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) >= 0x2b0 && (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         uint32 dest_offset = 0x2b0;
 684
 685         // copy header
 686         memcpy(tmp_buffer, buffer, 0x2b0);
 687
 688         // copy tracks
 689         for(int trkside = 0; trkside < 164; trkside++) {
 690                 pair src_trk_offset;
 691                 src_trk_offset.read_4bytes_le_from(buffer + 0x20 + trkside * 4);
 692
 693                 pair dest_trk_offset;
 694                 dest_trk_offset.d = 0;
 695
 696                 if(IS_VALID_TRACK(src_trk_offset.d)) {
 697                         uint8* t = buffer + src_trk_offset.d;
 698                         pair sector_num, data_size;
 699                         sector_num.read_2bytes_le_from(t + 4);
 700                         if(sector_num.sd != 0) {
 701                                 dest_trk_offset.d = dest_offset;
 702                                 for(int i = 0; i < sector_num.sd; i++) {
 703                                         data_size.read_2bytes_le_from(t + 14);
 704                                         memcpy(tmp_buffer + dest_offset, t, data_size.sd + 0x10);
 705                                         dest_offset += data_size.sd + 0x10;
 706                                         t += data_size.sd + 0x10;
 707                                 }
 708                         }
 709                 }
 710                 dest_trk_offset.write_4bytes_le_to(tmp_buffer + 0x20 + trkside * 4);
 711         }
 712
 713         // update file size
 714         file_size.d = dest_offset;
 715         file_size.write_4bytes_le_to(tmp_buffer + 0x1c);
 716
 717         memset(buffer, 0, sizeof(buffer));
 718         memcpy(buffer, tmp_buffer, file_size.d);
 719 }
 720
 721 int DISK::get_rpm()
 722 {
 723         if(drive_rpm != 0) {
 724                 return drive_rpm;
 725         } else if(inserted) {
 726                 return (media_type == MEDIA_TYPE_2HD) ? 360 : 300;
 727         } else {
 728                 return (drive_type == DRIVE_TYPE_2HD) ? 360 : 300;
 729         }
 730 }
 731
 732 int DISK::get_track_size()
 733 {
 734         if(inserted) {
 735                 return media_type == MEDIA_TYPE_144 ? 12500 : media_type == MEDIA_TYPE_2HD ? 10410 : drive_mfm ? 6250 : 3100;
 736         } else {
 737                 return drive_type == DRIVE_TYPE_144 ? 12500 : drive_type == DRIVE_TYPE_2HD ? 10410 : drive_mfm ? 6250 : 3100;
 738         }
 739 }
 740
 741 double DISK::get_usec_per_bytes(int bytes)
 742 {
 743         return 1000000.0 / (get_track_size() * (get_rpm() / 60.0)) * bytes;
 744 }
 745
 746 bool DISK::check_media_type()
 747 {
 748         switch(drive_type) {
 749         case DRIVE_TYPE_2D:
 750                 return (media_type == MEDIA_TYPE_2D);
 751         case DRIVE_TYPE_2DD:
 752                 return (media_type == MEDIA_TYPE_2D || media_type == MEDIA_TYPE_2DD);
 753         case DRIVE_TYPE_2HD:
 754                 return (media_type == MEDIA_TYPE_2HD);
 755         case DRIVE_TYPE_144:
 756                 return (media_type == MEDIA_TYPE_144);
 757         case DRIVE_TYPE_UNK:
 758                 return true; // always okay
 759         }
 760         return false;
 761 }
 762
 763 // teledisk image decoder
 764
 765 /*
 766         this teledisk image decoder is based on:
 767
 768                 LZHUF.C English version 1.0 based on Japanese version 29-NOV-1988
 769                 LZSS coded by Haruhiko OKUMURA
 770                 Adaptive Huffman Coding coded by Haruyasu YOSHIZAKI
 771                 Edited and translated to English by Kenji RIKITAKE
 772                 TDLZHUF.C by WTK
 773 */
 774
 775 #define COPYBUFFER(src, size) { \
 776         if(file_size.d + (size) > DISK_BUFFER_SIZE) { \
 777                 return false; \
 778         } \
 779         memcpy(buffer + file_size.d, (src), (size)); \
 780         file_size.d += (size); \
 781 }
 782
 783 bool DISK::teledisk_to_d88()
 784 {
 785         td_hdr_t hdr;
 786         td_cmt_t cmt;
 787         td_trk_t trk;
 788         td_sct_t sct;
 789         d88_hdr_t d88_hdr;
 790         d88_sct_t d88_sct;
 791         uint8 obuf[512];
 792
 793         // check teledisk header
 794         fi->Fseek(0, FILEIO_SEEK_SET);
 795         fi->Fread(&hdr, sizeof(td_hdr_t), 1);
 796         if(hdr.sig[0] == 't' && hdr.sig[1] == 'd') {
 797                 // decompress to the temporary file
 798                 FILEIO* fo = new FILEIO();
 799                 if(!fo->Fopen(temp_path, FILEIO_WRITE_BINARY)) {
 800                         delete fo;
 801                         return false;
 802                 }
 803                 int rd = 1;
 804                 init_decode();
 805                 do {
 806                         if((rd = decode(obuf, 512)) > 0) {
 807                                 fo->Fwrite(obuf, rd, 1);
 808                         }
 809                 }
 810                 while(rd > 0);
 811                 fo->Fclose();
 812                 delete fo;
 813                 temporary = true;
 814
 815                 // reopen the temporary file
 816                 fi->Fclose();
 817                 if(!fi->Fopen(temp_path, FILEIO_READ_BINARY)) {
 818                         return false;
 819                 }
 820         }
 821         if(hdr.flag & 0x80) {
 822                 // skip comment
 823                 fi->Fread(&cmt, sizeof(td_cmt_t), 1);
 824                 fi->Fseek(cmt.len, FILEIO_SEEK_CUR);
 825         }
 826
 827         // create d88 image
 828         file_size.d = 0;
 829
 830         // create d88 header
 831         memset(&d88_hdr, 0, sizeof(d88_hdr_t));
 832         _strcpy_s(d88_hdr.title, sizeof(d88_hdr.title), "TELEDISK");
 833         d88_hdr.protect = 0; // non-protected
 834         COPYBUFFER(&d88_hdr, sizeof(d88_hdr_t));
 835
 836         // create tracks
 837         int trkcnt = 0, trkptr = sizeof(d88_hdr_t);
 838         fi->Fread(&trk, sizeof(td_trk_t), 1);
 839         while(trk.nsec != 0xff) {
 840                 d88_hdr.trkptr[trkcnt++] = trkptr;
 841                 if(hdr.sides == 1) {
 842                         d88_hdr.trkptr[trkcnt++] = trkptr;
 843                 }
 844
 845                 // read sectors in this track
 846                 for(int i = 0; i < trk.nsec; i++) {
 847                         uint8 buf[2048], dst[2048];
 848                         memset(buf, 0, sizeof(buf));
 849                         memset(dst, 0, sizeof(dst));
 850
 851                         // read sector header
 852                         fi->Fread(&sct, sizeof(td_sct_t), 1);
 853
 854                         // create d88 sector header
 855                         memset(&d88_sct, 0, sizeof(d88_sct_t));
 856                         d88_sct.c = sct.c;
 857                         d88_sct.h = sct.h;
 858                         d88_sct.r = sct.r;
 859                         d88_sct.n = sct.n;
 860                         d88_sct.nsec = trk.nsec;
 861                         d88_sct.dens = (hdr.dens & 0x80) ? 0x40 : 0;
 862                         d88_sct.del = (sct.ctrl & 4) ? 0x10 : 0;
 863                         d88_sct.stat = (sct.ctrl & 2) ? 0xb0 : d88_sct.del;
 864                         d88_sct.size = secsize[sct.n & 3];
 865
 866                         // create sector image
 867                         if(sct.ctrl != 0x10) {
 868                                 // read sector source
 869                                 int len = fi->Fgetc();
 870                                 len += fi->Fgetc() * 256 - 1;
 871                                 int flag = fi->Fgetc(), d = 0;
 872                                 fi->Fread(buf, len, 1);
 873
 874                                 // convert
 875                                 if(flag == 0) {
 876                                         memcpy(dst, buf, len);
 877                                 } else if(flag == 1) {
 878                                         pair len2;
 879                                         len2.read_2bytes_le_from(buf);
 880                                         while(len2.sd--) {
 881                                                 dst[d++] = buf[2];
 882                                                 dst[d++] = buf[3];
 883                                         }
 884                                 } else if(flag == 2) {
 885                                         for(int s = 0; s < len;) {
 886                                                 int type = buf[s++];
 887                                                 int len2 = buf[s++];
 888                                                 if(type == 0) {
 889                                                         while(len2--) {
 890                                                                 dst[d++] = buf[s++];
 891                                                         }
 892                                                 } else if(type < 5) {
 893                                                         uint8 pat[256];
 894                                                         int n = 2;
 895                                                         while(type-- > 1) {
 896                                                                 n *= 2;
 897                                                         }
 898                                                         for(int j = 0; j < n; j++) {
 899                                                                 pat[j] = buf[s++];
 900                                                         }
 901                                                         while(len2--) {
 902                                                                 for(int j = 0; j < n; j++) {
 903                                                                         dst[d++] = pat[j];
 904                                                                 }
 905                                                         }
 906                                                 } else {
 907                                                         break; // unknown type
 908                                                 }
 909                                         }
 910                                 } else {
 911                                         break; // unknown flag
 912                                 }
 913                         } else {
 914                                 d88_sct.size = 0;
 915                         }
 916
 917                         // copy to d88
 918                         COPYBUFFER(&d88_sct, sizeof(d88_sct_t));
 919                         COPYBUFFER(dst, d88_sct.size);
 920                         trkptr += sizeof(d88_sct_t) + d88_sct.size;
 921                 }
 922                 // read next track
 923                 fi->Fread(&trk, sizeof(td_trk_t), 1);
 924         }
 925         d88_hdr.type = ((hdr.dens & 3) == 2) ? MEDIA_TYPE_2HD : ((trkcnt >> 1) > 60) ? MEDIA_TYPE_2DD : MEDIA_TYPE_2D;
 926         d88_hdr.size = trkptr;
 927         memcpy(buffer, &d88_hdr, sizeof(d88_hdr_t));
 928         return true;
 929 }
 930
 931 int DISK::next_word()
 932 {
 933         if(ibufndx >= ibufcnt) {
 934                 ibufndx = ibufcnt = 0;
 935                 memset(inbuf, 0, 512);
 936                 for(int i = 0; i < 512; i++) {
 937                         int d = fi->Fgetc();
 938                         if(d == EOF) {
 939                                 if(i) {
 940                                         break;
 941                                 }
 942                                 return(-1);
 943                         }
 944                         inbuf[i] = d;
 945                         ibufcnt = i + 1;
 946                 }
 947         }
 948         while(getlen <= 8) {
 949                 getbuf |= inbuf[ibufndx++] << (8 - getlen);
 950                 getlen += 8;
 951         }
 952         return 0;
 953 }
 954
 955 int DISK::get_bit()
 956 {
 957         if(next_word() < 0) {
 958                 return -1;
 959         }
 960         short i = getbuf;
 961         getbuf <<= 1;
 962         getlen--;
 963         return (i < 0) ? 1 : 0;
 964 }
 965
 966 int DISK::get_byte()
 967 {
 968         if(next_word() != 0) {
 969                 return -1;
 970         }
 971         uint16 i = getbuf;
 972         getbuf <<= 8;
 973         getlen -= 8;
 974         i >>= 8;
 975         return (int)i;
 976 }
 977
 978 void DISK::start_huff()
 979 {
 980         int i, j;
 981         for(i = 0; i < N_CHAR; i++) {
 982                 freq[i] = 1;
 983                 son[i] = i + TABLE_SIZE;
 984                 prnt[i + TABLE_SIZE] = i;
 985         }
 986         i = 0; j = N_CHAR;
 987         while(j <= ROOT_POSITION) {
 988                 freq[j] = freq[i] + freq[i + 1];
 989                 son[j] = i;
 990                 prnt[i] = prnt[i + 1] = j;
 991                 i += 2; j++;
 992         }
 993         freq[TABLE_SIZE] = 0xffff;
 994         prnt[ROOT_POSITION] = 0;
 995 }
 996
 997 void DISK::reconst()
 998 {
 999         short i, j = 0, k;
1000         uint16 f, l;
1001         for(i = 0; i < TABLE_SIZE; i++) {
1002                 if(son[i] >= TABLE_SIZE) {
1003                         freq[j] = (freq[i] + 1) / 2;
1004                         son[j] = son[i];
1005                         j++;
1006                 }
1007         }
1008         for(i = 0, j = N_CHAR; j < TABLE_SIZE; i += 2, j++) {
1009                 k = i + 1;
1010                 f = freq[j] = freq[i] + freq[k];
1011                 for(k = j - 1; f < freq[k]; k--);
1012                 k++;
1013                 l = (j - k) * 2;
1014                 memmove(&freq[k + 1], &freq[k], l);
1015                 freq[k] = f;
1016                 memmove(&son[k + 1], &son[k], l);
1017                 son[k] = i;
1018         }
1019         for(i = 0; i < TABLE_SIZE; i++) {
1020                 if((k = son[i]) >= TABLE_SIZE) {
1021                         prnt[k] = i;
1022                 } else {
1023                         prnt[k] = prnt[k + 1] = i;
1024                 }
1025         }
1026 }
1027
1028 void DISK::update(int c)
1029 {
1030         int i, j, k, l;
1031         if(freq[ROOT_POSITION] == MAX_FREQ) {
1032                 reconst();
1033         }
1034         c = prnt[c + TABLE_SIZE];
1035         do {
1036                 k = ++freq[c];
1037                 if(k > freq[l = c + 1]) {
1038                         while(k > freq[++l]);
1039                         l--;
1040                         freq[c] = freq[l];
1041                         freq[l] = k;
1042                         i = son[c];
1043                         prnt[i] = l;
1044                         if(i < TABLE_SIZE) {
1045                                 prnt[i + 1] = l;
1046                         }
1047                         j = son[l];
1048                         son[l] = i;
1049                         prnt[j] = c;
1050                         if(j < TABLE_SIZE) {
1051                                 prnt[j + 1] = c;
1052                         }
1053                         son[c] = j;
1054                         c = l;
1055                 }
1056         }
1057         while((c = prnt[c]) != 0);
1058 }
1059
1060 short DISK::decode_char()
1061 {
1062         int ret;
1063         uint16 c = son[ROOT_POSITION];
1064         while(c < TABLE_SIZE) {
1065                 if((ret = get_bit()) < 0) {
1066                         return -1;
1067                 }
1068                 c += (unsigned)ret;
1069                 c = son[c];
1070         }
1071         c -= TABLE_SIZE;
1072         update(c);
1073         return c;
1074 }
1075
1076 short DISK::decode_position()
1077 {
1078         short bit;
1079         uint16 i, j, c;
1080         if((bit = get_byte()) < 0) {
1081                 return -1;
1082         }
1083         i = (uint16)bit;
1084         c = (uint16)d_code[i] << 6;
1085         j = d_len[i] - 2;
1086         while(j--) {
1087                 if((bit = get_bit()) < 0) {
1088                          return -1;
1089                 }
1090                 i = (i << 1) + bit;
1091         }
1092         return (c | i & 0x3f);
1093 }
1094
1095 void DISK::init_decode()
1096 {
1097         ibufcnt= ibufndx = bufcnt = getbuf = 0;
1098         getlen = 0;
1099         start_huff();
1100         for(int i = 0; i < STRING_BUFFER_SIZE - LOOKAHEAD_BUFFER_SIZE; i++) {
1101                 text_buf[i] = ' ';
1102         }
1103         ptr = STRING_BUFFER_SIZE - LOOKAHEAD_BUFFER_SIZE;
1104 }
1105
1106 int DISK::decode(uint8 *buf, int len)
1107 {
1108         short c, pos;
1109         int  count;
1110         for(count = 0; count < len;) {
1111                 if(bufcnt == 0) {
1112                         if((c = decode_char()) < 0) {
1113                                 return count;
1114                         }
1115                         if(c < 256) {
1116                                 *(buf++) = (uint8)c;
1117                                 text_buf[ptr++] = (uint8)c;
1118                                 ptr &= (STRING_BUFFER_SIZE - 1);
1119                                 count++;
1120                         } else {
1121                                 if((pos = decode_position()) < 0) {
1122                                         return count;
1123                                 }
1124                                 bufpos = (ptr - pos - 1) & (STRING_BUFFER_SIZE - 1);
1125                                 bufcnt = c - 255 + THRESHOLD;
1126                                 bufndx = 0;
1127                         }
1128                 } else {
1129                         while(bufndx < bufcnt && count < len) {
1130                                 c = text_buf[(bufpos + bufndx) & (STRING_BUFFER_SIZE - 1)];
1131                                 *(buf++) = (uint8)c;
1132                                 bufndx++;
1133                                 text_buf[ptr++] = (uint8)c;
1134                                 ptr &= (STRING_BUFFER_SIZE - 1);
1135                                 count++;
1136                         }
1137                         if(bufndx >= bufcnt) {
1138                                 bufndx = bufcnt = 0;
1139                         }
1140                 }
1141         }
1142         return count;
1143 }
1144
1145 // imagedisk image decoder
1146
1147 bool DISK::imagedisk_to_d88()
1148 {
1149         imd_trk_t trk;
1150         d88_hdr_t d88_hdr;
1151         d88_sct_t d88_sct;
1152
1153         // skip comment
1154         fi->Fseek(0, FILEIO_SEEK_SET);
1155         int tmp;
1156         while((tmp = fi->Fgetc()) != 0x1a) {
1157                 if(tmp == EOF) {
1158                         return false;
1159                 }
1160         }
1161
1162         // create d88 image
1163         file_size.d = 0;
1164
1165         // create d88 header
1166         memset(&d88_hdr, 0, sizeof(d88_hdr_t));
1167         _strcpy_s(d88_hdr.title, sizeof(d88_hdr.title), "IMAGEDISK");
1168         d88_hdr.protect = 0; // non-protected
1169         COPYBUFFER(&d88_hdr, sizeof(d88_hdr_t));
1170
1171         // create tracks
1172         int trkptr = sizeof(d88_hdr_t);
1173         int trkcnt = 0, mode;
1174
1175         for(int t = 0; t < 164; t++) {
1176                 // check end of file
1177                 if(fi->Fread(&trk, sizeof(imd_trk_t), 1) != 1) {
1178                         break;
1179                 }
1180                 trkcnt = t;
1181
1182                 // check track header
1183                 if(t == 0) {
1184                         mode = trk.mode % 3; // 0=500kbps, 1=300kbps, 2=250kbps
1185                 }
1186                 if(!trk.nsec) {
1187                         continue;
1188                 }
1189                 d88_hdr.trkptr[t] = trkptr;
1190
1191                 // setup sector id
1192                 uint8 c[64], h[64], r[64];
1193                 fi->Fread(r, trk.nsec, 1);
1194                 if(trk.head & 0x80) {
1195                         fi->Fread(c, trk.nsec, 1);
1196                 } else {
1197                         memset(c, trk.cyl, sizeof(c));
1198                 }
1199                 if(trk.head & 0x40) {
1200                         fi->Fread(h, trk.nsec, 1);
1201                 } else {
1202                         memset(h, trk.head & 1, sizeof(h));
1203                 }
1204
1205                 // read sectors in this track
1206                 for(int i = 0; i < trk.nsec; i++) {
1207                         // create d88 sector header
1208                         int sectype = fi->Fgetc();
1209                         if(sectype > 8) {
1210                                 return false;
1211                         }
1212                         memset(&d88_sct, 0, sizeof(d88_sct_t));
1213                         d88_sct.c = c[i];
1214                         d88_sct.h = h[i];
1215                         d88_sct.r = r[i];
1216                         d88_sct.n = trk.size;
1217                         d88_sct.nsec = trk.nsec;
1218                         d88_sct.dens = (trk.mode < 3) ? 0x40 : 0;
1219                         d88_sct.del = (sectype == 3 || sectype == 4 || sectype == 7 || sectype == 8) ? 0x10 : 0;
1220                         d88_sct.stat = (sectype == 5 || sectype == 6 || sectype == 7 || sectype == 8) ? 0xb0 : d88_sct.del;
1221                         d88_sct.size = secsize[trk.size & 7];
1222
1223                         // create sector image
1224                         uint8 dst[8192];
1225                         if(sectype == 1 || sectype == 3 || sectype == 5 || sectype == 7) {
1226                                 // uncompressed
1227                                 fi->Fread(dst, d88_sct.size, 1);
1228                         } else if(sectype == 2 || sectype == 4 || sectype == 6 || sectype == 8) {
1229                                 // compressed
1230                                 int tmp = fi->Fgetc();
1231                                 memset(dst, tmp, d88_sct.size);
1232                         } else {
1233                                 d88_sct.size = 0;
1234                         }
1235
1236                         // copy to d88
1237                         COPYBUFFER(&d88_sct, sizeof(d88_sct_t));
1238                         COPYBUFFER(dst, d88_sct.size);
1239                         trkptr += sizeof(d88_sct_t) + d88_sct.size;
1240                 }
1241         }
1242         d88_hdr.type = (mode == 0) ? MEDIA_TYPE_2HD : ((trkcnt >> 1) > 60) ? MEDIA_TYPE_2DD : MEDIA_TYPE_2D;
1243         d88_hdr.size = trkptr;
1244         memcpy(buffer, &d88_hdr, sizeof(d88_hdr_t));
1245         return true;
1246 }
1247
1248 // cpdread image decoder (from MESS formats/dsk_dsk.c)
1249
1250 bool DISK::cpdread_to_d88(int extended)
1251 {
1252         d88_hdr_t d88_hdr;
1253         d88_sct_t d88_sct;
1254         int total = 0;
1255
1256         // get cylinder number and side number
1257         memcpy(tmp_buffer, buffer, file_size.d);
1258         int ncyl = tmp_buffer[0x30];
1259         int nside = tmp_buffer[0x31];
1260
1261         // create d88 image
1262         file_size.d = 0;
1263
1264         // create d88 header
1265         memset(&d88_hdr, 0, sizeof(d88_hdr_t));
1266         _strcpy_s(d88_hdr.title, sizeof(d88_hdr.title), "CPDRead");
1267         d88_hdr.protect = 0; // non-protected
1268         COPYBUFFER(&d88_hdr, sizeof(d88_hdr_t));
1269
1270         // create tracks
1271         int trkofs = 0x100, trkofs_ptr = 0x34;
1272         int trkptr = sizeof(d88_hdr_t);
1273
1274         for(int c = 0; c < ncyl; c++) {
1275                 for(int h = 0; h < nside; h++) {
1276                         // read sectors in this track
1277                         uint8 *track_info = tmp_buffer + trkofs;
1278                         int cyl = track_info[0x10];
1279                         int side = track_info[0x11];
1280                         int nsec = track_info[0x15];
1281                         int size = 1 << (track_info[0x14] + 7); // standard
1282                         int sctofs = trkofs + 0x100;
1283
1284                         if(nside == 1) {
1285                                 // double side
1286                                 d88_hdr.trkptr[2 * cyl] = d88_hdr.trkptr[2 * cyl + 1] = trkptr;
1287                         } else {
1288                                 d88_hdr.trkptr[2 * cyl + side] = trkptr;
1289                         }
1290                         for(int s = 0; s < nsec; s++) {
1291                                 // get sector size
1292                                 uint8 *sector_info = tmp_buffer + trkofs + 0x18 + s * 8;
1293                                 if(extended) {
1294                                         size = sector_info[6] + sector_info[7] * 256;
1295                                 }
1296
1297                                 // create d88 sector header
1298                                 memset(&d88_sct, 0, sizeof(d88_sct_t));
1299                                 d88_sct.c = sector_info[0];
1300                                 d88_sct.h = sector_info[1];
1301                                 d88_sct.r = sector_info[2];
1302                                 d88_sct.n = sector_info[3];
1303                                 d88_sct.nsec = nsec;
1304                                 d88_sct.dens = 0;
1305                                 d88_sct.del = (sector_info[5] == 0xb2) ? 0x10 : 0;
1306                                 d88_sct.stat = (sector_info[5] == 0xb5) ? 0xb0 : d88_sct.del;
1307                                 d88_sct.size = size;
1308
1309                                 // copy to d88
1310                                 COPYBUFFER(&d88_sct, sizeof(d88_sct_t));
1311                                 COPYBUFFER(tmp_buffer + sctofs, size);
1312                                 trkptr += sizeof(d88_sct_t) + size;
1313                                 sctofs += size;
1314                                 total += size;
1315                         }
1316
1317                         if(extended) {
1318                                 trkofs += tmp_buffer[trkofs_ptr++] * 256;
1319                         } else {
1320                                 trkofs += tmp_buffer[0x32] + tmp_buffer[0x33] * 256;
1321                         }
1322                 }
1323         }
1324         d88_hdr.type = (total < (368640 + 655360) / 2) ? MEDIA_TYPE_2D : (total < (737280 + 1228800) / 2) ? MEDIA_TYPE_2DD : MEDIA_TYPE_2HD;
1325         d88_hdr.size = trkptr;
1326         memcpy(buffer, &d88_hdr, sizeof(d88_hdr_t));
1327         return true;
1328 }
1329
1330 // standard image decoder
1331
1332 bool DISK::standard_to_d88(int type, int ncyl, int nside, int nsec, int size)
1333 {
1334         d88_hdr_t d88_hdr;
1335         d88_sct_t d88_sct;
1336         int n = 0, t = 0;
1337
1338         file_size.d = 0;
1339
1340         // create d88 header
1341         memset(&d88_hdr, 0, sizeof(d88_hdr_t));
1342         _strcpy_s(d88_hdr.title, sizeof(d88_hdr.title), "STANDARD");
1343         d88_hdr.protect = 0; // non-protected
1344         d88_hdr.type = (type == MEDIA_TYPE_144) ? MEDIA_TYPE_2HD : type;
1345         media_type = type;
1346         COPYBUFFER(&d88_hdr, sizeof(d88_hdr_t));
1347
1348         // sector length
1349         for(int i = 0; i < 8; i++) {
1350                 if(size == (128 << i)) {
1351                         n = i;
1352                         break;
1353                 }
1354         }
1355
1356         // create tracks
1357         int trkptr = sizeof(d88_hdr_t);
1358         for(int c = 0; c < ncyl; c++) {
1359                 for(int h = 0; h < nside; h++) {
1360                         d88_hdr.trkptr[t++] = trkptr;
1361                         if(nside == 1) {
1362                                 // double side
1363                                 d88_hdr.trkptr[t++] = trkptr;
1364                         }
1365
1366                         // read sectors in this track
1367                         for(int s = 0; s < nsec; s++) {
1368                                 // create d88 sector header
1369                                 memset(&d88_sct, 0, sizeof(d88_sct_t));
1370                                 d88_sct.c = c;
1371                                 d88_sct.h = h;
1372                                 d88_sct.r = s + 1;
1373                                 d88_sct.n = n;
1374                                 d88_sct.nsec = nsec;
1375                                 d88_sct.dens = 0;
1376                                 d88_sct.del = 0;
1377                                 d88_sct.stat = 0;
1378                                 d88_sct.size = size;
1379
1380                                 // create sector image
1381                                 uint8 dst[16384];
1382                                 memset(dst, 0xe5, sizeof(dst));
1383                                 fi->Fread(dst, size, 1);
1384
1385                                 // copy to d88
1386                                 COPYBUFFER(&d88_sct, sizeof(d88_sct_t));
1387                                 COPYBUFFER(dst, size);
1388                                 trkptr += sizeof(d88_sct_t) + size;
1389                         }
1390                 }
1391         }
1392         d88_hdr.size = trkptr;
1393         memcpy(buffer, &d88_hdr, sizeof(d88_hdr_t));
1394         return true;
1395 }
1396
1397 #define STATE_VERSION   3
1398
1399 void DISK::save_state(FILEIO* state_fio)
1400 {
1401         state_fio->FputUint32(STATE_VERSION);
1402
1403         state_fio->Fwrite(buffer, sizeof(buffer), 1);
1404         state_fio->Fwrite(orig_path, sizeof(orig_path), 1);
1405         state_fio->Fwrite(dest_path, sizeof(dest_path), 1);
1406         state_fio->FputUint32(file_size.d);
1407         state_fio->FputInt32(file_bank);
1408         state_fio->FputUint32(crc32);
1409         state_fio->Fwrite(fdi_header, sizeof(fdi_header), 1);
1410         state_fio->FputBool(inserted);
1411         state_fio->FputBool(ejected);
1412         state_fio->FputBool(write_protected);
1413         state_fio->FputBool(changed);
1414         state_fio->FputUint8(media_type);
1415         state_fio->FputBool(is_standard_image);
1416         state_fio->FputBool(is_fdi_image);
1417         state_fio->FputInt32(is_special_disk);
1418         state_fio->Fwrite(track, sizeof(track), 1);
1419         state_fio->FputInt32(sector_num.sd);
1420         state_fio->FputInt32(data_size_shift);
1421         state_fio->FputBool(too_many_sectors);
1422         state_fio->FputBool(no_skew);
1423         state_fio->Fwrite(sync_position, sizeof(sync_position), 1);
1424         state_fio->Fwrite(id_position, sizeof(id_position), 1);
1425         state_fio->Fwrite(data_position, sizeof(data_position), 1);
1426         state_fio->FputInt32(sector ? (int)(sector - buffer) : -1);
1427         state_fio->FputInt32(sector_size.sd);
1428         state_fio->Fwrite(id, sizeof(id), 1);
1429         state_fio->FputUint8(density);
1430         state_fio->FputBool(deleted);
1431         state_fio->FputBool(crc_error);
1432         state_fio->FputUint8(drive_type);
1433         state_fio->FputInt32(drive_rpm);
1434         state_fio->FputBool(drive_mfm);
1435 }
1436
1437 bool DISK::load_state(FILEIO* state_fio)
1438 {
1439         if(state_fio->FgetUint32() != STATE_VERSION) {
1440                 return false;
1441         }
1442         state_fio->Fread(buffer, sizeof(buffer), 1);
1443         state_fio->Fread(orig_path, sizeof(orig_path), 1);
1444         state_fio->Fread(dest_path, sizeof(dest_path), 1);
1445         file_size.d = state_fio->FgetUint32();
1446         file_bank = state_fio->FgetInt32();
1447         crc32 = state_fio->FgetUint32();
1448         state_fio->Fread(fdi_header, sizeof(fdi_header), 1);
1449         inserted = state_fio->FgetBool();
1450         ejected = state_fio->FgetBool();
1451         write_protected = state_fio->FgetBool();
1452         changed = state_fio->FgetBool();
1453         media_type = state_fio->FgetUint8();
1454         is_standard_image = state_fio->FgetBool();
1455         is_fdi_image = state_fio->FgetBool();
1456         is_special_disk = state_fio->FgetInt32();
1457         state_fio->Fread(track, sizeof(track), 1);
1458         sector_num.sd = state_fio->FgetInt32();
1459         data_size_shift = state_fio->FgetInt32();
1460         too_many_sectors = state_fio->FgetBool();
1461         no_skew = state_fio->FgetBool();
1462         state_fio->Fread(sync_position, sizeof(sync_position), 1);
1463         state_fio->Fread(id_position, sizeof(id_position), 1);
1464         state_fio->Fread(data_position, sizeof(data_position), 1);
1465         int offset = state_fio->FgetInt32();
1466         sector = (offset != -1) ? buffer + offset : NULL;
1467         sector_size.sd = state_fio->FgetInt32();
1468         state_fio->Fread(id, sizeof(id), 1);
1469         density = state_fio->FgetUint8();
1470         deleted = state_fio->FgetBool();
1471         crc_error = state_fio->FgetBool();
1472         drive_type = state_fio->FgetUint8();
1473         drive_rpm = state_fio->FgetInt32();
1474         drive_mfm = state_fio->FgetBool();
1475         return true;
1476 }
1477