source/src/vm/multi8/cmt.cpp

   1 /*
   2         MITSUBISHI Electric MULTI8 Emulator 'EmuLTI8'
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2006.09.16 -
   6
   7         [ cmt ]
   8 */
   9
  10 #include "cmt.h"
  11 #include "../i8251.h"
  12
  13 void CMT::initialize()
  14 {
  15         fio = new FILEIO();
  16         play = rec = remote = false;
  17 }
  18
  19 void CMT::release()
  20 {
  21         release_tape();
  22         delete fio;
  23 }
  24
  25 void CMT::reset()
  26 {
  27         close_tape();
  28         play = rec = remote = false;
  29 }
  30
  31 void CMT::write_signal(int id, uint32_t data, uint32_t mask)
  32 {
  33         if(id == SIG_CMT_REMOTE) {
  34                 remote = ((data & mask) != 0);
  35         } else if(id == SIG_CMT_OUT) {
  36                 if(rec && remote) {
  37                         // recv from sio
  38                         buffer[bufcnt++] = data & mask;
  39                         if(bufcnt >= BUFFER_SIZE) {
  40                                 fio->Fwrite(buffer, bufcnt, 1);
  41                                 bufcnt = 0;
  42                         }
  43                 }
  44         }
  45 }
  46
  47 void CMT::play_tape(const _TCHAR* file_path)
  48 {
  49         close_tape();
  50
  51         if(fio->Fopen(file_path, FILEIO_READ_BINARY)) {
  52                 fio->Fseek(0, FILEIO_SEEK_END);
  53                 int size = (fio->Ftell() + 9) & (BUFFER_SIZE - 1);
  54                 fio->Fseek(0, FILEIO_SEEK_SET);
  55                 memset(buffer, 0, sizeof(buffer));
  56                 fio->Fread(buffer, sizeof(buffer), 1);
  57                 fio->Fclose();
  58
  59                 // send data to sio
  60                 // this implement does not care the sio buffer size... :-(
  61                 for(int i = 0; i < size; i++) {
  62                         d_sio->write_signal(SIG_I8251_RECV, buffer[i], 0xff);
  63                 }
  64                 play = true;
  65         }
  66 }
  67
  68 void CMT::rec_tape(const _TCHAR* file_path)
  69 {
  70         close_tape();
  71
  72         if(fio->Fopen(file_path, FILEIO_READ_WRITE_NEW_BINARY)) {
  73                 my_tcscpy_s(rec_file_path, _MAX_PATH, file_path);
  74                 bufcnt = 0;
  75                 rec = true;
  76         }
  77 }
  78
  79 void CMT::close_tape()
  80 {
  81         // close file
  82         release_tape();
  83
  84         // clear sio buffer
  85         d_sio->write_signal(SIG_I8251_CLEAR, 0, 0);
  86 }
  87
  88 void CMT::release_tape()
  89 {
  90         // close file
  91         if(fio->IsOpened()) {
  92                 if(rec && bufcnt) {
  93                         fio->Fwrite(buffer, bufcnt, 1);
  94                 }
  95                 fio->Fclose();
  96         }
  97         play = rec = false;
  98 }
  99
 100 #define STATE_VERSION   2
 101
 102 #include "../../statesub.h"
 103
 104 void CMT::decl_state()
 105 {
 106         enter_decl_state(STATE_VERSION);
 107
 108         DECL_STATE_ENTRY_BOOL(play);
 109         DECL_STATE_ENTRY_BOOL(rec);
 110         DECL_STATE_ENTRY_BOOL(remote);
 111         DECL_STATE_ENTRY_STRING(rec_file_path, sizeof(rec_file_path));
 112         DECL_STATE_ENTRY_CMT_RECORDING(fio, rec, rec_file_path);
 113
 114         DECL_STATE_ENTRY_INT32(bufcnt);
 115         DECL_STATE_ENTRY_1D_ARRAY(buffer, sizeof(buffer));
 116
 117         leave_decl_state();
 118 }
 119 void CMT::save_state(FILEIO* state_fio)
 120 {
 121         if(state_entry != NULL) {
 122                 state_entry->save_state(state_fio);
 123         }
 124 //      state_fio->FputUint32(STATE_VERSION);
 125 //      state_fio->FputInt32(this_device_id);
 126
 127 //      state_fio->FputBool(play);
 128 //      state_fio->FputBool(rec);
 129 //      state_fio->FputBool(remote);
 130 //      state_fio->Fwrite(rec_file_path, sizeof(rec_file_path), 1);
 131 //      if(rec && fio->IsOpened()) {
 132 //              int length_tmp = (int)fio->Ftell();
 133 //              fio->Fseek(0, FILEIO_SEEK_SET);
 134 //              state_fio->FputInt32(length_tmp);
 135 //              while(length_tmp != 0) {
 136 //                      uint8_t buffer_tmp[1024];
 137 //                      int length_rw = min(length_tmp, (int)sizeof(buffer_tmp));
 138 //                      fio->Fread(buffer_tmp, length_rw, 1);
 139 //                      state_fio->Fwrite(buffer_tmp, length_rw, 1);
 140 //                      length_tmp -= length_rw;
 141 //              }
 142 //      } else {
 143 //              state_fio->FputInt32(0);
 144 //      }
 145 //      state_fio->FputInt32(bufcnt);
 146 //      state_fio->Fwrite(buffer, sizeof(buffer), 1);
 147 }
 148
 149 bool CMT::load_state(FILEIO* state_fio)
 150 {
 151         release_tape();
 152
 153         bool mb = false;
 154         if(state_entry != NULL) {
 155                 mb = state_entry->load_state(state_fio);
 156         }
 157         if(!mb) {
 158                 return false;
 159         }
 160 //      if(state_fio->FgetUint32() != STATE_VERSION) {
 161 //              return false;
 162 //      }
 163 //      if(state_fio->FgetInt32() != this_device_id) {
 164 //              return false;
 165 //      }
 166 //      play = state_fio->FgetBool();
 167 //      rec = state_fio->FgetBool();
 168 //      remote = state_fio->FgetBool();
 169 //      state_fio->Fread(rec_file_path, sizeof(rec_file_path), 1);
 170 //      int length_tmp = state_fio->FgetInt32();
 171 //      if(rec) {
 172 //              fio->Fopen(rec_file_path, FILEIO_READ_WRITE_NEW_BINARY);
 173 //              while(length_tmp != 0) {
 174 //                      uint8_t buffer_tmp[1024];
 175 //                      int length_rw = min(length_tmp, (int)sizeof(buffer_tmp));
 176 //                      state_fio->Fread(buffer_tmp, length_rw, 1);
 177 //                      if(fio->IsOpened()) {
 178 //                              fio->Fwrite(buffer_tmp, length_rw, 1);
 179 //                      }
 180 //                      length_tmp -= length_rw;
 181 //              }
 182 //      }
 183 //      bufcnt = state_fio->FgetInt32();
 184 //      state_fio->Fread(buffer, sizeof(buffer), 1);
 185         return true;
 186 }
 187
 188 bool CMT::process_state(FILEIO* state_fio, bool loading)
 189 {
 190         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 191                 return false;
 192         }
 193         if(!state_fio->StateCheckInt32(this_device_id)) {
 194                 return false;
 195         }
 196         state_fio->StateBool(play);
 197         state_fio->StateBool(rec);
 198         state_fio->StateBool(remote);
 199         state_fio->StateBuffer(rec_file_path, sizeof(rec_file_path), 1);
 200         if(loading) {
 201                 int length_tmp = state_fio->FgetInt32_LE();
 202                 if(rec) {
 203                         fio->Fopen(rec_file_path, FILEIO_READ_WRITE_NEW_BINARY);
 204                         while(length_tmp != 0) {
 205                                 uint8_t buffer_tmp[1024];
 206                                 int length_rw = min(length_tmp, (int)sizeof(buffer_tmp));
 207                                 state_fio->Fread(buffer_tmp, length_rw, 1);
 208                                 if(fio->IsOpened()) {
 209                                         fio->Fwrite(buffer_tmp, length_rw, 1);
 210                                 }
 211                                 length_tmp -= length_rw;
 212                         }
 213                 }
 214         } else {
 215                 if(rec && fio->IsOpened()) {
 216                         int length_tmp = (int)fio->Ftell();
 217                         fio->Fseek(0, FILEIO_SEEK_SET);
 218                         state_fio->FputInt32_LE(length_tmp);
 219                         while(length_tmp != 0) {
 220                                 uint8_t buffer_tmp[1024];
 221                                 int length_rw = min(length_tmp, (int)sizeof(buffer_tmp));
 222                                 fio->Fread(buffer_tmp, length_rw, 1);
 223                                 state_fio->Fwrite(buffer_tmp, length_rw, 1);
 224                                 length_tmp -= length_rw;
 225                         }
 226                 } else {
 227                         state_fio->FputInt32_LE(0);
 228                 }
 229         }
 230         state_fio->StateInt32(bufcnt);
 231         state_fio->StateBuffer(buffer, sizeof(buffer), 1);
 232         return true;
 233 }