first commit

Author: SilverGreen93

CTape.cpp

@@ -0,0 +1,232 @@
+#include "ctape.h"
+
+CTape::CTape()
+{
+ TapeLength=0; //signal length on tape
+ TapeData=NULL; //tape data
+ Speed=1; //playback speed
+ HeadPosition=0; //current position of the "head" of the recorder
+ UseLeftChannel=true; //permission to use the left channel
+ UseRightChannel=true; //permission to use the right channel
+ Channels=0;
+}
+
+CTape::~CTape()
+{
+ Eject();
+}
+
+bool CTape::LoadTape(char *FileName)
+{
+ Eject();
+
+ HMMIO hwav;
+ MMCKINFO parent,child;
+ WAVEFORMATEX wfmtx;
+ parent.ckid=(FOURCC)0;
+ parent.cksize=0;
+ parent.fccType=(FOURCC)0;
+ parent.dwDataOffset=0;
+ parent.dwFlags=0;
+ child=parent;
+ if ((hwav=mmioOpen(FileName,NULL,MMIO_READ|MMIO_ALLOCBUF))==NULL) return(false);
+ parent.fccType=mmioFOURCC('W','A','V','E');
+ if (mmioDescend(hwav,&parent,NULL,MMIO_FINDRIFF))
+ {
+  mmioClose(hwav,0);
+  return(false);
+ }
+ child.ckid=mmioFOURCC('f','m','t',' ');
+ if (mmioDescend(hwav,&child,&parent,0))
+ {
+  mmioClose(hwav,0);
+  return(false);
+ }
+ if (mmioRead(hwav,(char *)&wfmtx,sizeof(wfmtx))!=sizeof(wfmtx))
+ {
+  mmioClose(hwav,0);
+  return(false);
+ }
+ if (wfmtx.wFormatTag!=WAVE_FORMAT_PCM)
+ {
+  mmioClose(hwav,0);
+  return(false);
+ } 
+ if (mmioAscend(hwav,&child,0))
+ {
+  mmioClose(hwav,0);
+  return(false);
+ }
+ child.ckid=mmioFOURCC('d','a','t','a');
+ if (mmioDescend(hwav,&child,&parent,MMIO_FINDCHUNK))
+ {
+  mmioClose(hwav,0);
+  return(false);
+ }
+
+ //check the file format
+ Channels=wfmtx.nChannels; //number of channels
+ if (wfmtx.nSamplesPerSec!=44100) return(false); //check sample rate 44100
+ if (wfmtx.nBlockAlign!=wfmtx.nChannels) return(false); //only 8 bit
+
+ //load sound data
+ TapeData=new unsigned char[child.cksize];
+ TapeLength=child.cksize;
+ mmioRead(hwav,(char *)TapeData,child.cksize);
+ TapeLength/=Channels; //make the length of one channel
+ mmioClose(hwav,0);
+ return(true);
+}
+
+bool CTape::SetSpeed(long double speed)
+{
+ if (Speed<=0) return(false);
+ Speed=speed;
+ return(true);
+}
+
+bool CTape::ReadTape(unsigned char &volume)
+{
+ if (TapeData==NULL) return(false);
+ unsigned long pos=(unsigned long)HeadPosition;
+ if (pos>=TapeLength) return(false); 
+ unsigned long left=pos;
+ unsigned long right=pos+1;
+ if (right>=TapeLength) right=pos;
+
+ //do a linear interpolation of the signal between neighboring points
+ if (Channels==1) //for mono
+ {
+  long double k=((long double)(TapeData[right])-(long double)(TapeData[left]));
+  double v=(double)(TapeData[left])+(HeadPosition-(long double)(pos))*k;
+  volume=(unsigned char)v;
+ }
+ if (Channels==2) //for stereo
+ {
+  double ch_level=0;
+  int ch_summ=0;
+  if (UseLeftChannel==true)
+  {
+   long double k=((long double)(TapeData[right*2])-(long double)(TapeData[left*2]));
+   ch_level+=(double)(TapeData[left*2])+(HeadPosition-(long double)(pos))*k;
+   ch_summ++;  
+  } 
+  if (UseRightChannel==true)
+  {
+   long double k=((long double)(TapeData[right*2+1])-(long double)(TapeData[left*2+1]));
+   ch_level+=(double)(TapeData[left*2+1])+(HeadPosition-(long double)(pos))*k;
+   ch_summ++;
+  } 
+  if (ch_summ==0) ch_summ=1;
+  ch_level/=ch_summ;
+  volume=(unsigned char)ch_level;
+ }
+ return(true);
+}
+
+bool CTape::MoveHead(void)
+{
+ HeadPosition+=Speed;
+ unsigned long pos=(unsigned long)HeadPosition;
+ if (pos>=TapeLength) return(false); 
+ return(true);
+}
+
+bool CTape::ResetHead(void)
+{
+ HeadPosition=0;
+ return(true);
+}
+
+unsigned long CTape::GetTapeLength(void)
+{
+ return(TapeLength);
+}
+
+void CTape::Eject(void)
+{
+ if (TapeData!=NULL) delete(TapeData);
+ HeadPosition=0;
+ TapeData=NULL;
+ TapeLength=0;
+}
+
+bool CTape::ApplyFilter(void)
+{
+ /*
+ unsigned long n;
+ int Filter=TapeData[0];
+ for(n=0;n<TapeLength;n++)
+ {
+  Filter=Filter+TapeData[n];
+  Filter/=2;
+  TapeData[n]=Filter;
+ }
+ */
+ return(true);
+}
+
+long double CTape::GetSpeed(void)
+{
+ return(Speed);
+}
+
+bool CTape::EndOfTape(void)
+{
+ unsigned char volume;
+ if (ReadTape(volume)==false) return(true); //tape finished
+ return(false); //tape not finished
+}
+
+unsigned char CTape::GetLevel(int Step)
+{
+ unsigned long h_p=(unsigned long)HeadPosition;
+ int n;
+ unsigned long level=0;
+ int max=0;
+ int min=255;
+ if (h_p+Step>=TapeLength) h_p=TapeLength-Step;
+ if (TapeLength<Step)
+ {
+  h_p=0;
+  Step=TapeLength;
+ }
+ for(n=0;n<Step;n++,h_p++)
+ {
+  unsigned char volume;
+  if (Channels==1) volume=TapeData[h_p]; //for mono
+  if (Channels==2)
+  {
+   int ch_level=0;
+   int ch_summ=0;
+   if (UseLeftChannel==true)
+   {
+	ch_level+=TapeData[h_p*2];
+    ch_summ++;  
+   }
+   if (UseRightChannel==true)
+   {
+	ch_level+=TapeData[h_p*2+1];
+    ch_summ++;  
+   }
+   if (ch_summ==0) ch_summ=1;
+   ch_level/=ch_summ;
+   volume=ch_level;
+  }
+  level+=volume;
+  if (volume>max) max=volume;
+  if (volume<min) min=volume;
+ }
+ if (n!=0) level/=n;
+ int center=(max+min)/2;
+ level=(level+center)/2;
+ return((unsigned char)level);
+}
+
+bool CTape::SetUseChannel(bool use_left_channel,bool use_right_channel)
+{
+ UseLeftChannel=use_left_channel;
+ UseRightChannel=use_right_channel;
+ return(true);
+}
+

CTape.h

@@ -0,0 +1,37 @@
+#ifndef CTAPE_H
+#define CTAPE_H
+
+#include "stdafx.h"
+
+class CTape
+{
+ protected:
+
+  unsigned long TapeLength;
+  unsigned char *TapeData;
+  long double Speed;
+  long double HeadPosition;
+  int Channels;
+  bool UseLeftChannel;
+  bool UseRightChannel;
+
+ public:
+
+  CTape();
+  ~CTape();
+
+  bool LoadTape(char *FileName);
+  bool SetSpeed(long double speed);
+  bool ReadTape(unsigned char &volume);
+  bool MoveHead(void);
+  bool ResetHead(void);
+  unsigned long GetTapeLength(void);
+  void Eject(void);
+  bool ApplyFilter(void);
+  long double GetSpeed(void);
+  bool EndOfTape(void);
+  unsigned char GetLevel(int Step);
+  bool SetUseChannel(bool use_left_channel,bool use_right_channel);
+};
+
+#endif

Main.cpp

@@ -0,0 +1,35 @@
+#include "stdafx.h"
+#include "cdialog_main.h"
+
+class CWinApp_Main:public CWinApp
+{
+ protected:
+
+ public:
+
+  CWinApp_Main(void);
+ 
+  ~CWinApp_Main();
+ 
+  BOOL InitInstance(void);
+  
+};
+
+CWinApp_Main::CWinApp_Main(void)
+{
+}
+
+CWinApp_Main::~CWinApp_Main()
+{
+}
+
+BOOL CWinApp_Main::InitInstance(void)
+{
+ CDialog_Main cDialog_Main((LPSTR)IDD_DIALOG_MAIN,NULL);
+ cDialog_Main.DoModal();
+ return(TRUE);
+}
+
+CWinApp_Main cWinAppMain;
+
+

README.md

@@ -0,0 +1,47 @@
+The signal on the ZX-Spectrum tape is a frequency-modulated signal.
+Zero is encoded with the highest frequency. The clock/sync signal is slightly higher frequency.
+One is encoded with double the frequency of zero.
+Start tone has the frequency 2.5 times lower than the zero frequency.
+Encoded start tone sounds pi-i-i-i-i at the beginning of the tape.
+
+All signals are rectangular:
+
+_    __
+ |  |  |               - clock/sync signal.
+ |__|  |_
+_     ___
+ |   |   |             - zero or sync.
+ |___|   |_
+
+_        ______
+ |      |      |       - one.
+ |______|      |_
+
+_          ________
+ |        |        |   - start tone.
+ |________|        |_
+
+
+In general, the ZX-Spectrum signal looks like this:
+
+_          ________          ________    __     ___        ______
+ |        |        |        |        |  |  |   |   |      |      |
+ |________|        |________|        |__|  |___|   |______|      |
+
+                 start tone     sync signal   zero       one
+
+
+The program analyzes only the upper parts of the signals, respectively, the program specifies the duration of these parts of the signals in the samples of the sound file multiplied by 5. That is, if a high level of the signal in the sound file takes 30 counts, then in the duration we write 150.
+Only files with parameters 44100Hz, 8 bits, mono or stereo, not compressed, are decrypted.
+Such files can be easily obtained from recording programs.
+
+The signal level needs to be known in order to decide whether to receive a signal for a part of the high level or for a part of a low level. For this, two methods are used:
+ - Automatic. The computer analyzes the signal for N samples of audio data forward, averages signals and learns the average level (because the signals have the upper and them, then the middle will be average).
+ - Manual. The user himself sets the value of the level. For ideal files, this value is 127 - the middle of the range 0-255.
+
+When recording from a tape recorder, it is recommended that the signal be all within the range 0-255, and there was no clipping for too strong a signal level. That is, the volume is needed to be 
+small. Moreover, the noise at high volume also increases.
+
+Successful decoding! :)
+
+(c) Äìèòðèé Òðóíîâ (Dmitry Trunov) (da-nie), August 21, 2009, http://www.animekazan.net/forum2

Release/CTape.obj

@@ -0,0 +1,6 @@
+del *.obj
+del *.pch
+del *.idb
+del *.res
+
+