source/src/vm/disk.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2006.09.16-
   6
   7         [ d88 handler ]
   8 */
   9
  10 #include "disk.h"
  11 #include "../fileio.h"
  12 #if defined(_USE_AGAR) || defined(_USE_SDL) || defined(_USE_QT)
  13 #include "agar_logger.h"
  14 #endif
  15
  16 // crc table
  17 static const uint16 crc_table[256] = {
  18         0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
  19         0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
  20         0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
  21         0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
  22         0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
  23         0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
  24         0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
  25         0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
  26         0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
  27         0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
  28         0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
  29         0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
  30         0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
  31         0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
  32         0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
  33         0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
  34 };
  35
  36 // teledisk decoder table
  37 static const uint8 d_code[256] = {
  38         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  39         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  40         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  41         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  42         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  43         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  44         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  45         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
  46         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  47         0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f,
  48         0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
  49         0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
  50         0x18, 0x18, 0x19, 0x19, 0x1a, 0x1a, 0x1b, 0x1b, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f, 0x1f,
  51         0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23, 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27,
  52         0x28, 0x28, 0x29, 0x29, 0x2a, 0x2a, 0x2b, 0x2b, 0x2c, 0x2c, 0x2d, 0x2d, 0x2e, 0x2e, 0x2f, 0x2f,
  53         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f
  54 };
  55 static const uint8 d_len[256] = {
  56         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  57         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  58         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  59         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  60         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  61         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  62         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  63         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  64         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  65         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  66         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  67         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  68         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  69         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  70         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  71         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
  72 };
  73 static const int secsize[8] = {
  74         128, 256, 512, 1024, 2048, 4096, 8192, 16384
  75 };
  76
  77 static uint8 tmp_buffer[DISK_BUFFER_SIZE];
  78
  79 typedef struct {
  80         int type;
  81         int ncyl, nside, nsec, size;
  82 } fd_format_t;
  83
  84 static const fd_format_t fd_formats[] = {
  85         { MEDIA_TYPE_2D,  40, 1, 16,  256 },    // 1D   160KB
  86         { MEDIA_TYPE_2D , 40, 2, 16,  256 },    // 2D   320KB
  87 #if defined(_MZ80B) || defined(_MZ2000) || defined(_MZ2200) || defined(_MZ2500)
  88         { MEDIA_TYPE_2DD, 80, 2, 16,  256 },    // 2DD  640KB (MZ-2500)
  89 #else
  90         { MEDIA_TYPE_2DD, 80, 2,  8,  512 },    // 2DD  640KB
  91 #endif
  92         { MEDIA_TYPE_2DD, 80, 2,  9,  512 },    // 2DD  720KB
  93         { MEDIA_TYPE_2HD, 80, 2, 15,  512 },    // 2HC 1.20MB
  94         { MEDIA_TYPE_2HD, 77, 2,  8, 1024 },    // 2HD 1.25MB
  95         { MEDIA_TYPE_144, 80, 2, 18,  512 },    // 2HD 1.44MB
  96         { MEDIA_TYPE_144, 80, 2, 36,  512 },    // 2ED 2.88MB
  97         { -1, 0, 0, 0, 0 },
  98 };
  99
 100 #define IS_VALID_TRACK(offset) ((offset) >= 0x20 && (offset) < sizeof(buffer))
 101
 102 void DISK::open(_TCHAR path[], int bank)
 103 {
 104         // check current disk image
 105         if(inserted) {
 106                 if(_tcsicmp(orig_path, path) == 0 && file_bank == bank) {
 107                         return;
 108                 }
 109                 close();
 110         }
 111         memset(buffer, 0, sizeof(buffer));
 112         media_type = MEDIA_TYPE_UNK;
 113         is_standard_image = is_fdi_image = false;
 114         trim_required = false;
 115
 116         // open disk image
 117         fi = new FILEIO();
 118         if(fi->Fopen(path, FILEIO_READ_BINARY)) {
 119                 bool converted = false;
 120
 121                 _tcscpy_s(orig_path, _MAX_PATH, path);
 122                 _tcscpy_s(dest_path, _MAX_PATH, path);
 123                 _stprintf_s(temp_path, _MAX_PATH, _T("%s.$$$"), path);
 124                 temporary = false;
 125
 126                 // check if file protected
 127                 write_protected = fi->IsProtected(path);
 128
 129                 // is this d88 format ?
 130                 if(check_file_extension(path, _T(".d88")) || check_file_extension(path, _T(".d77"))) {
 131                         uint32 offset = 0;
 132                         for(int i = 0; i < bank; i++) {
 133                                 fi->Fseek(offset + 0x1c, SEEK_SET);
 134                                 offset += fi->FgetUint32_LE();
 135                         }
 136                         fi->Fseek(offset + 0x1c, FILEIO_SEEK_SET);
 137                         file_size.d = fi->FgetUint32_LE();
 138                         fi->Fseek(offset, FILEIO_SEEK_SET);
 139                         fi->Fread(buffer, file_size.d, 1);
 140                         file_bank = bank;
 141                         inserted = changed = true;
 142                         trim_required = true;
 143 //                      trim_required = false;
 144                         goto file_loaded;
 145                 }
 146
 147                 fi->Fseek(0, FILEIO_SEEK_END);
 148                 file_size.d = fi->Ftell();
 149                 fi->Fseek(0, FILEIO_SEEK_SET);
 150                 file_bank = 0;
 151
 152 #if defined(_X1) || defined(_X1TWIN) || defined(_X1TURBO) || defined(_X1TURBOZ)
 153                 // is this 2d format ?
 154                 if(check_file_extension(path, _T(".2d"))) {
 155                         if(standard_to_d88(MEDIA_TYPE_2D, 40, 2, 16, 256)) {
 156                                 inserted = changed = is_standard_image = true;
 157                                 goto file_loaded;
 158                         }
 159                         fi->Fseek(0, FILEIO_SEEK_SET);
 160                 }
 161 #endif
 162
 163                 // check image file format
 164                 for(int i = 0;; i++) {
 165                         const fd_format_t *p = &fd_formats[i];
 166                         if(p->type == -1) {
 167                                 break;
 168                         }
 169                         int len = p->ncyl * p->nside * p->nsec * p->size;
 170                         // 4096 bytes: FDI header ???
 171                         if(file_size.d == len || (file_size.d == (len + 4096) && (len == 655360 || len == 1261568))) {
 172                                 if(file_size.d == len + 4096) {
 173                                         is_fdi_image = true;
 174                                         fi->Fread(fdi_header, 4096, 1);
 175                                 }
 176                                 if(standard_to_d88(p->type, p->ncyl, p->nside, p->nsec, p->size)) {
 177                                         inserted = changed = is_standard_image = true;
 178                                         goto file_loaded;
 179                                 }
 180                         }
 181                 }
 182                 if(0 < file_size.d && file_size.d <= DISK_BUFFER_SIZE) {
 183                         memset(buffer, 0, sizeof(buffer));
 184                         fi->Fread(buffer, file_size.d, 1);
 185
 186                         // check d88 format (temporary)
 187                         if(file_size.b.l == buffer[0x1c] && file_size.b.h == buffer[0x1d] && file_size.b.h2 == buffer[0x1e] && file_size.b.h3 == buffer[0x1f]) {
 188                                 inserted = changed = true;
 189                                 goto file_loaded;
 190                         }
 191                         _stprintf_s(dest_path, _MAX_PATH, _T("%s.D88"), path);
 192
 193                         // check file header
 194                         try {
 195                                 if(memcmp(buffer, "TD", 2) == 0 || memcmp(buffer, "td", 2) == 0) {
 196                                         // teledisk image file
 197                                         inserted = changed = converted = teledisk_to_d88();
 198                                 } else if(memcmp(buffer, "IMD", 3) == 0) {
 199                                         // imagedisk image file
 200                                         inserted = changed = converted = imagedisk_to_d88();
 201                                 } else if(memcmp(buffer, "MV - CPC", 8) == 0) {
 202                                         // standard cpdread image file
 203                                         inserted = changed = converted = cpdread_to_d88(0);
 204                                 } else if(memcmp(buffer, "EXTENDED", 8) == 0) {
 205                                         // extended cpdread image file
 206                                         inserted = changed = converted = cpdread_to_d88(1);
 207                                 }
 208                         } catch(...) {
 209                                 // failed to convert the disk image
 210                         }
 211                 }
 212 file_loaded:
 213                 if(fi->IsOpened()) {
 214                         fi->Fclose();
 215                 }
 216                 if(temporary) {
 217                         fi->Remove(temp_path);
 218                 }
 219                 if(inserted) {
 220 #if 0
 221                         if(converted) {
 222                                 // write image
 223                                 FILEIO* fio = new FILEIO();
 224                                 if(fio->Fopen(dest_path, FILEIO_WRITE_BINARY)) {
 225                                         fio->Fwrite(buffer, file_size.d, 1);
 226                                         fio->Fclose();
 227                                 }
 228                                 delete fio;
 229                         }
 230 #endif
 231                         crc32 = getcrc32(buffer, file_size.d);
 232                 }
 233                 if(buffer[0x1a] != 0) {
 234                         write_protected = true;
 235                 }
 236                 if(media_type == MEDIA_TYPE_UNK) {
 237                         if((media_type = buffer[0x1b]) == MEDIA_TYPE_2HD) {
 238                                 for(int trkside = 0; trkside < 164; trkside++) {
 239                                         pair offset;
 240                                         offset.read_4bytes_le_from(buffer + 0x20 + trkside * 4);
 241
 242                                         if(!IS_VALID_TRACK(offset.d)) {
 243                                                 continue;
 244                                         }
 245                                         // track found
 246                                         uint8 *t = buffer + offset.d;
 247                                         pair sector_num, data_size;
 248                                         sector_num.read_2bytes_le_from(t + 4);
 249                                         data_size.read_2bytes_le_from(t + 14);
 250
 251                                         if(sector_num.sd >= 18 && data_size.sd == 512) {
 252                                                 media_type = MEDIA_TYPE_144;
 253                                         }
 254                                         break;
 255                                 }
 256                         }
 257                 }
 258                 // FIXME: ugly patch for X1turbo ALPHA and Batten Tanuki
 259                 is_special_disk = 0;
 260 #if defined(_X1) || defined(_X1TWIN) || defined(_X1TURBO) || defined(_X1TURBOZ)
 261                 if(media_type == MEDIA_TYPE_2D) {
 262                         // check first sector
 263                         pair offset;
 264                         offset.read_4bytes_le_from(buffer + 0x20);
 265                         if(IS_VALID_TRACK(offset.d)) {
 266                                 static const uint8 batten[] = {0xca, 0xde, 0xaf, 0xc3, 0xdd, 0x20, 0xc0, 0xc7, 0xb7};
 267                                 uint8 *t = buffer + offset.d;
 268                                 if(strncmp((char *)(t + 0x11), "turbo ALPHA", 11) == 0) {
 269                                         is_special_disk = SPECIAL_DISK_X1_ALPHA;
 270                                 } else if(memcmp((void *)(t + 0x11), batten, sizeof(batten)) == 0) {
 271                                         is_special_disk = SPECIAL_DISK_X1_BATTEN;
 272                                 }
 273                         }
 274                 }
 275 #endif
 276         }
 277         delete fi;
 278 }
 279
 280 void DISK::close()
 281 {
 282         // write disk image
 283         if(inserted) {
 284                 if(trim_required) {
 285                         trim_buffer();
 286                         trim_required = false;
 287                 }
 288                 if(!write_protected && file_size.d && getcrc32(buffer, file_size.d) != crc32) {
 289                         // write image
 290                         FILEIO* fio = new FILEIO();
 291                         int pre_size = 0, post_size = 0;
 292                         uint8 *pre_buffer = NULL, *post_buffer = NULL;
 293
 294                         // is this d88 format ?
 295                         if(check_file_extension(dest_path, _T(".d88")) || check_file_extension(dest_path, _T(".d77"))) {
 296                                 if(fio->Fopen(dest_path, FILEIO_READ_BINARY)) {
 297                                         fio->Fseek(0, FILEIO_SEEK_END);
 298                                         uint32 total_size = fio->Ftell(), offset = 0;
 299                                         for(int i = 0; i < file_bank; i++) {
 300                                                 fio->Fseek(offset + 0x1c, SEEK_SET);
 301                                                 offset += fio->FgetUint32_LE();
 302                                         }
 303                                         if((pre_size = offset) > 0) {
 304                                                 pre_buffer = (uint8 *)malloc(pre_size);
 305                                                 fio->Fseek(0, FILEIO_SEEK_SET);
 306                                                 fio->Fread(pre_buffer, pre_size, 1);
 307                                         }
 308                                         fio->Fseek(offset + 0x1c, SEEK_SET);
 309                                         offset += fio->FgetUint32_LE();
 310                                         if((post_size = total_size - offset) > 0) {
 311                                                 post_buffer = (uint8 *)malloc(post_size);
 312                                                 fio->Fseek(offset, FILEIO_SEEK_SET);
 313                                                 fio->Fread(post_buffer, post_size, 1);
 314                                         }
 315                                         fio->Fclose();
 316                                 }
 317                         }
 318                         if(!fio->Fopen(dest_path, FILEIO_WRITE_BINARY)) {
 319                                 _TCHAR tmp_path[_MAX_PATH];
 320                                 _stprintf_s(tmp_path, _MAX_PATH, _T("temporary_saved_floppy_disk_#%d.d88"), drive_num);
 321                                 fio->Fopen(emu->bios_path(tmp_path), FILEIO_WRITE_BINARY);
 322                         }
 323                         if(fio->IsOpened()) {
 324                                 if(pre_buffer) {
 325                                         fio->Fwrite(pre_buffer, pre_size, 1);
 326                                 }
 327                                 if(is_standard_image) {
 328                                         if(is_fdi_image) {
 329                                                 fio->Fwrite(fdi_header, 4096, 1);
 330                                         }
 331                                         for(int trkside = 0; trkside < 164; trkside++) {
 332                                                 pair offset;
 333                                                 offset.read_4bytes_le_from(buffer + 0x20 + trkside * 4);
 334
 335                                                 if(!IS_VALID_TRACK(offset.d)) {
 336                                                         break;
 337                                                 }
 338                                                 uint8* t = buffer + offset.d;
 339                                                 pair sector_num, data_size;
 340                                                 sector_num.read_2bytes_le_from(t + 4);
 341
 342                                                 for(int i = 0; i < sector_num.sd; i++) {
 343                                                         data_size.read_2bytes_le_from(t + 14);
 344                                                         fio->Fwrite(t + 0x10, data_size.sd, 1);
 345                                                         t += data_size.sd + 0x10;
 346                                                 }
 347                                         }
 348                                 } else {
 349                                         fio->Fwrite(buffer, file_size.d, 1);
 350                                 }
 351                                 if(post_buffer) {
 352                                         fio->Fwrite(post_buffer, post_size, 1);
 353                                 }
 354                                 fio->Fclose();
 355                         }
 356                         if(pre_buffer) {
 357                                 free(pre_buffer);
 358                         }
 359                         if(post_buffer) {
 360                                 free(post_buffer);
 361                         }
 362                         delete fio;
 363                 }
 364                 ejected = true;
 365         }
 366         inserted = write_protected = false;
 367         file_size.d = 0;
 368         sector_size.sd = sector_num.sd = 0;
 369         sector = NULL;
 370 }
 371
 372 bool DISK::get_track(int trk, int side)
 373 {
 374         sector_size.sd = sector_num.sd = 0;
 375         no_skew = true;
 376
 377         // disk not inserted or invalid media type
 378         if(!(inserted && check_media_type())) {
 379                 return false;
 380         }
 381
 382         // search track
 383         int trkside = trk * 2 + (side & 1);
 384         if(!(0 <= trkside && trkside < 164)) {
 385                 return false;
 386         }
 387         pair offset;
 388         offset.read_4bytes_le_from(buffer + 0x20 + trkside * 4);
 389
 390         if(!IS_VALID_TRACK(offset.d)) {
 391                 return false;
 392         }
 393
 394         // track found
 395         sector = buffer + offset.d;
 396         sector_num.read_2bytes_le_from(sector + 4);
 397
 398         // create each sector position in track
 399         int sync_size  = drive_mfm ? 12 : 6;
 400         int am_size = drive_mfm ? 3 : 0;
 401         int gap2_size = drive_mfm ? 22 : 11;
 402
 403         data_size_shift = 0;
 404         too_many_sectors = false;
 405 retry:
 406         uint8* t = sector;
 407         int total = 0, gap3_size;
 408
 409         for(int i = 0; i < sector_num.sd; i++) {
 410                 pair data_size;
 411                 data_size.read_2bytes_le_from(t + 14);
 412                 if((data_size.sd >> data_size_shift) < 0x80) {
 413                         too_many_sectors = true;
 414                         break;
 415                 }
 416                 total += sync_size + (am_size + 1) + (4 + 2) + gap2_size + sync_size + (am_size + 1);
 417                 total += (data_size.sd >> data_size_shift) + 2;
 418                 t += data_size.sd + 0x10;
 419         }
 420         if(too_many_sectors) {
 421                 // Too many sectors in this track
 422                 gap3_size = 32;
 423                 data_size_shift = 0;
 424         } else if((gap3_size = (get_track_size() - total) / (sector_num.sd + 2)) < 12) {
 425                 // ID:N is modified
 426                 data_size_shift++;
 427                 goto retry;
 428         }
 429         t = sector;
 430         total = gap3_size * 2;
 431
 432         for(int i = 0; i < sector_num.sd; i++) {
 433                 pair data_size;
 434                 data_size.read_2bytes_le_from(t + 14);
 435                 if(too_many_sectors) {
 436                         total = gap3_size * 2 + (get_track_size() - gap3_size * 2) * i / sector_num.sd;
 437                 }
 438                 sync_position[i] = total;
 439                 total += sync_size + (am_size + 1);
 440                 id_position[i] = total;
 441                 total += (4 + 2) + gap2_size + sync_size + (am_size + 1);
 442                 data_position[i] = total;
 443                 total += (data_size.sd >> data_size_shift) + 2 + gap3_size;
 444                 if(t[2] != i + 1) {
 445                         no_skew = false;
 446                 }
 447                 t += data_size.sd + 0x10;
 448         }
 449         return true;
 450 }
 451
 452 bool DISK::make_track(int trk, int side)
 453 {
 454         int track_size = get_track_size();
 455
 456         if(!get_track(trk, side)) {
 457                 // create a dummy track
 458                 for(int i = 0; i < track_size; i++) {
 459                         track[i] = rand();
 460                 }
 461                 return false;
 462         }
 463
 464         // make track image
 465         int sync_size  = drive_mfm ? 12 : 6;
 466         int am_size = drive_mfm ? 3 : 0;
 467         int gap2_size = drive_mfm ? 22 : 11;
 468         uint8 gap_data = drive_mfm ? 0x4e : 0xff;
 469
 470         // preamble
 471         memset(track, gap_data, track_size);
 472
 473         if(sync_position[0] >= (sync_size + am_size + 1) + (8 + 5)) {
 474                 int p = (sync_position[0] - (sync_size + am_size + 1)) * 8 / (8 + 5);
 475
 476                 // sync
 477                 for(int i = 0; i < sync_size; i++) {
 478                         track[p++] = 0x00;
 479                 }
 480                 // index mark
 481                 for(int i = 0; i < am_size; i++) {
 482                         track[p++] = 0xc2;
 483                 }
 484                 track[p++] = 0xfc;
 485         }
 486
 487         // sectors
 488         uint8 *t = sector;
 489
 490         for(int i = 0; i < sector_num.sd; i++) {
 491                 pair data_size;
 492                 data_size.read_2bytes_le_from(t + 14);
 493                 int p = sync_position[i];
 494
 495                 // sync
 496                 for(int j = 0; j < sync_size; j++) {
 497                         if(p < track_size) track[p++] = 0x00;
 498                 }
 499                 // am1
 500                 for(int j = 0; j < am_size; j++) {
 501                         if(p < track_size) track[p++] = 0xa1;
 502                 }
 503                 if(p < track_size) track[p++] = 0xfe;
 504                 // id
 505                 if(p < track_size) track[p++] = t[0];
 506                 if(p < track_size) track[p++] = t[1];
 507                 if(p < track_size) track[p++] = t[2];
 508                 if(p < track_size) track[p++] = t[3];
 509                 uint16 crc = 0;
 510                 crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[0]]);
 511                 crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[1]]);
 512                 crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[2]]);
 513                 crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[3]]);
 514                 if(p < track_size) track[p++] = (crc >> 8) & 0xff;
 515                 if(p < track_size) track[p++] = (crc >> 0) & 0xff;
 516                 // gap2
 517                 for(int j = 0; j < gap2_size; j++) {
 518                         if(p < track_size) track[p++] = gap_data;
 519                 }
 520                 // sync
 521                 for(int j = 0; j < sync_size; j++) {
 522                         if(p < track_size) track[p++] = 0x00;
 523                 }
 524                 // am2
 525                 for(int j = 0; j < am_size; j++) {
 526                         if(p < track_size) track[p++] = 0xa1;
 527                 }
 528                 if(p < track_size) track[p++] = (t[7] != 0) ? 0xf8 : 0xfb;
 529                 // data
 530                 crc = 0;
 531                 for(int j = 0; j < (data_size.sd >> data_size_shift); j++) {
 532                         if(p < track_size) track[p++] = t[0x10 + j];
 533                         crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[0x10 + j]]);
 534                 }
 535                 if(p < track_size) track[p++] = (crc >> 8) & 0xff;
 536                 if(p < track_size) track[p++] = (crc >> 0) & 0xff;
 537
 538                 t += data_size.sd + 0x10;
 539         }
 540         return true;
 541 }
 542
 543 bool DISK::get_sector(int trk, int side, int index)
 544 {
 545         sector_size.sd = sector_num.sd = 0;
 546         sector = NULL;
 547
 548         // disk not inserted or invalid media type
 549         if(!(inserted && check_media_type())) {
 550                 return false;
 551         }
 552
 553         // search track
 554         int trkside = trk * 2 + (side & 1);
 555         if(!(0 <= trkside && trkside < 164)) {
 556                 return false;
 557         }
 558         pair offset;
 559         offset.read_4bytes_le_from(buffer + 0x20 + trkside * 4);
 560
 561         if(!IS_VALID_TRACK(offset.d)) {
 562                 return false;
 563         }
 564
 565         // track found
 566         uint8* t = buffer + offset.d;
 567         sector_num.read_2bytes_le_from(t + 4);
 568
 569         if(index >= sector_num.sd) {
 570                 return false;
 571         }
 572
 573         // skip sector
 574         for(int i = 0; i < index; i++) {
 575                 pair data_size;
 576                 data_size.read_2bytes_le_from(t + 14);
 577                 t += data_size.sd + 0x10;
 578         }
 579         set_sector_info(t);
 580         return true;
 581 }
 582
 583 void DISK::set_sector_info(uint8 *t)
 584 {
 585         // header info
 586         id[0] = t[0];
 587         id[1] = t[1];
 588         id[2] = t[2];
 589         id[3] = t[3];
 590         uint16 crc = 0;
 591         crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[0]]);
 592         crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[1]]);
 593         crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[2]]);
 594         crc = (uint16)((crc << 8) ^ crc_table[(uint8)(crc >> 8) ^ t[3]]);
 595         id[4] = (crc >> 8) & 0xff;
 596         id[5] = (crc >> 0) & 0xff;
 597         density = t[6];
 598         deleted = (t[7] != 0);
 599         crc_error = (t[8] != 0x00 && t[8] != 0x10);
 600         sector = t + 0x10;
 601         sector_size.read_2bytes_le_from(t + 14);
 602 }
 603
 604 void DISK::set_deleted(bool value)
 605 {
 606         if(sector != NULL) {
 607                 uint8 *t = sector - 0x10;
 608                 t[7] = value ? 0x10 : 0;
 609                 if(t[8] == 0x00 || t[8] == 0x10) {
 610                         t[8] = t[7];
 611                 }
 612         }
 613         deleted = value;
 614 }
 615
 616 void DISK::set_crc_error(bool value)
 617 {
 618         if(sector != NULL) {
 619                 uint8 *t = sector - 0x10;
 620                 t[8] = value ? 0xb0 : t[7];
 621         }
 622         crc_error = value;
 623 }
 624
 625 bool DISK::format_track(int trk, int side)
 626 {
 627         // disk not inserted or invalid media type
 628         if(!(inserted && check_media_type())) {
 629                 return false;
 630         }
 631
 632         // search track
 633         int trkside = trk * 2 + (side & 1);
 634         if(!(0 <= trkside && trkside < 164)) {
 635                 return false;
 636         }
 637
 638         // create new empty track
 639         if(trim_required) {
 640                 trim_buffer();
 641                 trim_required = false;
 642         }
 643         memset(buffer + DISK_BUFFER_SIZE, 0, sizeof(buffer) - DISK_BUFFER_SIZE);
 644         pair offset;
 645         offset.d = DISK_BUFFER_SIZE;
 646         offset.write_4bytes_le_to(buffer + 0x20 + trkside * 4);
 647
 648         trim_required = true;
 649         sector_num.sd = 0;
 650         return true;
 651 }
 652
 653 void DISK::insert_sector(uint8 c, uint8 h, uint8 r, uint8 n, bool deleted, bool crc_error, uint8 fill_data, int length)
 654 {
 655         uint8* t = buffer + DISK_BUFFER_SIZE;
 656
 657         sector_num.sd++;
 658         for(int i = 0; i < (sector_num.sd - 1); i++) {
 659                 t[4] = sector_num.b.l;
 660                 t[5] = sector_num.b.h;
 661                 pair data_size;
 662                 data_size.read_2bytes_le_from(t + 14);
 663                 t += data_size.sd + 0x10;
 664         }
 665         t[0] = c;
 666         t[1] = h;
 667         t[2] = r;
 668         t[3] = n;
 669         t[4] = sector_num.b.l;
 670         t[5] = sector_num.b.h;
 671         t[6] = drive_mfm ? 0 : 0x40;
 672         t[7] = deleted ? 0x10 : 0;
 673         t[8] = crc_error ? 0xb0 : t[7];
 674         t[14] = (length >> 0) & 0xff;
 675         t[15] = (length >> 8) & 0xff;
 676         memset(t + 16, fill_data, length);
 677
 678         set_sector_info(t);
 679 }
 680
 681 void DISK::trim_buffer()
 682 {
 683         int max_tracks = 164;
 684         uint32 dest_offset = 0x2b0;
 685
 686         // copy header
 687         memset(tmp_buffer, 0, sizeof(tmp_buffer));
 688         memcpy(tmp_buffer, buffer, 0x20);
 689
 690         // check max tracks
 691         for(int trkside = 0; trkside < 164; trkside++) {
 692                 pair src_trk_offset;
 693                 src_trk_offset.read_4bytes_le_from(buffer + 0x20 + trkside * 4);
 694                 if(src_trk_offset.d != 0) {
 695 #if 1
 696                         if(src_trk_offset.d < 0x2b0) {
 697                                 max_tracks = (src_trk_offset.d - 0x20) >> 2;
 698                         }
 699 #else
 700                         if(src_trk_offset.d != 0x2b0) {
 701                                 max_tracks = (src_trk_offset.d - 0x20) >> 2;
 702                                 if(max_tracks > 164) {
 703                                         dest_offset = 0x20 + max_tracks * 4);
 704                                 }
 705                         }
 706 #endif
 707                         break;
 708                 }
 709         }
 710
 711         // copy tracks
 712         for(int trkside = 0; trkside < max_tracks; trkside++) {
 713                 pair src_trk_offset;
 714                 src_trk_offset.read_4bytes_le_from(buffer + 0x20 + trkside * 4);
 715
 716                 pair dest_trk_offset;
 717                 dest_trk_offset.d = 0;
 718
 719                 if(IS_VALID_TRACK(src_trk_offset.d)) {
 720                         uint8* t = buffer + src_trk_offset.d;
 721                         pair sector_num, data_size;
 722                         sector_num.read_2bytes_le_from(t + 4);
 723                         if(sector_num.sd != 0) {
 724                                 dest_trk_offset.d = dest_offset;
 725                                 for(int i = 0; i < sector_num.sd; i++) {
 726                                         data_size.read_2bytes_le_from(t + 14);
 727                                         memcpy(tmp_buffer + dest_offset, t, data_size.sd + 0x10);
 728                                         dest_offset += data_size.sd + 0x10;
 729                                         t += data_size.sd + 0x10;
 730                                 }
 731                         }
 732                 }
 733                 dest_trk_offset.write_4bytes_le_to(tmp_buffer + 0x20 + trkside * 4);
 734         }
 735
 736         // update file size
 737         file_size.d = dest_offset;
 738         file_size.write_4bytes_le_to(tmp_buffer + 0x1c);
 739
 740         memset(buffer, 0, sizeof(buffer));
 741         memcpy(buffer, tmp_buffer, file_size.d);
 742 }
 743
 744 int DISK::get_rpm()
 745 {
 746         if(drive_rpm != 0) {
 747                 return drive_rpm;
 748         } else if(inserted) {
 749                 return (media_type == MEDIA_TYPE_2HD) ? 360 : 300;
 750         } else {
 751                 return (drive_type == DRIVE_TYPE_2HD) ? 360 : 300;
 752         }
 753 }
 754
 755 int DISK::get_track_size()
 756 {
 757         if(inserted) {
 758                 return media_type == MEDIA_TYPE_144 ? 12500 : media_type == MEDIA_TYPE_2HD ? 10410 : drive_mfm ? 6250 : 3100;
 759         } else {
 760                 return drive_type == DRIVE_TYPE_144 ? 12500 : drive_type == DRIVE_TYPE_2HD ? 10410 : drive_mfm ? 6250 : 3100;
 761         }
 762 }
 763
 764 double DISK::get_usec_per_bytes(int bytes)
 765 {
 766         return 1000000.0 / (get_track_size() * (get_rpm() / 60.0)) * bytes;
 767 }
 768
 769 bool DISK::check_media_type()
 770 {
 771         switch(drive_type) {
 772         case DRIVE_TYPE_2D:
 773                 return (media_type == MEDIA_TYPE_2D);
 774         case DRIVE_TYPE_2DD:
 775                 return (media_type == MEDIA_TYPE_2D || media_type == MEDIA_TYPE_2DD);
 776         case DRIVE_TYPE_2HD:
 777                 return (media_type == MEDIA_TYPE_2HD);
 778         case DRIVE_TYPE_144:
 779                 return (media_type == MEDIA_TYPE_144);
 780         case DRIVE_TYPE_UNK:
 781                 return true; // always okay
 782         }
 783         return false;
 784 }
 785
 786 // teledisk image decoder
 787
 788 /*
 789         this teledisk image decoder is based on:
 790
 791                 LZHUF.C English version 1.0 based on Japanese version 29-NOV-1988
 792                 LZSS coded by Haruhiko OKUMURA
 793                 Adaptive Huffman Coding coded by Haruyasu YOSHIZAKI
 794                 Edited and translated to English by Kenji RIKITAKE
 795                 TDLZHUF.C by WTK
 796 */
 797
 798 #define COPYBUFFER(src, size) { \
 799         if(file_size.d + (size) > DISK_BUFFER_SIZE) { \
 800                 return false; \
 801         } \
 802         memcpy(buffer + file_size.d, (src), (size)); \
 803         file_size.d += (size); \
 804 }
 805
 806 bool DISK::teledisk_to_d88()
 807 {
 808         td_hdr_t hdr;
 809         td_cmt_t cmt;
 810         td_trk_t trk;
 811         td_sct_t sct;
 812         d88_hdr_t d88_hdr;
 813         d88_sct_t d88_sct;
 814         uint8 obuf[512];
 815
 816         // check teledisk header
 817         fi->Fseek(0, FILEIO_SEEK_SET);
 818         fi->Fread(&hdr, sizeof(td_hdr_t), 1);
 819         if(hdr.sig[0] == 't' && hdr.sig[1] == 'd') {
 820                 // decompress to the temporary file
 821                 FILEIO* fo = new FILEIO();
 822                 if(!fo->Fopen(temp_path, FILEIO_WRITE_BINARY)) {
 823                         delete fo;
 824                         return false;
 825                 }
 826                 int rd = 1;
 827                 init_decode();
 828                 do {
 829                         if((rd = decode(obuf, 512)) > 0) {
 830                                 fo->Fwrite(obuf, rd, 1);
 831                         }
 832                 }
 833                 while(rd > 0);
 834                 fo->Fclose();
 835                 delete fo;
 836                 temporary = true;
 837
 838                 // reopen the temporary file
 839                 fi->Fclose();
 840                 if(!fi->Fopen(temp_path, FILEIO_READ_BINARY)) {
 841                         return false;
 842                 }
 843         }
 844         if(hdr.flag & 0x80) {
 845                 // skip comment
 846                 fi->Fread(&cmt, sizeof(td_cmt_t), 1);
 847                 fi->Fseek(cmt.len, FILEIO_SEEK_CUR);
 848         }
 849
 850         // create d88 image
 851         file_size.d = 0;
 852
 853         // create d88 header
 854         memset(&d88_hdr, 0, sizeof(d88_hdr_t));
 855         _strcpy_s(d88_hdr.title, sizeof(d88_hdr.title), "TELEDISK");
 856         d88_hdr.protect = 0; // non-protected
 857         COPYBUFFER(&d88_hdr, sizeof(d88_hdr_t));
 858
 859         // create tracks
 860         int trkcnt = 0, trkptr = sizeof(d88_hdr_t);
 861         fi->Fread(&trk, sizeof(td_trk_t), 1);
 862         while(trk.nsec != 0xff) {
 863                 d88_hdr.trkptr[trkcnt++] = trkptr;
 864                 if(hdr.sides == 1) {
 865                         d88_hdr.trkptr[trkcnt++] = trkptr;
 866                 }
 867
 868                 // read sectors in this track
 869                 for(int i = 0; i < trk.nsec; i++) {
 870                         uint8 buf[2048], dst[2048];
 871                         memset(buf, 0, sizeof(buf));
 872                         memset(dst, 0, sizeof(dst));
 873
 874                         // read sector header
 875                         fi->Fread(&sct, sizeof(td_sct_t), 1);
 876
 877                         // create d88 sector header
 878                         memset(&d88_sct, 0, sizeof(d88_sct_t));
 879                         d88_sct.c = sct.c;
 880                         d88_sct.h = sct.h;
 881                         d88_sct.r = sct.r;
 882                         d88_sct.n = sct.n;
 883                         d88_sct.nsec = trk.nsec;
 884                         d88_sct.dens = (hdr.dens & 0x80) ? 0x40 : 0;
 885                         d88_sct.del = (sct.ctrl & 4) ? 0x10 : 0;
 886                         d88_sct.stat = (sct.ctrl & 2) ? 0xb0 : d88_sct.del;
 887                         d88_sct.size = secsize[sct.n & 3];
 888
 889                         // create sector image
 890                         if(sct.ctrl != 0x10) {
 891                                 // read sector source
 892                                 int len = fi->Fgetc();
 893                                 len += fi->Fgetc() * 256 - 1;
 894                                 int flag = fi->Fgetc(), d = 0;
 895                                 fi->Fread(buf, len, 1);
 896
 897                                 // convert
 898                                 if(flag == 0) {
 899                                         memcpy(dst, buf, len);
 900                                 } else if(flag == 1) {
 901                                         pair len2;
 902                                         len2.read_2bytes_le_from(buf);
 903                                         while(len2.sd--) {
 904                                                 dst[d++] = buf[2];
 905                                                 dst[d++] = buf[3];
 906                                         }
 907                                 } else if(flag == 2) {
 908                                         for(int s = 0; s < len;) {
 909                                                 int type = buf[s++];
 910                                                 int len2 = buf[s++];
 911                                                 if(type == 0) {
 912                                                         while(len2--) {
 913                                                                 dst[d++] = buf[s++];
 914                                                         }
 915                                                 } else if(type < 5) {
 916                                                         uint8 pat[256];
 917                                                         int n = 2;
 918                                                         while(type-- > 1) {
 919                                                                 n *= 2;
 920                                                         }
 921                                                         for(int j = 0; j < n; j++) {
 922                                                                 pat[j] = buf[s++];
 923                                                         }
 924                                                         while(len2--) {
 925                                                                 for(int j = 0; j < n; j++) {
 926                                                                         dst[d++] = pat[j];
 927                                                                 }
 928                                                         }
 929                                                 } else {
 930                                                         break; // unknown type
 931                                                 }
 932                                         }
 933                                 } else {
 934                                         break; // unknown flag
 935                                 }
 936                         } else {
 937                                 d88_sct.size = 0;
 938                         }
 939
 940                         // copy to d88
 941                         COPYBUFFER(&d88_sct, sizeof(d88_sct_t));
 942                         COPYBUFFER(dst, d88_sct.size);
 943                         trkptr += sizeof(d88_sct_t) + d88_sct.size;
 944                 }
 945                 // read next track
 946                 fi->Fread(&trk, sizeof(td_trk_t), 1);
 947         }
 948         d88_hdr.type = ((hdr.dens & 3) == 2) ? MEDIA_TYPE_2HD : ((trkcnt >> 1) > 60) ? MEDIA_TYPE_2DD : MEDIA_TYPE_2D;
 949         d88_hdr.size = trkptr;
 950         memcpy(buffer, &d88_hdr, sizeof(d88_hdr_t));
 951         return true;
 952 }
 953
 954 int DISK::next_word()
 955 {
 956         if(ibufndx >= ibufcnt) {
 957                 ibufndx = ibufcnt = 0;
 958                 memset(inbuf, 0, 512);
 959                 for(int i = 0; i < 512; i++) {
 960                         int d = fi->Fgetc();
 961                         if(d == EOF) {
 962                                 if(i) {
 963                                         break;
 964                                 }
 965                                 return(-1);
 966                         }
 967                         inbuf[i] = d;
 968                         ibufcnt = i + 1;
 969                 }
 970         }
 971         while(getlen <= 8) {
 972                 getbuf |= inbuf[ibufndx++] << (8 - getlen);
 973                 getlen += 8;
 974         }
 975         return 0;
 976 }
 977
 978 int DISK::get_bit()
 979 {
 980         if(next_word() < 0) {
 981                 return -1;
 982         }
 983         short i = getbuf;
 984         getbuf <<= 1;
 985         getlen--;
 986         return (i < 0) ? 1 : 0;
 987 }
 988
 989 int DISK::get_byte()
 990 {
 991         if(next_word() != 0) {
 992                 return -1;
 993         }
 994         uint16 i = getbuf;
 995         getbuf <<= 8;
 996         getlen -= 8;
 997         i >>= 8;
 998         return (int)i;
 999 }
1000
1001 void DISK::start_huff()
1002 {
1003         int i, j;
1004         for(i = 0; i < N_CHAR; i++) {
1005                 freq[i] = 1;
1006                 son[i] = i + TABLE_SIZE;
1007                 prnt[i + TABLE_SIZE] = i;
1008         }
1009         i = 0; j = N_CHAR;
1010         while(j <= ROOT_POSITION) {
1011                 freq[j] = freq[i] + freq[i + 1];
1012                 son[j] = i;
1013                 prnt[i] = prnt[i + 1] = j;
1014                 i += 2; j++;
1015         }
1016         freq[TABLE_SIZE] = 0xffff;
1017         prnt[ROOT_POSITION] = 0;
1018 }
1019
1020 void DISK::reconst()
1021 {
1022         short i, j = 0, k;
1023         uint16 f, l;
1024         for(i = 0; i < TABLE_SIZE; i++) {
1025                 if(son[i] >= TABLE_SIZE) {
1026                         freq[j] = (freq[i] + 1) / 2;
1027                         son[j] = son[i];
1028                         j++;
1029                 }
1030         }
1031         for(i = 0, j = N_CHAR; j < TABLE_SIZE; i += 2, j++) {
1032                 k = i + 1;
1033                 f = freq[j] = freq[i] + freq[k];
1034                 for(k = j - 1; f < freq[k]; k--);
1035                 k++;
1036                 l = (j - k) * 2;
1037                 memmove(&freq[k + 1], &freq[k], l);
1038                 freq[k] = f;
1039                 memmove(&son[k + 1], &son[k], l);
1040                 son[k] = i;
1041         }
1042         for(i = 0; i < TABLE_SIZE; i++) {
1043                 if((k = son[i]) >= TABLE_SIZE) {
1044                         prnt[k] = i;
1045                 } else {
1046                         prnt[k] = prnt[k + 1] = i;
1047                 }
1048         }
1049 }
1050
1051 void DISK::update(int c)
1052 {
1053         int i, j, k, l;
1054         if(freq[ROOT_POSITION] == MAX_FREQ) {
1055                 reconst();
1056         }
1057         c = prnt[c + TABLE_SIZE];
1058         do {
1059                 k = ++freq[c];
1060                 if(k > freq[l = c + 1]) {
1061                         while(k > freq[++l]);
1062                         l--;
1063                         freq[c] = freq[l];
1064                         freq[l] = k;
1065                         i = son[c];
1066                         prnt[i] = l;
1067                         if(i < TABLE_SIZE) {
1068                                 prnt[i + 1] = l;
1069                         }
1070                         j = son[l];
1071                         son[l] = i;
1072                         prnt[j] = c;
1073                         if(j < TABLE_SIZE) {
1074                                 prnt[j + 1] = c;
1075                         }
1076                         son[c] = j;
1077                         c = l;
1078                 }
1079         }
1080         while((c = prnt[c]) != 0);
1081 }
1082
1083 short DISK::decode_char()
1084 {
1085         int ret;
1086         uint16 c = son[ROOT_POSITION];
1087         while(c < TABLE_SIZE) {
1088                 if((ret = get_bit()) < 0) {
1089                         return -1;
1090                 }
1091                 c += (unsigned)ret;
1092                 c = son[c];
1093         }
1094         c -= TABLE_SIZE;
1095         update(c);
1096         return c;
1097 }
1098
1099 short DISK::decode_position()
1100 {
1101         short bit;
1102         uint16 i, j, c;
1103         if((bit = get_byte()) < 0) {
1104                 return -1;
1105         }
1106         i = (uint16)bit;
1107         c = (uint16)d_code[i] << 6;
1108         j = d_len[i] - 2;
1109         while(j--) {
1110                 if((bit = get_bit()) < 0) {
1111                          return -1;
1112                 }
1113                 i = (i << 1) + bit;
1114         }
1115         return (c | i & 0x3f);
1116 }
1117
1118 void DISK::init_decode()
1119 {
1120         ibufcnt= ibufndx = bufcnt = getbuf = 0;
1121         getlen = 0;
1122         start_huff();
1123         for(int i = 0; i < STRING_BUFFER_SIZE - LOOKAHEAD_BUFFER_SIZE; i++) {
1124                 text_buf[i] = ' ';
1125         }
1126         ptr = STRING_BUFFER_SIZE - LOOKAHEAD_BUFFER_SIZE;
1127 }
1128
1129 int DISK::decode(uint8 *buf, int len)
1130 {
1131         short c, pos;
1132         int  count;
1133         for(count = 0; count < len;) {
1134                 if(bufcnt == 0) {
1135                         if((c = decode_char()) < 0) {
1136                                 return count;
1137                         }
1138                         if(c < 256) {
1139                                 *(buf++) = (uint8)c;
1140                                 text_buf[ptr++] = (uint8)c;
1141                                 ptr &= (STRING_BUFFER_SIZE - 1);
1142                                 count++;
1143                         } else {
1144                                 if((pos = decode_position()) < 0) {
1145                                         return count;
1146                                 }
1147                                 bufpos = (ptr - pos - 1) & (STRING_BUFFER_SIZE - 1);
1148                                 bufcnt = c - 255 + THRESHOLD;
1149                                 bufndx = 0;
1150                         }
1151                 } else {
1152                         while(bufndx < bufcnt && count < len) {
1153                                 c = text_buf[(bufpos + bufndx) & (STRING_BUFFER_SIZE - 1)];
1154                                 *(buf++) = (uint8)c;
1155                                 bufndx++;
1156                                 text_buf[ptr++] = (uint8)c;
1157                                 ptr &= (STRING_BUFFER_SIZE - 1);
1158                                 count++;
1159                         }
1160                         if(bufndx >= bufcnt) {
1161                                 bufndx = bufcnt = 0;
1162                         }
1163                 }
1164         }
1165         return count;
1166 }
1167
1168 // imagedisk image decoder
1169
1170 bool DISK::imagedisk_to_d88()
1171 {
1172         imd_trk_t trk;
1173         d88_hdr_t d88_hdr;
1174         d88_sct_t d88_sct;
1175
1176         // skip comment
1177         fi->Fseek(0, FILEIO_SEEK_SET);
1178         int tmp;
1179         while((tmp = fi->Fgetc()) != 0x1a) {
1180                 if(tmp == EOF) {
1181                         return false;
1182                 }
1183         }
1184
1185         // create d88 image
1186         file_size.d = 0;
1187
1188         // create d88 header
1189         memset(&d88_hdr, 0, sizeof(d88_hdr_t));
1190         _strcpy_s(d88_hdr.title, sizeof(d88_hdr.title), "IMAGEDISK");
1191         d88_hdr.protect = 0; // non-protected
1192         COPYBUFFER(&d88_hdr, sizeof(d88_hdr_t));
1193
1194         // create tracks
1195         int trkptr = sizeof(d88_hdr_t);
1196         int trkcnt = 0, mode;
1197
1198         for(int t = 0; t < 164; t++) {
1199                 // check end of file
1200                 if(fi->Fread(&trk, sizeof(imd_trk_t), 1) != 1) {
1201                         break;
1202                 }
1203                 trkcnt = t;
1204
1205                 // check track header
1206                 if(t == 0) {
1207                         mode = trk.mode % 3; // 0=500kbps, 1=300kbps, 2=250kbps
1208                 }
1209                 if(!trk.nsec) {
1210                         continue;
1211                 }
1212                 d88_hdr.trkptr[t] = trkptr;
1213
1214                 // setup sector id
1215                 uint8 c[64], h[64], r[64];
1216                 fi->Fread(r, trk.nsec, 1);
1217                 if(trk.head & 0x80) {
1218                         fi->Fread(c, trk.nsec, 1);
1219                 } else {
1220                         memset(c, trk.cyl, sizeof(c));
1221                 }
1222                 if(trk.head & 0x40) {
1223                         fi->Fread(h, trk.nsec, 1);
1224                 } else {
1225                         memset(h, trk.head & 1, sizeof(h));
1226                 }
1227
1228                 // read sectors in this track
1229                 for(int i = 0; i < trk.nsec; i++) {
1230                         // create d88 sector header
1231                         int sectype = fi->Fgetc();
1232                         if(sectype > 8) {
1233                                 return false;
1234                         }
1235                         memset(&d88_sct, 0, sizeof(d88_sct_t));
1236                         d88_sct.c = c[i];
1237                         d88_sct.h = h[i];
1238                         d88_sct.r = r[i];
1239                         d88_sct.n = trk.size;
1240                         d88_sct.nsec = trk.nsec;
1241                         d88_sct.dens = (trk.mode < 3) ? 0x40 : 0;
1242                         d88_sct.del = (sectype == 3 || sectype == 4 || sectype == 7 || sectype == 8) ? 0x10 : 0;
1243                         d88_sct.stat = (sectype == 5 || sectype == 6 || sectype == 7 || sectype == 8) ? 0xb0 : d88_sct.del;
1244                         d88_sct.size = secsize[trk.size & 7];
1245
1246                         // create sector image
1247                         uint8 dst[8192];
1248                         if(sectype == 1 || sectype == 3 || sectype == 5 || sectype == 7) {
1249                                 // uncompressed
1250                                 fi->Fread(dst, d88_sct.size, 1);
1251                         } else if(sectype == 2 || sectype == 4 || sectype == 6 || sectype == 8) {
1252                                 // compressed
1253                                 int tmp = fi->Fgetc();
1254                                 memset(dst, tmp, d88_sct.size);
1255                         } else {
1256                                 d88_sct.size = 0;
1257                         }
1258
1259                         // copy to d88
1260                         COPYBUFFER(&d88_sct, sizeof(d88_sct_t));
1261                         COPYBUFFER(dst, d88_sct.size);
1262                         trkptr += sizeof(d88_sct_t) + d88_sct.size;
1263                 }
1264         }
1265         d88_hdr.type = (mode == 0) ? MEDIA_TYPE_2HD : ((trkcnt >> 1) > 60) ? MEDIA_TYPE_2DD : MEDIA_TYPE_2D;
1266         d88_hdr.size = trkptr;
1267         memcpy(buffer, &d88_hdr, sizeof(d88_hdr_t));
1268         return true;
1269 }
1270
1271 // cpdread image decoder (from MESS formats/dsk_dsk.c)
1272
1273 bool DISK::cpdread_to_d88(int extended)
1274 {
1275         d88_hdr_t d88_hdr;
1276         d88_sct_t d88_sct;
1277         int total = 0;
1278
1279         // get cylinder number and side number
1280         memcpy(tmp_buffer, buffer, file_size.d);
1281         int ncyl = tmp_buffer[0x30];
1282         int nside = tmp_buffer[0x31];
1283
1284         // create d88 image
1285         file_size.d = 0;
1286
1287         // create d88 header
1288         memset(&d88_hdr, 0, sizeof(d88_hdr_t));
1289         _strcpy_s(d88_hdr.title, sizeof(d88_hdr.title), "CPDRead");
1290         d88_hdr.protect = 0; // non-protected
1291         COPYBUFFER(&d88_hdr, sizeof(d88_hdr_t));
1292
1293         // create tracks
1294         int trkofs = 0x100, trkofs_ptr = 0x34;
1295         int trkptr = sizeof(d88_hdr_t);
1296
1297         for(int c = 0; c < ncyl; c++) {
1298                 for(int h = 0; h < nside; h++) {
1299                         // read sectors in this track
1300                         uint8 *track_info = tmp_buffer + trkofs;
1301                         int cyl = track_info[0x10];
1302                         int side = track_info[0x11];
1303                         int nsec = track_info[0x15];
1304                         int size = 1 << (track_info[0x14] + 7); // standard
1305                         int sctofs = trkofs + 0x100;
1306
1307                         if(nside == 1) {
1308                                 // double side
1309                                 d88_hdr.trkptr[2 * cyl] = d88_hdr.trkptr[2 * cyl + 1] = trkptr;
1310                         } else {
1311                                 d88_hdr.trkptr[2 * cyl + side] = trkptr;
1312                         }
1313                         for(int s = 0; s < nsec; s++) {
1314                                 // get sector size
1315                                 uint8 *sector_info = tmp_buffer + trkofs + 0x18 + s * 8;
1316                                 if(extended) {
1317                                         size = sector_info[6] + sector_info[7] * 256;
1318                                 }
1319
1320                                 // create d88 sector header
1321                                 memset(&d88_sct, 0, sizeof(d88_sct_t));
1322                                 d88_sct.c = sector_info[0];
1323                                 d88_sct.h = sector_info[1];
1324                                 d88_sct.r = sector_info[2];
1325                                 d88_sct.n = sector_info[3];
1326                                 d88_sct.nsec = nsec;
1327                                 d88_sct.dens = 0;
1328                                 d88_sct.del = (sector_info[5] == 0xb2) ? 0x10 : 0;
1329                                 d88_sct.stat = (sector_info[5] == 0xb5) ? 0xb0 : d88_sct.del;
1330                                 d88_sct.size = size;
1331
1332                                 // copy to d88
1333                                 COPYBUFFER(&d88_sct, sizeof(d88_sct_t));
1334                                 COPYBUFFER(tmp_buffer + sctofs, size);
1335                                 trkptr += sizeof(d88_sct_t) + size;
1336                                 sctofs += size;
1337                                 total += size;
1338                         }
1339
1340                         if(extended) {
1341                                 trkofs += tmp_buffer[trkofs_ptr++] * 256;
1342                         } else {
1343                                 trkofs += tmp_buffer[0x32] + tmp_buffer[0x33] * 256;
1344                         }
1345                 }
1346         }
1347         d88_hdr.type = (total < (368640 + 655360) / 2) ? MEDIA_TYPE_2D : (total < (737280 + 1228800) / 2) ? MEDIA_TYPE_2DD : MEDIA_TYPE_2HD;
1348         d88_hdr.size = trkptr;
1349         memcpy(buffer, &d88_hdr, sizeof(d88_hdr_t));
1350         return true;
1351 }
1352
1353 // standard image decoder
1354
1355 bool DISK::standard_to_d88(int type, int ncyl, int nside, int nsec, int size)
1356 {
1357         d88_hdr_t d88_hdr;
1358         d88_sct_t d88_sct;
1359         int n = 0, t = 0;
1360
1361         file_size.d = 0;
1362
1363         // create d88 header
1364         memset(&d88_hdr, 0, sizeof(d88_hdr_t));
1365         _strcpy_s(d88_hdr.title, sizeof(d88_hdr.title), "STANDARD");
1366         d88_hdr.protect = 0; // non-protected
1367         d88_hdr.type = (type == MEDIA_TYPE_144) ? MEDIA_TYPE_2HD : type;
1368         media_type = type;
1369         COPYBUFFER(&d88_hdr, sizeof(d88_hdr_t));
1370
1371         // sector length
1372         for(int i = 0; i < 8; i++) {
1373                 if(size == (128 << i)) {
1374                         n = i;
1375                         break;
1376                 }
1377         }
1378
1379         // create tracks
1380         int trkptr = sizeof(d88_hdr_t);
1381         for(int c = 0; c < ncyl; c++) {
1382                 for(int h = 0; h < nside; h++) {
1383                         d88_hdr.trkptr[t++] = trkptr;
1384                         if(nside == 1) {
1385                                 // double side
1386                                 d88_hdr.trkptr[t++] = trkptr;
1387                         }
1388
1389                         // read sectors in this track
1390                         for(int s = 0; s < nsec; s++) {
1391                                 // create d88 sector header
1392                                 memset(&d88_sct, 0, sizeof(d88_sct_t));
1393                                 d88_sct.c = c;
1394                                 d88_sct.h = h;
1395                                 d88_sct.r = s + 1;
1396                                 d88_sct.n = n;
1397                                 d88_sct.nsec = nsec;
1398                                 d88_sct.dens = 0;
1399                                 d88_sct.del = 0;
1400                                 d88_sct.stat = 0;
1401                                 d88_sct.size = size;
1402
1403                                 // create sector image
1404                                 uint8 dst[16384];
1405                                 memset(dst, 0xe5, sizeof(dst));
1406                                 fi->Fread(dst, size, 1);
1407
1408                                 // copy to d88
1409                                 COPYBUFFER(&d88_sct, sizeof(d88_sct_t));
1410                                 COPYBUFFER(dst, size);
1411                                 trkptr += sizeof(d88_sct_t) + size;
1412                         }
1413                 }
1414         }
1415         d88_hdr.size = trkptr;
1416         memcpy(buffer, &d88_hdr, sizeof(d88_hdr_t));
1417         return true;
1418 }
1419
1420 #define STATE_VERSION   3
1421
1422 void DISK::save_state(FILEIO* state_fio)
1423 {
1424         state_fio->FputUint32(STATE_VERSION);
1425
1426         state_fio->Fwrite(buffer, sizeof(buffer), 1);
1427         state_fio->Fwrite(orig_path, sizeof(orig_path), 1);
1428         state_fio->Fwrite(dest_path, sizeof(dest_path), 1);
1429         state_fio->FputUint32(file_size.d);
1430         state_fio->FputInt32(file_bank);
1431         state_fio->FputUint32(crc32);
1432         state_fio->Fwrite(fdi_header, sizeof(fdi_header), 1);
1433         state_fio->FputBool(inserted);
1434         state_fio->FputBool(ejected);
1435         state_fio->FputBool(write_protected);
1436         state_fio->FputBool(changed);
1437         state_fio->FputUint8(media_type);
1438         state_fio->FputBool(is_standard_image);
1439         state_fio->FputBool(is_fdi_image);
1440         state_fio->FputInt32(is_special_disk);
1441         state_fio->Fwrite(track, sizeof(track), 1);
1442         state_fio->FputInt32(sector_num.sd);
1443         state_fio->FputInt32(data_size_shift);
1444         state_fio->FputBool(too_many_sectors);
1445         state_fio->FputBool(no_skew);
1446         state_fio->Fwrite(sync_position, sizeof(sync_position), 1);
1447         state_fio->Fwrite(id_position, sizeof(id_position), 1);
1448         state_fio->Fwrite(data_position, sizeof(data_position), 1);
1449         state_fio->FputInt32(sector ? (int)(sector - buffer) : -1);
1450         state_fio->FputInt32(sector_size.sd);
1451         state_fio->Fwrite(id, sizeof(id), 1);
1452         state_fio->FputUint8(density);
1453         state_fio->FputBool(deleted);
1454         state_fio->FputBool(crc_error);
1455         state_fio->FputUint8(drive_type);
1456         state_fio->FputInt32(drive_rpm);
1457         state_fio->FputBool(drive_mfm);
1458 }
1459
1460 bool DISK::load_state(FILEIO* state_fio)
1461 {
1462         if(state_fio->FgetUint32() != STATE_VERSION) {
1463                 return false;
1464         }
1465         state_fio->Fread(buffer, sizeof(buffer), 1);
1466         state_fio->Fread(orig_path, sizeof(orig_path), 1);
1467         state_fio->Fread(dest_path, sizeof(dest_path), 1);
1468         file_size.d = state_fio->FgetUint32();
1469         file_bank = state_fio->FgetInt32();
1470         crc32 = state_fio->FgetUint32();
1471         state_fio->Fread(fdi_header, sizeof(fdi_header), 1);
1472         inserted = state_fio->FgetBool();
1473         ejected = state_fio->FgetBool();
1474         write_protected = state_fio->FgetBool();
1475         changed = state_fio->FgetBool();
1476         media_type = state_fio->FgetUint8();
1477         is_standard_image = state_fio->FgetBool();
1478         is_fdi_image = state_fio->FgetBool();
1479         is_special_disk = state_fio->FgetInt32();
1480         state_fio->Fread(track, sizeof(track), 1);
1481         sector_num.sd = state_fio->FgetInt32();
1482         data_size_shift = state_fio->FgetInt32();
1483         too_many_sectors = state_fio->FgetBool();
1484         no_skew = state_fio->FgetBool();
1485         state_fio->Fread(sync_position, sizeof(sync_position), 1);
1486         state_fio->Fread(id_position, sizeof(id_position), 1);
1487         state_fio->Fread(data_position, sizeof(data_position), 1);
1488         int offset = state_fio->FgetInt32();
1489         sector = (offset != -1) ? buffer + offset : NULL;
1490         sector_size.sd = state_fio->FgetInt32();
1491         state_fio->Fread(id, sizeof(id), 1);
1492         density = state_fio->FgetUint8();
1493         deleted = state_fio->FgetBool();
1494         crc_error = state_fio->FgetBool();
1495         drive_type = state_fio->FgetUint8();
1496         drive_rpm = state_fio->FgetInt32();
1497         drive_mfm = state_fio->FgetBool();
1498         return true;
1499 }
1500