Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,674 @@
|
||||
/*
|
||||
Copyright 2015 by Joseph Forgione
|
||||
This file is part of VCC (Virtual Color Computer).
|
||||
|
||||
VCC (Virtual Color Computer) is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
VCC (Virtual Color Computer) is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with VCC (Virtual Color Computer). If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <Windows.h>
|
||||
#include <iostream>
|
||||
#include "resource.h"
|
||||
#include "defines.h"
|
||||
#include "coco3.h"
|
||||
#include "config.h"
|
||||
#include <vcc/util/DialogOps.h>
|
||||
#include <vcc/util/fileutil.h>
|
||||
#include "Cassette.h"
|
||||
#include "stdio.h"
|
||||
#include <vcc/util/logger.h>
|
||||
#include <functional>
|
||||
|
||||
unsigned char MotorState=0,TapeMode=STOP,WriteProtect=0,Quiet=30;
|
||||
static HANDLE TapeHandle=nullptr;
|
||||
static unsigned long TapeOffset=0,TotalSize=0;
|
||||
static char TapeFileName[MAX_PATH]="";
|
||||
static char CassPath[MAX_PATH];
|
||||
static unsigned char TempBuffer[8192];
|
||||
static unsigned char *CasBuffer=nullptr;
|
||||
static char TapeWritten = 0;
|
||||
static char FileType = TAPE_UNKNOWN;
|
||||
extern unsigned char TapeFastLoad;
|
||||
unsigned long BytesMoved=0;
|
||||
static unsigned int TempIndex=0;
|
||||
static unsigned int TapeRate=CAS_TAPEAUDIORATE;
|
||||
static unsigned int TapeSampleSize=0;
|
||||
static unsigned int MotorOffDelay = 0;
|
||||
static unsigned long PrvOffset=0,StalledCtr=0;
|
||||
|
||||
unsigned char One[21]={0xC8,0xE8,0xE8,0xF8,0xF8,0xE8,0xC8,0xA8,0x78,0x50,0x50,0x30,0x10,0x00,0x00,0x10,0x30,0x30,0x50,0x80,0xA8};
|
||||
unsigned char Zero[40]={0xC8,0xD8,0xE8,0xE8,0xF0,0xF8,0xF8,0xF8,0xF0,0xE8,0xD8,0xC8,0xB8,0xA8,0x90,0x78,0x78,0x68,0x50,0x40,0x30,0x20,0x10,0x08,0x00,0x00,0x00,0x08,0x10,0x10,0x20,0x30,0x40,0x50,0x68,0x68,0x80,0x90,0xA8,0xB8};
|
||||
|
||||
namespace VCC
|
||||
{
|
||||
struct WavHeader
|
||||
{
|
||||
char riff[4]; // RIFF
|
||||
uint32_t fileSize;
|
||||
char wave[4]; // WAVE
|
||||
};
|
||||
|
||||
struct WavBlock
|
||||
{
|
||||
char name[4]; // "data"
|
||||
uint32_t size;
|
||||
};
|
||||
|
||||
struct WavFmtBlock : WavBlock
|
||||
{
|
||||
uint16_t waveType;
|
||||
uint16_t channels;
|
||||
uint32_t bitRate;
|
||||
uint32_t bytesPerSec;
|
||||
uint16_t blockAlign;
|
||||
uint16_t bitsPerSample;
|
||||
};
|
||||
|
||||
void SampleSignedConversion(int width, uint8_t* outBuffer, const uint8_t* inBuffer, size_t samples)
|
||||
{
|
||||
for (size_t i = 0; i < samples; ++i)
|
||||
{
|
||||
auto p = inBuffer + i * width + width - 1;
|
||||
int sample = *p;
|
||||
outBuffer[i] = (uint8_t)(sample + CAS_SILENCE);
|
||||
}
|
||||
}
|
||||
|
||||
void SampleUnsignedConversion(int width, uint8_t* outBuffer, const uint8_t* inBuffer, size_t samples)
|
||||
{
|
||||
for (size_t i = 0; i < samples; ++i)
|
||||
{
|
||||
auto p = inBuffer + i * width + width - 1;
|
||||
uint8_t sample = *p;
|
||||
outBuffer[i] = sample;
|
||||
}
|
||||
}
|
||||
|
||||
void SampleFloatConversion(int width, uint8_t* outBuffer, const uint8_t* inBuffer, size_t samples)
|
||||
{
|
||||
for (size_t i = 0; i < samples; ++i)
|
||||
{
|
||||
auto p = inBuffer + i * width;
|
||||
float sample = *reinterpret_cast<const float*>(p);
|
||||
outBuffer[i] = (uint8_t)(sample * 128) + 256 / 2;
|
||||
}
|
||||
}
|
||||
|
||||
bool Init()
|
||||
{
|
||||
// reduce peak to peak to 75% for .cas as its more realistic what actual tape uses
|
||||
for (int i = 0; i < sizeof(One); ++i)
|
||||
One[i] = One[i] / 2 + One[i] / 4 + 64 / 2;
|
||||
for (int i = 0; i < sizeof(Zero); ++i)
|
||||
Zero[i] = Zero[i] / 2 + Zero[i] / 4 + 64 / 2;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool gInit = Init();
|
||||
}
|
||||
|
||||
static std::function<void(int, uint8_t*, const uint8_t*, size_t)> Conversion;
|
||||
|
||||
//Write Stuff
|
||||
static int LastTrans=0;
|
||||
static unsigned char Mask=0,Byte=0,LastSample=0;
|
||||
//****************************
|
||||
|
||||
void WavtoCas(const unsigned char *,unsigned int);
|
||||
int MountTape( const char *);
|
||||
void CloseTapeFile();
|
||||
void SyncFileBuffer();
|
||||
void CastoWav(unsigned char *,unsigned int);
|
||||
|
||||
unsigned int GetTapeRate()
|
||||
{
|
||||
return TapeRate;
|
||||
}
|
||||
|
||||
unsigned char GetMotorState()
|
||||
{
|
||||
if (MotorOffDelay > 0)
|
||||
{
|
||||
--MotorOffDelay;
|
||||
return 1;
|
||||
}
|
||||
return MotorState;
|
||||
}
|
||||
|
||||
//
|
||||
// true if tape playback is fast load cas
|
||||
//
|
||||
bool GetTapePlaybackFastLoad()
|
||||
{
|
||||
return !IsTapeWav() && TapeFastLoad && TapeMode == PLAY && TotalSize > 0;
|
||||
}
|
||||
|
||||
void Motor(unsigned char State)
|
||||
{
|
||||
MotorState=State;
|
||||
switch (MotorState)
|
||||
{
|
||||
// MOTOROFF
|
||||
case 0:
|
||||
SetSndOutMode(0);
|
||||
switch (TapeMode)
|
||||
{
|
||||
case STOP:
|
||||
break;
|
||||
|
||||
case PLAY:
|
||||
Quiet = 15;
|
||||
StalledCtr = 0;
|
||||
TempIndex = 0;
|
||||
MotorOffDelay = 10;
|
||||
break;
|
||||
|
||||
case REC:
|
||||
SyncFileBuffer();
|
||||
break;
|
||||
|
||||
case EJECT:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
// MOTORON
|
||||
case 1:
|
||||
switch (TapeMode)
|
||||
{
|
||||
case STOP:
|
||||
SetSndOutMode(0);
|
||||
break;
|
||||
|
||||
case PLAY:
|
||||
SetSndOutMode(2);
|
||||
break;
|
||||
|
||||
case REC:
|
||||
SetSndOutMode(1);
|
||||
break;
|
||||
|
||||
case EJECT:
|
||||
SetSndOutMode(0);
|
||||
}
|
||||
break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned int GetTapeCounter()
|
||||
{
|
||||
return TapeOffset;
|
||||
}
|
||||
|
||||
bool IsTapeWav()
|
||||
{
|
||||
return TapeHandle && FileType == TAPE_WAV;
|
||||
}
|
||||
|
||||
void SetTapeCounter(unsigned int Count, bool forced)
|
||||
{
|
||||
TapeOffset=Count;
|
||||
if (TapeOffset>TotalSize)
|
||||
TotalSize=TapeOffset;
|
||||
UpdateTapeCounter(TapeOffset,TapeMode,forced);
|
||||
return;
|
||||
}
|
||||
|
||||
void UpdateTapeStatus(char* status, int max)
|
||||
{
|
||||
if (TapeMode == PLAY && TapeOffset >= TotalSize)
|
||||
{
|
||||
++StalledCtr;
|
||||
if (StalledCtr >= 100)
|
||||
{
|
||||
TapeMode = STOP;
|
||||
UpdateTapeCounter(TapeOffset, TapeMode, true);
|
||||
}
|
||||
}
|
||||
if (TotalSize > 0 && StalledCtr < 100)
|
||||
snprintf(status, max, " | Tape:%05lu (%0.0f%%)", TapeOffset, ((float)std::min(TotalSize, (TapeOffset + 50)) * 100.0f / TotalSize));
|
||||
}
|
||||
|
||||
void SetTapeMode(unsigned char Mode) //Handles button pressed from Dialog
|
||||
{
|
||||
TapeMode=Mode;
|
||||
switch (TapeMode)
|
||||
{
|
||||
case STOP:
|
||||
|
||||
break;
|
||||
|
||||
case PLAY:
|
||||
if (TapeHandle == nullptr)
|
||||
{
|
||||
if (!LoadTape())
|
||||
{
|
||||
TapeMode = STOP;
|
||||
}
|
||||
else
|
||||
{
|
||||
TapeMode = Mode;
|
||||
}
|
||||
}
|
||||
|
||||
if (MotorState)
|
||||
{
|
||||
Motor(1);
|
||||
}
|
||||
break;
|
||||
|
||||
case REC:
|
||||
if (TapeHandle == nullptr)
|
||||
{
|
||||
if (!LoadTape())
|
||||
{
|
||||
TapeMode = STOP;
|
||||
}
|
||||
else
|
||||
{
|
||||
TapeMode = Mode;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case EJECT:
|
||||
CloseTapeFile();
|
||||
strcpy(TapeFileName,"EMPTY");
|
||||
break;
|
||||
}
|
||||
UpdateTapeCounter(TapeOffset,TapeMode);
|
||||
return;
|
||||
}
|
||||
|
||||
void FlushCassetteBuffer(const unsigned char *Buffer,unsigned int *Len)
|
||||
{
|
||||
if (TapeMode!=REC)
|
||||
return;
|
||||
|
||||
unsigned int Length = *Len;
|
||||
*Len = 0;
|
||||
|
||||
TapeWritten = true;
|
||||
switch(FileType)
|
||||
{
|
||||
case TAPE_WAV:
|
||||
SetFilePointer(TapeHandle,TapeOffset+44,nullptr,FILE_BEGIN);
|
||||
WriteFile(TapeHandle,Buffer,Length,&BytesMoved,nullptr);
|
||||
if (Length!=BytesMoved)
|
||||
return;
|
||||
TapeOffset+=Length;
|
||||
if (TapeOffset>TotalSize)
|
||||
TotalSize=TapeOffset;
|
||||
break;
|
||||
|
||||
case TAPE_CAS:
|
||||
WavtoCas(Buffer, Length);
|
||||
break;
|
||||
}
|
||||
UpdateTapeCounter(TapeOffset,TapeMode);
|
||||
return;
|
||||
}
|
||||
|
||||
void LoadCassetteBuffer(unsigned char *CassBuffer, unsigned int* CassBufferSize)
|
||||
{
|
||||
unsigned long BytesMoved=0;
|
||||
if (TapeMode != PLAY)
|
||||
{
|
||||
*CassBufferSize = TapeRate / 60;
|
||||
memset(&CassBuffer[0], CAS_SILENCE, *CassBufferSize);
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned int offset = TapeOffset;
|
||||
switch (FileType)
|
||||
{
|
||||
case TAPE_WAV:
|
||||
{
|
||||
if (TapeHandle)
|
||||
{
|
||||
SetFilePointer(TapeHandle, TapeOffset + 44, nullptr, FILE_BEGIN);
|
||||
ReadFile(TapeHandle, TempBuffer, TapeSampleSize * TapeRate / 60, &BytesMoved, nullptr);
|
||||
if (BytesMoved > 0)
|
||||
{
|
||||
unsigned int samples = BytesMoved / TapeSampleSize;
|
||||
Conversion(TapeSampleSize, CassBuffer, TempBuffer, samples);
|
||||
*CassBufferSize = samples;
|
||||
TapeOffset += BytesMoved;
|
||||
}
|
||||
if (TapeOffset > TotalSize)
|
||||
TapeOffset = TotalSize;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case TAPE_CAS:
|
||||
{
|
||||
CastoWav(CassBuffer, CAS_TAPEREADAHEAD);
|
||||
*CassBufferSize = CAS_TAPEREADAHEAD;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (TapeOffset == TotalSize) offset = TapeOffset;
|
||||
UpdateTapeCounter(offset,TapeMode);
|
||||
return;
|
||||
}
|
||||
|
||||
int MountTape( const char *FileName) //Return 1 on sucess 0 on fail
|
||||
{
|
||||
char Extension[4]="";
|
||||
unsigned char Index=0;
|
||||
if (TapeHandle!=nullptr)
|
||||
{
|
||||
TapeMode=STOP;
|
||||
CloseTapeFile();
|
||||
}
|
||||
|
||||
WriteProtect=0;
|
||||
FileType = TAPE_UNKNOWN; //1=wav 2=cas
|
||||
TapeHandle = CreateFile(FileName,GENERIC_READ | GENERIC_WRITE,0,nullptr,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,nullptr); //CREATE_NEW OPEN_ALWAYS
|
||||
if (TapeHandle == INVALID_HANDLE_VALUE) //Can't open read/write. try read only
|
||||
{
|
||||
TapeHandle = CreateFile(FileName,GENERIC_READ,0,nullptr,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,nullptr);
|
||||
WriteProtect=1;
|
||||
}
|
||||
if (TapeHandle==INVALID_HANDLE_VALUE)
|
||||
{
|
||||
MessageBox(nullptr,"Can't Mount","Error",0);
|
||||
return 0; //Give up
|
||||
}
|
||||
TapeWritten = false;
|
||||
TotalSize=SetFilePointer(TapeHandle,0,nullptr,FILE_END);
|
||||
TapeOffset=0;
|
||||
TapeRate = CAS_TAPEAUDIORATE;
|
||||
TapeSampleSize = 1;
|
||||
StalledCtr = 0;
|
||||
SetFilePointer(TapeHandle, 0, nullptr, FILE_BEGIN);
|
||||
strcpy(Extension,&FileName[strlen(FileName)-3]);
|
||||
for (Index=0;Index<strlen(Extension);Index++)
|
||||
Extension[Index]=toupper(Extension[Index]);
|
||||
|
||||
if (CasBuffer != nullptr)
|
||||
{
|
||||
free(CasBuffer);
|
||||
CasBuffer = nullptr;
|
||||
}
|
||||
|
||||
if (strcmp(Extension, "WAV") == 0)
|
||||
{
|
||||
using namespace VCC;
|
||||
using namespace std::placeholders;
|
||||
|
||||
WavHeader header;
|
||||
WavFmtBlock formatBlock;
|
||||
ReadFile(TapeHandle, &header, sizeof(header), &BytesMoved, nullptr);
|
||||
ReadFile(TapeHandle, &formatBlock, sizeof(formatBlock), &BytesMoved, nullptr);
|
||||
Conversion = nullptr;
|
||||
if (formatBlock.waveType == 1)
|
||||
{
|
||||
TapeSampleSize = formatBlock.channels * formatBlock.bitsPerSample / 8;
|
||||
if (formatBlock.bitsPerSample == 8)
|
||||
Conversion = SampleUnsignedConversion;
|
||||
else
|
||||
Conversion = SampleSignedConversion;
|
||||
}
|
||||
else if (formatBlock.waveType == 3)
|
||||
{
|
||||
TapeSampleSize = formatBlock.channels * formatBlock.bitsPerSample / 8;
|
||||
if (formatBlock.bitsPerSample == 32)
|
||||
Conversion = SampleFloatConversion;
|
||||
}
|
||||
if (!Conversion) return 0;
|
||||
CasBuffer = (unsigned char*)malloc(CAS_WRITEBUFFERSIZE);
|
||||
FileType = TAPE_WAV;
|
||||
TapeRate = formatBlock.bitRate;
|
||||
}
|
||||
else if (strcmp(Extension, "CAS") == 0)
|
||||
{
|
||||
FileType= TAPE_CAS;
|
||||
LastTrans=0;
|
||||
Mask=0;
|
||||
Byte=0;
|
||||
LastSample=0;
|
||||
TempIndex=0;
|
||||
|
||||
if (TotalSize > CAS_WRITEBUFFERSIZE)
|
||||
TotalSize = CAS_WRITEBUFFERSIZE;
|
||||
|
||||
CasBuffer=(unsigned char *)malloc(CAS_WRITEBUFFERSIZE);
|
||||
ReadFile(TapeHandle,CasBuffer,TotalSize,&BytesMoved,nullptr); //Read the whole file in for .CAS files
|
||||
if (BytesMoved!=TotalSize)
|
||||
return 0;
|
||||
}
|
||||
|
||||
SetSndOutMode(2);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CloseTapeFile()
|
||||
{
|
||||
if (TapeHandle==nullptr)
|
||||
return;
|
||||
SyncFileBuffer();
|
||||
CloseHandle(TapeHandle);
|
||||
TapeHandle=nullptr;
|
||||
TapeRate = CAS_TAPEAUDIORATE;
|
||||
TotalSize=0;
|
||||
}
|
||||
|
||||
unsigned int LoadTape()
|
||||
{
|
||||
FileDialog dlg;
|
||||
Setting().read("DefaultPaths","CassPath","",CassPath,MAX_PATH);
|
||||
dlg.setInitialDir(CassPath);
|
||||
dlg.setFilter("Cassette Files (.cas,.wav)\0*.cas;*.wav\0\0");
|
||||
dlg.setTitle("Insert Tape Image");
|
||||
dlg.setFlags(OFN_NOTESTFILECREATE);
|
||||
if (dlg.show()) {
|
||||
dlg.getpath(TapeFileName,MAX_PATH);
|
||||
if (MountTape(TapeFileName)==0) {
|
||||
MessageBox(nullptr,"Can't open file","Error",0);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
dlg.getdir(CassPath);
|
||||
if (strcmp(CassPath, "") != 0) {
|
||||
VCC::Util::FixDirSlashes(CassPath);
|
||||
Setting().write("DefaultPaths","CassPath",CassPath);
|
||||
}
|
||||
TapeWritten = false;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void GetTapeName(char *Name)
|
||||
{
|
||||
strcpy(Name,TapeFileName);
|
||||
return;
|
||||
}
|
||||
|
||||
void SyncFileBuffer ()
|
||||
{
|
||||
if (!TapeWritten) return;
|
||||
char Buffer[64]="";
|
||||
unsigned long BytesMoved=0;
|
||||
unsigned int FileSize=TotalSize+40-8;
|
||||
unsigned short WaveType=1; //WAVE type format
|
||||
unsigned int FormatSize=16; //size of WAVE section chunck
|
||||
unsigned short Channels=1; //mono/stereo
|
||||
unsigned int BitRate=TapeRate; //sample rate
|
||||
unsigned short BitsperSample=8; //Bits/sample
|
||||
unsigned int BytesperSec=BitRate*Channels*(BitsperSample/8); //bytes/sec
|
||||
unsigned short BlockAlign=(BitsperSample * Channels)/8; //Block alignment
|
||||
unsigned int ChunkSize=FileSize;
|
||||
|
||||
SetFilePointer(TapeHandle,0,nullptr,FILE_BEGIN);
|
||||
switch (FileType)
|
||||
{
|
||||
case TAPE_CAS:
|
||||
CasBuffer[TapeOffset]=Byte; //capture the last byte
|
||||
LastTrans=0; //reset all static inter-call variables
|
||||
Mask=0;
|
||||
Byte=0;
|
||||
LastSample=0;
|
||||
TempIndex=0;
|
||||
WriteFile(TapeHandle,CasBuffer,TapeOffset,&BytesMoved,nullptr);
|
||||
break;
|
||||
|
||||
case TAPE_WAV:
|
||||
sprintf(Buffer,"RIFF");
|
||||
WriteFile(TapeHandle,Buffer,4,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&FileSize,4,&BytesMoved,nullptr);
|
||||
sprintf(Buffer,"WAVE");
|
||||
WriteFile(TapeHandle,Buffer,4,&BytesMoved,nullptr);
|
||||
sprintf(Buffer,"fmt ");
|
||||
WriteFile(TapeHandle,Buffer,4,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&FormatSize,4,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&WaveType,2,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&Channels,2,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&BitRate,4,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&BytesperSec,4,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&BlockAlign,2,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&BitsperSample,2,&BytesMoved,nullptr);
|
||||
sprintf(Buffer,"data");
|
||||
WriteFile(TapeHandle,Buffer,4,&BytesMoved,nullptr);
|
||||
WriteFile(TapeHandle,&ChunkSize,4,&BytesMoved,nullptr);
|
||||
break;
|
||||
}
|
||||
FlushFileBuffers(TapeHandle);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void CastoWav(unsigned char *Buffer,unsigned int BytestoConvert)
|
||||
{
|
||||
unsigned char Byte=0;
|
||||
char Mask=0;
|
||||
|
||||
assert((BytestoConvert & 1) == 0);
|
||||
|
||||
// copy any left over bytes and fill remaining space with silence
|
||||
auto fillSilence = [&]()
|
||||
{
|
||||
int remaining = TempIndex - BytestoConvert;
|
||||
if (TempIndex)
|
||||
memcpy(Buffer, TempBuffer, TempIndex); //Partial Fill of return buffer;
|
||||
memset(&Buffer[TempIndex], CAS_SILENCE, -remaining); //and silence for the rest
|
||||
TempIndex = 0;
|
||||
};
|
||||
|
||||
if (Quiet>0)
|
||||
{
|
||||
Quiet--;
|
||||
fillSilence();
|
||||
return;
|
||||
}
|
||||
|
||||
if (TapeOffset >= TotalSize || TotalSize == 0) //End of tape return nothing
|
||||
{
|
||||
TapeMode=STOP; //Stop at end of tape
|
||||
fillSilence();
|
||||
return;
|
||||
}
|
||||
|
||||
while (TempIndex < BytestoConvert && TapeOffset < TotalSize)
|
||||
{
|
||||
Byte=CasBuffer[(TapeOffset++)%TotalSize];
|
||||
if (GetTapePlaybackFastLoad())
|
||||
{
|
||||
for (Mask = 0; Mask <= 7; ++Mask, Byte >>= 1)
|
||||
{
|
||||
// color basic expects high/low transitions so this
|
||||
// is the smallest waveform that we can have without
|
||||
// hacking the rom. CA
|
||||
// high/low waveform (b1) + tape bit (b0)
|
||||
TempBuffer[TempIndex++] = 2 + (Byte & 1);
|
||||
TempBuffer[TempIndex++] = 0 + (Byte & 1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (Mask = 0;Mask <= 7;Mask++)
|
||||
{
|
||||
if ((Byte & (1 << Mask)) == 0)
|
||||
{
|
||||
memcpy(&TempBuffer[TempIndex],Zero,40);
|
||||
TempIndex+=40;
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(&TempBuffer[TempIndex],One,21);
|
||||
TempIndex+=21;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int remaining = TempIndex - BytestoConvert;
|
||||
if (remaining >= 0)
|
||||
{
|
||||
memcpy(Buffer,TempBuffer,BytestoConvert); //Fill the return Buffer
|
||||
if (remaining > 0)
|
||||
memcpy(TempBuffer, &TempBuffer[BytestoConvert], remaining); //Slide the overage to the front
|
||||
TempIndex-=BytestoConvert; //Point to the Next free byte in the tempbuffer
|
||||
return;
|
||||
}
|
||||
|
||||
fillSilence();
|
||||
}
|
||||
|
||||
|
||||
void WavtoCas(const unsigned char *WaveBuffer,unsigned int Length)
|
||||
{
|
||||
unsigned char Bit=0,Sample=0;
|
||||
unsigned int Index=0,Width=0;
|
||||
|
||||
for (Index=0;Index<Length;Index++)
|
||||
{
|
||||
Sample=WaveBuffer[Index];
|
||||
if ( (LastSample <= 0x80) & (Sample>0x80)) //Low to High transition
|
||||
{
|
||||
Width=Index-LastTrans;
|
||||
if ((Width <10) | (Width >50)) //Invalid Sample Skip it
|
||||
{
|
||||
LastSample=0;
|
||||
LastTrans=Index;
|
||||
Mask=0;
|
||||
Byte=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
Bit=1;
|
||||
if (Width >30)
|
||||
Bit=0;
|
||||
Byte=Byte | (Bit<<Mask);
|
||||
Mask++;
|
||||
Mask&=7;
|
||||
if (Mask==0)
|
||||
{
|
||||
CasBuffer[TapeOffset++]=Byte;
|
||||
Byte=0;
|
||||
if (TapeOffset>= CAS_WRITEBUFFERSIZE) //Don't blow past the end of the buffer
|
||||
TapeMode=STOP;
|
||||
}
|
||||
|
||||
}
|
||||
LastTrans=Index;
|
||||
} //Fi LastSample
|
||||
LastSample=Sample;
|
||||
} //Next Index
|
||||
LastTrans-=Length;
|
||||
if (TapeOffset>TotalSize)
|
||||
TotalSize=TapeOffset;
|
||||
return;
|
||||
}
|
||||
Reference in new issue
Block a user