source/src/vm/pc8201/cmt.cpp

   1 /*
   2         NEC PC-8201 Emulator 'ePC-8201'
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2013.04.22-
   6
   7         [ cmt (record only) ]
   8 */
   9
  10 #include "cmt.h"
  11
  12 #define SAMPLE_RATE 48000
  13
  14 namespace PC8201 {
  15
  16 void CMT::initialize()
  17 {
  18         fio = new FILEIO();
  19         rec = remote = false;
  20 }
  21
  22 void CMT::release()
  23 {
  24         close_tape();
  25         delete fio;
  26 }
  27
  28 void CMT::reset()
  29 {
  30         close_tape();
  31         rec = remote = false;
  32 }
  33
  34 void CMT::write_buffer(uint8_t value, int samples)
  35 {
  36         if(is_wav) {
  37                 for(int i = 0; i < samples; i++) {
  38                         buffer[bufcnt++] = value;
  39                         if(bufcnt == sizeof(buffer)) {
  40                                 fio->Fwrite(buffer, sizeof(buffer), 1);
  41                                 bufcnt = 0;
  42                         }
  43                 }
  44         } else {
  45                 value = (value > 128) ? 0x80 : 0;
  46                 while(samples > 0) {
  47                         int s = min(samples, 0x7f);
  48                         samples -= s;
  49                         buffer[bufcnt++] = value | s;
  50                         if(bufcnt == sizeof(buffer)) {
  51                                 fio->Fwrite(buffer, sizeof(buffer), 1);
  52                                 bufcnt = 0;
  53                         }
  54                 }
  55         }
  56 }
  57
  58 void CMT::put_signal()
  59 {
  60         if(rec && remote) {
  61                 uint32_t clock = get_passed_clock(prev_clock);
  62                 if(prev_signal == 1) {
  63                         // 2400Hz
  64                         int count = (int)(1200.0 * (double)clock / (double)CPU_CLOCKS + 0.5) * 2;
  65                         for(int i = 0; i < count; i++) {
  66                                 write_buffer(0xff, SAMPLE_RATE / 2400 / 2);
  67                                 write_buffer(0x00, SAMPLE_RATE / 2400 / 2);
  68                         }
  69                 } else if(prev_signal == -1) {
  70                         // 1200Hz
  71                         int count = (int)(1200.0 * (double)clock / (double)CPU_CLOCKS + 0.5);
  72                         for(int i = 0; i < count; i++) {
  73                                 write_buffer(0xff, SAMPLE_RATE / 1200 / 2);
  74                                 write_buffer(0x00, SAMPLE_RATE / 1200 / 2);
  75                         }
  76                 } else {
  77                         write_buffer(0x80, SAMPLE_RATE * clock / CPU_CLOCKS);
  78                 }
  79         }
  80 }
  81
  82 void CMT::write_signal(int id, uint32_t data, uint32_t mask)
  83 {
  84         bool next = ((data & mask) != 0);
  85
  86         if(id == SIG_CMT_REMOTE) {
  87                 if(!remote && next) {
  88                         // start
  89                         prev_signal = 0;
  90                         prev_clock = get_current_clock();
  91                 } else if(remote && !next) {
  92                         // stop
  93                         put_signal();
  94                 }
  95                 remote = next;
  96         } else if(id == SIG_CMT_SOD) {
  97                 if(remote) {
  98                         request_skip_frames();
  99                         put_signal();
 100                 }
 101                 prev_signal = next ? 1 : -1;
 102                 prev_clock = get_current_clock();
 103         }
 104 }
 105
 106 void CMT::rec_tape(const _TCHAR* file_path)
 107 {
 108         close_tape();
 109
 110         if(fio->Fopen(file_path, FILEIO_WRITE_BINARY)) {
 111                 my_tcscpy_s(rec_file_path, _MAX_PATH, file_path);
 112                 if(check_file_extension(file_path, _T(".wav"))) {
 113                         write_dummy_wav_header((void *)fio);
 114                         is_wav = true;
 115                 }
 116                 bufcnt = 0;
 117                 rec = true;
 118         }
 119 }
 120
 121 void CMT::close_tape()
 122 {
 123         // close file
 124         if(rec) {
 125                 if(bufcnt) {
 126                         fio->Fwrite(buffer, bufcnt, 1);
 127                 }
 128                 if(is_wav) {
 129                         uint32_t length = fio->Ftell();
 130                         wav_header_t wav_header;
 131                         wav_chunk_t wav_chunk;
 132                         if(set_wav_header(&wav_header, &wav_chunk, 1, SAMPLE_RATE, 8, length)) {
 133                                 fio->Fseek(0, FILEIO_SEEK_SET);
 134                                 fio->Fwrite(&wav_header, sizeof(wav_header), 1);
 135                                 fio->Fwrite(&wav_chunk, sizeof(wav_chunk), 1);
 136                         }
 137                 }
 138                 fio->Fclose();
 139         }
 140         is_wav = rec = false;
 141 }
 142
 143 #define STATE_VERSION   1
 144
 145 bool CMT::process_state(FILEIO* state_fio, bool loading)
 146 {
 147         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 148                 return false;
 149         }
 150         if(!state_fio->StateCheckInt32(this_device_id)) {
 151                 return false;
 152         }
 153         state_fio->StateBool(is_wav);
 154         state_fio->StateBool(rec);
 155         state_fio->StateBool(remote);
 156         state_fio->StateBuffer(rec_file_path, sizeof(rec_file_path), 1);
 157         if(loading) {
 158                 int length_tmp = state_fio->FgetInt32_LE();
 159                 if(rec) {
 160                         fio->Fopen(rec_file_path, FILEIO_READ_WRITE_NEW_BINARY);
 161                         while(length_tmp != 0) {
 162                                 uint8_t buffer_tmp[1024];
 163                                 int length_rw = min(length_tmp, (int)sizeof(buffer_tmp));
 164                                 state_fio->Fread(buffer_tmp, length_rw, 1);
 165                                 if(fio->IsOpened()) {
 166                                         fio->Fwrite(buffer_tmp, length_rw, 1);
 167                                 }
 168                                 length_tmp -= length_rw;
 169                         }
 170                 }
 171         } else {
 172                 if(rec && fio->IsOpened()) {
 173                         int length_tmp = (int)fio->Ftell();
 174                         fio->Fseek(0, FILEIO_SEEK_SET);
 175                         state_fio->FputInt32_LE(length_tmp);
 176                         while(length_tmp != 0) {
 177                                 uint8_t buffer_tmp[1024];
 178                                 int length_rw = min(length_tmp, (int)sizeof(buffer_tmp));
 179                                 fio->Fread(buffer_tmp, length_rw, 1);
 180                                 state_fio->Fwrite(buffer_tmp, length_rw, 1);
 181                                 length_tmp -= length_rw;
 182                         }
 183                 } else {
 184                         state_fio->FputInt32_LE(0);
 185                 }
 186         }
 187         state_fio->StateInt32(bufcnt);
 188         state_fio->StateBuffer(buffer, sizeof(buffer), 1);
 189         state_fio->StateInt32(prev_signal);
 190         state_fio->StateUint32(prev_clock);
 191         return true;
 192 }
 193
 194 }