Initial import of the open source release

1 files changed, 1243 insertions, 0 deletions

diff --git a/tools/2CDT/src/2cdt.c b/tools/2CDT/src/2cdt.c
new file mode 100644
index 0000000..613662b
--- /dev/null
+++ b/tools/2CDT/src/2cdt.c
@@ -0,0 +1,1243 @@
+/*
+ *  2CDT Copyright (c) Kevin Thacker
+ *
+ *  This program 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 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+
+/* The following program is designed to create a .tzx/.cdt from a tape-file stored
+on the PC */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef UNIX
+#include <sys/io.h>
+#else
+#include <io.h>
+#endif
+#include "defs.h"
+#include "tzxfile.h"
+#include "getopt.h"
+#include <ctype.h>
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef unsigned __int64 ulong64;
+typedef signed __int64 long64;
+#else
+typedef unsigned long long ulong64;
+typedef signed long long long64;
+#endif
+
+enum
+{
+    CPC_METHOD_BLOCKS = 0,
+    CPC_METHOD_HEADERLESS,
+    CPC_METHOD_SPECTRUM,
+};
+
+static int ExecutionAddress;
+static BOOL ExecutionAddressOverride;
+static int LoadAddress;
+static BOOL  LoadAddressOverride;
+static int Type;
+static BOOL TypeOverride;
+static int Pause;
+static BOOL BuggyEmuExtraPause;
+
+#define MAXFILELEN 16
+
+static int BaudRate;                /* baud rate to write data */
+static int TZXWriteMethod;          /* method to write data into TZX file */
+static BOOL BlankBeforeUse;         /* blank existing CDT file before use */
+static int CPCMethod = CPC_METHOD_BLOCKS;
+
+/* I am using a enum, so that I can poke data into structures without
+worrying how the compiler has aligned it */
+enum
+{
+    CPC_TAPE_HEADER_FILENAME_BYTE0 = 0,
+    CPC_TAPE_HEADER_FILENAME_BYTE1,
+    CPC_TAPE_HEADER_FILENAME_BYTE2,
+    CPC_TAPE_HEADER_FILENAME_BYTE3,
+    CPC_TAPE_HEADER_FILENAME_BYTE4,
+    CPC_TAPE_HEADER_FILENAME_BYTE5,
+    CPC_TAPE_HEADER_FILENAME_BYTE6,
+    CPC_TAPE_HEADER_FILENAME_BYTE7,
+    CPC_TAPE_HEADER_FILENAME_BYTE8,
+    CPC_TAPE_HEADER_FILENAME_BYTE9,
+    CPC_TAPE_HEADER_FILENAME_BYTE10,
+    CPC_TAPE_HEADER_FILENAME_BYTE11,
+    CPC_TAPE_HEADER_FILENAME_BYTE12,
+    CPC_TAPE_HEADER_FILENAME_BYTE13,
+    CPC_TAPE_HEADER_FILENAME_BYTE14,
+    CPC_TAPE_HEADER_FILENAME_BYTE15,
+    CPC_TAPE_HEADER_BLOCK_NUMBER,
+    CPC_TAPE_HEADER_LAST_BLOCK_FLAG,
+    CPC_TAPE_HEADER_FILE_TYPE,
+    CPC_TAPE_HEADER_DATA_LENGTH_LOW,
+    CPC_TAPE_HEADER_DATA_LENGTH_HIGH,
+    CPC_TAPE_HEADER_DATA_LOCATION_LOW,
+    CPC_TAPE_HEADER_DATA_LOCATION_HIGH,
+    CPC_TAPE_HEADER_FIRST_BLOCK_FLAG,
+    CPC_TAPE_HEADER_DATA_LOGICAL_LENGTH_LOW,
+    CPC_TAPE_HEADER_DATA_LOGICAL_LENGTH_HIGH,
+    CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_LOW,
+    CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_HIGH,
+} CPC_TAPE_HEADER_ENUM;
+
+/* size of header */
+#define CPC_TAPE_HEADER_SIZE	64
+
+/* load a file into memory */
+BOOL	Host_LoadFile(const char *Filename, unsigned char **pLocation, unsigned long *pLength)
+{
+    FILE	*fh;
+    unsigned char	*pData;
+
+    *pLocation = NULL;
+    *pLength = 0;
+
+    if (Filename != NULL)
+    {
+        if (strlen(Filename) != 0)
+        {
+            fh = fopen(Filename, "rb");
+
+            if (fh != NULL)
+            {
+                int FileSize;
+
+#ifdef WIN32
+                int FNo;
+
+                FNo = _fileno(fh);
+                FileSize = _filelength(FNo);
+#else
+                unsigned long CurrentPosition;
+                CurrentPosition = ftell(fh);
+                fseek(fh, 0, SEEK_END);
+                FileSize = ftell(fh);
+                fseek(fh, CurrentPosition, SEEK_SET);
+#endif
+                if (FileSize != 0)
+                {
+                    pData = (unsigned char *)malloc(FileSize);
+
+                    if (pData != NULL)
+                    {
+                        if (fread(pData, 1, FileSize, fh) == FileSize)
+                        {
+                            *pLocation = pData;
+                            *pLength = FileSize;
+                            fclose(fh);
+                            return TRUE;
+                        }
+
+                        free(pData);
+                    }
+                }
+
+                fclose(fh);
+            }
+        }
+    }
+
+    return FALSE;
+}
+
+
+/* calculate checksum as AMSDOS would for the first 66 bytes of a datablock */
+/* this is used to determine if a file has a AMSDOS header */
+unsigned int AMSDOS_CalculateChecksum(unsigned char *pHeader)
+{
+    unsigned int Checksum;
+    int i;
+
+    Checksum = 0;
+
+    for (i = 0; i < 67; i++)
+    {
+        unsigned int CheckSumByte;
+
+        CheckSumByte = pHeader[i] & 0x0ff;
+
+        Checksum += CheckSumByte;
+    }
+
+    return Checksum;
+}
+
+/* CRC code shamelessly taken from Pierre Guerrier's AIFF decoder! */
+#define kCRCpoly  4129  /* used for binary long division in CRC */
+
+/* CRC polynomial: X^16+X^12+X^5+1 */
+unsigned int CRCupdate(unsigned int CRC, unsigned char new)
+{
+    unsigned int aux = CRC ^ (new << 8);
+    int i;
+
+    for (i = 0; i < 8; i++)
+        if (aux & 0x8000)
+            aux = (aux <<= 1) ^ kCRCpoly;
+        else
+            aux <<= 1;
+
+    return (aux);
+}
+
+/*
+ID : 11  -  Turbo loading data block
+-------
+        This block is very similar  to  the  normal  TAP  block but  with  some
+        additional   info  on  the  timings  and  other  important differences.
+        The same tape encoding is used as for the standard speed data block.
+        If a  block should  use some  non-standard  sync or  pilot  tones  (for
+        example all sorts of protection schemes) then use the next three blocks
+        to describe it.
+
+00 2  Length of PILOT pulse                                              [2168]
+02 2  Length of SYNC First pulse                                          [667]
+04 2  Length of SYNC Second pulse                                         [735]
+06 2  Length of ZERO bit pulse                                            [855]
+08 2  Length of ONE bit pulse                                            [1710]
+0A 2  Length of PILOT tone (in PILOT pulses)           [8064 Header, 3220 Data]
+0C 1  Used bits in last byte (other bits should be 0)                       [8]
+      i.e. if this is 6 then the bits (x) used in last byte are: xxxxxx00
+0D 2  Pause After this block in milliseconds (ms)                        [1000]
+0F 3  Length of following data
+12 x  Data; format is as for TAP (MSb first)
+
+- Length: [0F,10,11]+12
+*/
+
+/* 2 pulses per bit, tone is composed of 1 bits */
+#define CPC_PILOT_TONE_NUM_WAVES	(2048)
+#define CPC_PILOT_TONE_NUM_PULSES (CPC_PILOT_TONE_NUM_WAVES*2)
+
+#define CPC_NOPS_PER_FRAME (19968)
+#define CPC_NOPS_PER_SECOND	(CPC_NOPS_PER_FRAME*50)
+#define CPC_T_STATES	(CPC_NOPS_PER_SECOND*4)
+
+#define T_STATE_CONVERSION_FACTOR (TZX_T_STATES<<8)/(CPC_T_STATES>>8)
+/* pause between each block */
+#define CPC_PAUSE_AFTER_BLOCK_IN_MS	2500
+/* pause between tape header and data for block */
+#define CPC_PAUSE_AFTER_HEADER_IN_MS 14
+
+void InitialiseStandardSpeedDataBlock(TZX_BLOCK *pBlock, int Pause)
+{
+    unsigned char *pHeader = TZX_GetBlockHeaderPtr(pBlock);
+
+    if (pHeader != NULL)
+    {
+        /* check it is a turbo-loading data block */
+        if (pHeader[0] == TZX_STANDARD_SPEED_DATA_BLOCK)
+        {
+            pHeader++;
+
+            pHeader[0x00] = (Pause & 0x0ff);
+            pHeader[0x01] = (Pause >> 8);
+
+
+        }
+    }
+}
+
+void	CPC_InitialiseTurboLoadingDataBlock(TZX_BLOCK *pBlock, int BaudRate, int Pause)
+{
+    unsigned char *pHeader = TZX_GetBlockHeaderPtr(pBlock);
+
+    if (pHeader != NULL)
+    {
+        /* check it is a turbo-loading data block */
+        if (pHeader[0] == TZX_TURBO_LOADING_DATA_BLOCK)
+        {
+            int ZeroPulseLengthInMicroseconds;
+            long64 ZeroPulseLengthInCPCTStates;
+            int OnePulseLength;
+            int ZeroPulseLength;
+
+            pHeader++;
+            /* equation from CPC firmware guide:
+            Average baud rate: = 1 000 000/(3*half zero length) = 333 333/Half zero length
+            */
+
+            ZeroPulseLengthInMicroseconds = 333333 / BaudRate;
+            ZeroPulseLengthInCPCTStates = ZeroPulseLengthInMicroseconds << 2;
+
+            ZeroPulseLength = (ZeroPulseLengthInCPCTStates *
+                               (T_STATE_CONVERSION_FACTOR >> 8)) >> 8;
+
+            /* one pulse is twice the size of a zero pulse */
+            OnePulseLength = ZeroPulseLength << 1;
+
+            /* PILOT pulse on CPC is a one bit */
+            pHeader[0x00] = (unsigned char)OnePulseLength;
+            pHeader[0x01] = (unsigned char)(OnePulseLength >> 8);
+
+            /* SYNC on CPC is a zero bit, both sync pulses will be the same */
+            pHeader[0x02] = pHeader[0x04] = (unsigned char)ZeroPulseLength;
+            pHeader[0x03] = pHeader[0x05] = (unsigned char)(ZeroPulseLength >> 8);
+
+            /* write zero pulse length */
+            pHeader[0x06] = (unsigned char)ZeroPulseLength;
+            pHeader[0x07] = (unsigned char)(ZeroPulseLength >> 8);
+
+            /* write one pulse length */
+            pHeader[0x08] = (unsigned char)OnePulseLength;
+            pHeader[0x09] = (unsigned char)(OnePulseLength >> 8);
+
+            /* PILOT pulse is same as 1 Pulse */
+            /* pilot tone is 2048 bits long */
+            pHeader[0x0a] = CPC_PILOT_TONE_NUM_PULSES & 0x0ff;
+            pHeader[0x0b] = (CPC_PILOT_TONE_NUM_PULSES >> 8);
+
+            /* the end of the block will be the trailer bytes. Say all bits are
+            used, although, because it doesn't contain useful data it doesn't matter */
+            pHeader[0x0c] = 8;
+
+            pHeader[0x0d] = (Pause & 0x0ff);
+            pHeader[0x0e] = (Pause >> 8);
+
+
+        }
+    }
+}
+
+
+
+void WriteStandardSpeedDataBlock(TZX_FILE *pFile, unsigned char SyncPattern, unsigned char *pData, int DataSize, int Pause)
+{
+    TZX_BLOCK *pBlock;
+    unsigned char *pBlockData;
+
+    pBlock = TZX_CreateBlock(TZX_STANDARD_SPEED_DATA_BLOCK);
+    InitialiseStandardSpeedDataBlock(pBlock, Pause);
+
+    if (pBlock != NULL)
+    {
+        /* one byte for sync, one byte for checksum */
+        int TZX_DataBlockSize = DataSize + 2;
+
+        /* add block to end of file */
+        TZX_AddBlockToEndOfFile(pFile, pBlock);
+
+        /* allocate data in block */
+        TZX_AddDataToBlock(pBlock, TZX_DataBlockSize);
+
+        pBlockData = TZX_GetBlockDataPtr(pBlock);
+
+        if (pBlockData != NULL)
+        {
+            char CheckSum = SyncPattern;
+            int i;
+
+            /* write pattern */
+            *pBlockData = SyncPattern;
+            ++pBlockData;
+
+            for (i = 0; i < DataSize; i++)
+            {
+                char ch = *pData;
+                ++pData;
+                CheckSum ^= ch;
+                *pBlockData = ch;
+                ++pBlockData;
+            }
+            *pBlockData = CheckSum & 0x0ff;
+        }
+    }
+}
+
+
+#define CPC_DATA_CHUNK_SIZE 256
+#define CPC_DATA_BLOCK_SIZE 2048
+
+/* write a block of data to a file */
+void	CPC_WriteTurboLoadingDataBlock(TZX_FILE *pFile, unsigned char SyncPattern, unsigned char *pData, int DataSize, int Pause)
+{
+    TZX_BLOCK *pBlock;
+    unsigned char *pBlockData;
+
+    int NumChunks;
+    int TZX_DataBlockSize;
+
+    /* divide into complete 256 byte blocks */
+    NumChunks = (DataSize + 255) >> 8;
+
+    /* each tape block is split into 256 chunks, each chunk has a CRC */
+
+    /* size of all chunks, plus CRC's for each block */
+    TZX_DataBlockSize =
+        /* size of all chunks */
+        (NumChunks << 8) +
+        /* size of CRC's for all chunks */
+        (NumChunks << 1) +
+        /* size of trailer in bytes */
+        4 +
+        /* size of sync pattern */
+        1;
+
+
+
+    pBlock = TZX_CreateBlock(TZX_TURBO_LOADING_DATA_BLOCK);
+    CPC_InitialiseTurboLoadingDataBlock(pBlock, BaudRate, Pause);
+
+
+    if (pBlock != NULL)
+    {
+        /* add block to end of file */
+        TZX_AddBlockToEndOfFile(pFile, pBlock);
+
+        /* allocate data in block */
+        TZX_AddDataToBlock(pBlock, TZX_DataBlockSize);
+
+        pBlockData = TZX_GetBlockDataPtr(pBlock);
+
+        if (pBlockData != NULL)
+        {
+            int i, j;
+            unsigned char *pDataPtr;
+            int DataSizeRemaining;
+            unsigned char *pBlockPtr;
+            unsigned short CRC;
+
+            pDataPtr = pData;
+            DataSizeRemaining = DataSize;
+            pBlockPtr = pBlockData;
+
+            /* write pattern */
+            pBlockPtr[0] = SyncPattern;
+            pBlockPtr++;
+
+            /* write each chunk in turn and calculate CRC */
+            for (i = 0; i < NumChunks; i++)
+            {
+                /* copy data into block */
+                if (DataSizeRemaining < CPC_DATA_CHUNK_SIZE)
+                {
+                    /* less than CPC_DATA_CHUNK_SIZE */
+                    /* copy data, and fill rest with zeros */
+
+                    /* copy less than 256 bytes */
+                    memcpy(pBlockPtr, pDataPtr, DataSizeRemaining);
+                    /* fill reset of chunk with zero's */
+                    memset(pBlockPtr + DataSizeRemaining, 0, CPC_DATA_CHUNK_SIZE - DataSizeRemaining);
+                    /* update source pointer */
+                    pDataPtr += DataSizeRemaining;
+                    /* update size remaining - nothing */
+                    DataSizeRemaining = 0;
+                }
+                else
+                {
+                    /* greater or equal to CPC_DATA_CHUNK_SIZE */
+                    /* copy CPC_DATA_CHUNK_SIZE max */
+                    memcpy(pBlockPtr, pDataPtr, CPC_DATA_CHUNK_SIZE);
+                    /* update source pointer */
+                    pDataPtr += CPC_DATA_CHUNK_SIZE;
+                    /* update size remaining */
+                    DataSizeRemaining -= CPC_DATA_CHUNK_SIZE;
+                }
+
+                /* reset CRC */
+                CRC = 0x0ffff;
+
+                /* calculate CRC for block */
+                for (j = 0; j < CPC_DATA_CHUNK_SIZE; j++)
+                {
+                    char ch;
+
+                    ch = pBlockPtr[0];
+                    pBlockPtr++;
+                    CRC = CRCupdate(CRC, ch);
+                }
+
+                /* store CRC inverted */
+                pBlockPtr[0] = (CRC >> 8) ^ 0x0ff;
+                pBlockPtr++;
+                pBlockPtr[0] = CRC ^ 0x0ff;
+                pBlockPtr++;
+            }
+
+
+            /* write trailer */
+            memset(pBlockPtr, 0x0ff, 4);
+        }
+    }
+}
+
+/*
+ID : 14  -  Pure data block
+-------
+        This is the same as in the turbo loading data block, except that it has
+        no pilot or sync pulses.
+
+00 2  Length of ZERO bit pulse
+02 2  Length of ONE bit pulse
+04 1  Used bits in LAST Byte
+05 2  Pause after this block in milliseconds (ms)
+07 3  Length of following data
+0A x  Data
+*/
+
+void	CPC_InitialisePureDataBlock(TZX_BLOCK *pBlock, int BaudRate, int Pause)
+{
+    unsigned char *pHeader = TZX_GetBlockHeaderPtr(pBlock);
+
+    if (pHeader != NULL)
+    {
+        /* check it is a turbo-loading data block */
+        if (pHeader[0] == TZX_PURE_DATA_BLOCK)
+        {
+            int ZeroPulseLengthInMicroseconds;
+            long64 ZeroPulseLengthInCPCTStates;
+            int OnePulseLength;
+            int ZeroPulseLength;
+
+            pHeader++;
+            /* equation from CPC firmware guide:
+            Average baud rate: = 1 000 000/(3*half zero length) = 333 333/Half zero length
+            */
+
+            ZeroPulseLengthInMicroseconds = 333333 / BaudRate;
+            ZeroPulseLengthInCPCTStates = ZeroPulseLengthInMicroseconds << 2;
+
+            ZeroPulseLength = (ZeroPulseLengthInCPCTStates *
+                               (T_STATE_CONVERSION_FACTOR >> 8)) >> 8;
+
+            /* one pulse is twice the size of a zero pulse */
+            OnePulseLength = ZeroPulseLength << 1;
+            /* write zero pulse length */
+            pHeader[0x00] = ZeroPulseLength;
+            pHeader[0x01] = ZeroPulseLength >> 8;
+
+            /* write one pulse length */
+            pHeader[0x02] = OnePulseLength;
+            pHeader[0x03] = OnePulseLength >> 8;
+
+            /* the end of the block will be the trailer bytes. Say all bits are
+            used, although, because it doesn't contain useful data it doesn't matter */
+            pHeader[0x04] = 8;
+
+            /* write pause */
+            pHeader[0x05] = (Pause & 0x0ff);
+            pHeader[0x06] = (Pause >> 8) & 0x0ff;
+
+
+        }
+    }
+}
+
+
+/* the following is for a bitstream */
+unsigned char *pData;
+unsigned long ByteCount;
+unsigned long BitCount;
+
+/* initialise bit stream with buffer to write data to */
+void	BitStream_Initialise(unsigned char *pBuffer)
+{
+    pData = pBuffer;
+    ByteCount = 0;
+    BitCount = 0;
+}
+
+/* write bit to stream */
+void	BitStream_WriteBit(int Bit)
+{
+    unsigned char Data;
+
+    /* get current data written */
+    Data = pData[ByteCount];
+    Data &= ~(1 << (7 - BitCount));
+    Data |= (Bit << (7 - BitCount));
+    pData[ByteCount] = Data;
+
+    /* increment bit count */
+    BitCount++;
+    /* if we overrun 8-bits, then bit 3 will be set, add this on */
+    ByteCount += (BitCount >> 3);
+    /* mask off bit count */
+    BitCount &= 0x07;
+}
+
+/* write byte to stream */
+void	BitStream_WriteByte(unsigned char Byte)
+{
+    int b;
+    int Bit;
+    unsigned char LocalByte;
+
+    LocalByte = Byte;
+
+    for (b = 0; b < 8; b++)
+    {
+        Bit = LocalByte & 0x080;
+        Bit = Bit >> 7;
+        BitStream_WriteBit(Bit);
+        LocalByte = LocalByte << 1;
+    }
+}
+
+
+
+/* write a block of data to a file */
+void	CPC_WritePureDataBlock(TZX_FILE *pFile, unsigned char SyncPattern, unsigned char *pData, int DataSize, int Pause)
+{
+    TZX_BLOCK *pBlock;
+    unsigned char *pBlockData;
+
+    int NumChunks;
+    int TZX_DataBlockSize;
+
+    /* divide into complete 256 byte blocks */
+    NumChunks = (DataSize + 255) >> 8;
+
+    /* each tape block is split into 256 chunks, each chunk has a CRC */
+
+    /* size of all chunks, plus CRC's for each block */
+    TZX_DataBlockSize =
+        /* size of all chunks */
+        (NumChunks << 8) +
+        /* size of CRC's for all chunks */
+        (NumChunks << 1) +
+        /* size of trailer in bytes */
+        4 +
+        /* size of sync pattern */
+        1;
+
+    TZX_DataBlockSize +=
+        /* pilot tone - CPC_PILOT_TONE_NUM_WAVES 1 bit's, a zero bit then data as before ... */
+        ((CPC_PILOT_TONE_NUM_WAVES + 1) + 7) >> 3;
+
+    pBlock = TZX_CreateBlock(TZX_PURE_DATA_BLOCK);
+    CPC_InitialisePureDataBlock(pBlock, BaudRate, Pause);
+
+
+    if (pBlock != NULL)
+    {
+        /* add block to end of file */
+        TZX_AddBlockToEndOfFile(pFile, pBlock);
+
+        /* allocate data in block */
+        TZX_AddDataToBlock(pBlock, TZX_DataBlockSize);
+
+        pBlockData = TZX_GetBlockDataPtr(pBlock);
+
+        if (pBlockData != NULL)
+        {
+            int i, j;
+            unsigned char *pDataPtr;
+            int DataSizeRemaining;
+            unsigned char *pBlockPtr;
+            unsigned short CRC;
+
+            pDataPtr = pData;
+            DataSizeRemaining = DataSize;
+            pBlockPtr = pBlockData;
+
+            BitStream_Initialise(pBlockPtr);
+
+            /* write leader */
+            for (i = 0; i < CPC_PILOT_TONE_NUM_WAVES; i++)
+                BitStream_WriteBit(1);
+
+            BitStream_WriteBit(0);
+
+
+            BitStream_WriteByte(SyncPattern);
+
+            /* write each chunk in turn and calculate CRC */
+            for (i = 0; i < NumChunks; i++)
+            {
+                int BlockSizeToWrite;
+
+                /* copy data into block */
+                if (DataSizeRemaining < CPC_DATA_CHUNK_SIZE)
+                    BlockSizeToWrite = DataSizeRemaining;
+                else
+                    BlockSizeToWrite = CPC_DATA_CHUNK_SIZE;
+
+                CRC = 0x0ffff;
+
+                for (j = 0; j < BlockSizeToWrite; j++)
+                {
+                    char ch;
+
+                    /* get byte */
+                    ch = pDataPtr[0];
+                    pDataPtr++;
+                    /* update CRC */
+                    CRC = CRCupdate(CRC, ch);
+                    /* write byte to stream */
+                    BitStream_WriteByte(ch);
+                }
+
+                if (BlockSizeToWrite != CPC_DATA_CHUNK_SIZE)
+                {
+                    /* write padding zero's */
+                    for (j = 0; j < (CPC_DATA_CHUNK_SIZE - BlockSizeToWrite); j++)
+                    {
+                        char ch;
+
+                        ch = 0;
+                        /* update CRC */
+                        CRC = CRCupdate(CRC, ch);
+                        /* write byte to stream */
+                        BitStream_WriteByte(ch);
+                    }
+                }
+
+                DataSizeRemaining -= BlockSizeToWrite;
+
+                CRC = CRC ^ 0x0ffff;
+
+                BitStream_WriteByte((CRC >> 8));
+                BitStream_WriteByte(CRC);
+            }
+
+            /* write trailer */
+            for (i = 0; i < 32; i++)
+                BitStream_WriteBit(1);
+        }
+    }
+}
+
+/* write a data block in format specified */
+void	CPC_WriteDataBlock(TZX_FILE *pFile, unsigned char SyncByte, unsigned char *pData, unsigned long DataSize, int Pause)
+{
+    switch (TZXWriteMethod)
+    {
+        case TZX_TURBO_LOADING_DATA_BLOCK:
+        {
+            CPC_WriteTurboLoadingDataBlock(pFile, SyncByte, pData, DataSize, Pause);
+        }
+        break;
+
+        case TZX_PURE_DATA_BLOCK:
+        {
+            /* write header */
+            CPC_WritePureDataBlock(pFile, SyncByte, pData, DataSize, Pause);
+        }
+        break;
+    }
+}
+
+#define UTILITY_NAME "2CDT"
+
+void	DisplayInfo()
+{
+    printf("%s will transfer files into a .CDT/.TZX tape image, in Amstrad CPC/CPC+\r\n", UTILITY_NAME);
+    printf("KC Compact form.\r\n\r\n");
+    printf("Usage: %s [arguments] <input filename> <.cdt image>\r\n\r\n", UTILITY_NAME);
+    printf("-n              - Blank CDT file before use\n");
+    printf("-b <number>	    - Specify Baud rate (default 2000)\n");
+    printf("-s <0 or 1>     - Specify 'Speed Write'.\n");
+    printf("                  0 = 1000 baud, 1 = 2000 baud (default)\n");
+    printf("-t <method>     - TZX Block Write Method.\n");
+    printf("                  0 = Pure Data, 1 = Turbo Loading (default)\n");
+    printf("-m <method>     - Data method\n");
+    printf("                  0 = blocks (default)\n");
+    printf("                  1 = headerless (Firmware function: CAS READ - &BCA1) \n");
+    printf("                  2 = spectrum \n");
+    printf("                  3 = Two blocks. First block of 2K, second block has remainder\n");
+    printf("                  4 = Two blocks. First block of 1 byte, second block has remainder\n");
+    printf("-X <number> 	= Define or override execution address (default is &1000 if no header)\r\n");
+    printf("-L <number> 	= Define or override load address (default is &1000 if no header)\r\n");
+    printf("-F <number> 	= Define or override file type (0=BASIC, 2=Binary (default if no header)) etc. Applies to Data method 0\r\n");
+    printf("-p <number> 	= Set initial pause in milliseconds (default 3000ms)\r\n");
+    printf("-P 				= Add a 1ms pause for buggy emulators that ignore first block\r\n");
+    printf("-r <tape filename>\n");
+    printf("                - Add <input filename> as <tape filename> to CDT (rename file)\n");
+}
+
+extern char *optarg;
+
+int ReadNumberParameter(char *param)
+{
+    int Length = strlen(param);
+    BOOL bIsHex = FALSE;
+    int Offset = 0;
+    unsigned long Value = 0;
+    char ch;
+
+    if (Length == 0)
+        return 0;
+
+    /* check for common prefixs for hex numbers */
+    if ((Length > 1) && ((param[0] == '&') || (param[0] == '$')))
+    {
+        Offset = 1;
+        bIsHex = TRUE;
+    }
+    else if ((Length > 2) && (param[0] == '0') && ((param[1] == 'x') || (param[1] == 'X')))
+    {
+        Offset = 2;
+        bIsHex = TRUE;
+    }
+
+    if (!bIsHex)
+        return atoi(param);
+
+    ch = param[Offset];
+    while (ch != '\0')
+    {
+        Value = Value << 4;
+        if ((ch >= '0') && (ch <= '9'))
+            Value = Value | (ch - '0');
+        else if ((ch >= 'a') && (ch <= 'f'))
+            Value = Value | ((ch - 'a') + 10);
+        else if ((ch >= 'A') && (ch <= 'F'))
+            Value = Value | ((ch - 'A') + 10);
+        Offset++;
+        ch = param[Offset];
+    }
+
+    return Value;
+}
+
+int		main(int argc, char *argv[])
+{
+    unsigned char *pTapeFilename = NULL;
+
+    if (argc == 1)
+        DisplayInfo();
+    else
+    {
+        TZX_FILE *pTZXFile;
+        unsigned char *pSourceFilename;
+        unsigned char *pDestFilename;
+        unsigned char *pData;
+        unsigned long DataLength;
+        int c;
+
+        /* initialise defaults */
+        BaudRate = 2000;
+        Pause = 3000;
+        Type = 2;
+        TypeOverride = FALSE;
+        LoadAddressOverride = FALSE;
+        TZXWriteMethod = TZX_TURBO_LOADING_DATA_BLOCK;
+        BlankBeforeUse = FALSE;
+        ExecutionAddress = LoadAddress = 0x01000;
+        ExecutionAddressOverride = FALSE;
+        LoadAddressOverride = FALSE;
+
+        printf("-n              - Blank CDT file before use\n");
+        printf("-b <number>	    - Specify Baud rate (default 2000)\n");
+        printf("-s <0 or 1>     - Specify 'Speed Write'.\n");
+        printf("                  0 = 1000 baud, 1 = 2000 baud (default)\n");
+        printf("-t <method>     - TZX Block Write Method.\n");
+        printf("                  0 = Pure Data, 1 = Turbo Loading (default)\n");
+        printf("-m <method>     - Data method\n");
+        printf("                  0 = blocks (default)\n");
+        printf("                  1 = headerless (Firmware function: CAS READ - &BCA1) \n");
+        printf("                  2 = spectrum \n");
+        printf("                  3 = Two blocks. First block of 2K, second block has remainder\n");
+        printf("                  4 = Two blocks. First block of 1 byte, second block has remainder\n");
+        printf("-X <number> 	= Define or override execution address (default is &1000 if no header)\r\n");
+        printf("-L <number> 	= Define or override load address (default is &1000 if no header)\r\n");
+        printf("-F <number> 	= Define or override file type (0=BASIC, 2=Binary (default if no header)) etc. Applies to Data method 0\r\n");
+        printf("-p <number> 	= Set initial pause in milliseconds (default 3000ms)\r\n");
+        printf("-P 				= Add a 1ms pause for buggy emulators that ignore first block\r\n");
+        printf("-r <tape filename>\n");
+        printf("                - Add <input filename> as <tape filename> to CDT (rename file)\n");
+
+
+        do
+        {
+            c = getopt(argc, argv, "r:nb:p:m:t:F:L:s:X:p:P");
+
+            switch (c)
+            {
+                case 'm':
+                {
+                    int nMethod = atoi(optarg);
+                    CPCMethod = nMethod;
+
+                }
+                break;
+
+                case 'p':
+                {
+                    Pause = atoi(optarg);
+                    if (Pause < 0)
+                        Pause = 0;
+                }
+                break;
+
+                case 'r':
+                {
+                    pTapeFilename = optarg;
+                }
+                break;
+
+                case 'n':
+                {
+                    BlankBeforeUse = TRUE;
+                }
+                break;
+
+                case 'b':
+                {
+                    int Baud = atoi(optarg);
+                    if ((Baud > 0) && (Baud < 6000))
+                        BaudRate = Baud;
+                }
+                break;
+
+                case 'X':
+                {
+                    ExecutionAddress = ReadNumberParameter(optarg) & 0x0ffff;
+                    ExecutionAddressOverride = TRUE;
+                }
+                break;
+
+                case 'L':
+                {
+                    LoadAddress = ReadNumberParameter(optarg) & 0x0ffff;
+                    LoadAddressOverride = TRUE;
+                }
+                break;
+
+                case 's':
+                {
+                    int SpeedWrite = atoi(optarg);
+                    if (SpeedWrite == 1)
+                        BaudRate = 2000;
+                    else
+                        BaudRate = 1000;
+                }
+                break;
+
+                case 'F':
+                {
+                    Type = atoi(optarg) & 0x0ff;
+                    TypeOverride = TRUE;
+
+
+                }
+                break;
+
+
+                case 'P':
+                {
+                    BuggyEmuExtraPause = TRUE;
+
+                }
+                break;
+
+                case 't':
+                {
+                    int nMethod = atoi(optarg);
+                    if (nMethod == 0)
+                        TZXWriteMethod = TZX_PURE_DATA_BLOCK;
+                    else if (nMethod == 1)
+                        TZXWriteMethod = TZX_TURBO_LOADING_DATA_BLOCK;
+                    else if (nMethod == 2)
+                        TZXWriteMethod = TZX_STANDARD_SPEED_DATA_BLOCK;
+                }
+                break;
+
+                default:
+                {
+                }
+                break;
+            }
+        }
+        while (c != -1);
+
+        if ((argc - optind) == 0)
+        {
+            printf("No source file or destination file have been specified!\n");
+            exit(1);
+        }
+
+        if ((argc - optind) == 1)
+        {
+            printf("No destination file has been specified\n");
+            exit(1);
+        }
+
+        pSourceFilename = argv[optind];
+        pDestFilename = argv[optind + 1];
+
+        /* create TZX file */
+        pTZXFile = TZX_CreateFile(TZX_VERSION_MAJOR, TZX_VERSION_MINOR);
+
+        if (pTZXFile != NULL)
+        {
+            int nFile;
+
+
+            if (BlankBeforeUse)
+            {
+                TZX_BLOCK *pBlock;
+
+                /* if buggy emu, add an extra small pause */
+                if (BuggyEmuExtraPause)
+                {
+                    pBlock = TZX_CreateBlock(TZX_PAUSE_BLOCK);
+
+                    if (pBlock != NULL)
+                    {
+                        /* add a 1ms initial pause for buggy emus */
+                        TZX_SetupPauseBlock(pBlock, 1);
+                        TZX_AddBlockToEndOfFile(pTZXFile, pBlock);
+                    }
+                }
+
+
+                /* correct pause */
+                pBlock = TZX_CreateBlock(TZX_PAUSE_BLOCK);
+
+                if (pBlock != NULL)
+                {
+                    TZX_SetupPauseBlock(pBlock, Pause);
+                    TZX_AddBlockToEndOfFile(pTZXFile, pBlock);
+                }
+            }
+
+
+            if (Host_LoadFile(pSourceFilename, &pData, &DataLength))
+            {
+                int FileOffset;
+                int FileLengthRemaining;
+                int TapeBlockSize;
+                BOOL FirstBlock, LastBlock;
+                int BlockIndex;
+                unsigned short BlockLocation;
+
+                /* header for tape file */
+                unsigned char TapeHeader[CPC_TAPE_HEADER_SIZE];
+
+                /* calculate checksum from loaded file */
+                unsigned short CalculatedChecksum = (unsigned short)AMSDOS_CalculateChecksum(pData);
+
+                /* get stored checksum */
+                unsigned short StoredChecksum =
+                    (pData[67] & 0x0ff) |
+                    (pData[68] & 0x0ff) << 8;
+
+                FileOffset = 0;
+                FileLengthRemaining = DataLength;
+                BlockIndex = 1;
+                FirstBlock = TRUE;
+
+                /* insert a pause block - 1 second, this is added onto the end of the previous block */
+                /*            if (BlankBeforeUse == FALSE)
+                            {
+                                TZX_BLOCK *pBlock;
+
+                                pBlock = TZX_CreateBlock(TZX_PAUSE_BLOCK);
+
+                                if (pBlock!=NULL)
+                                {
+                                    TZX_SetupPauseBlock(pBlock, 2000);
+                                    TZX_AddBlockToEndOfFile(pTZXFile,pBlock);
+                                }
+                            }
+                */
+
+
+                /* clear tape header */
+                memset(TapeHeader, 0, CPC_TAPE_HEADER_SIZE);
+
+                /* checksum's match? */
+                if (CalculatedChecksum == StoredChecksum)
+                {
+                    /* copy file type */
+                    TapeHeader[CPC_TAPE_HEADER_FILE_TYPE] = pData[CPC_TAPE_HEADER_FILE_TYPE];
+                    /* copy execution address */
+                    TapeHeader[CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_LOW] = pData[CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_LOW];
+                    TapeHeader[CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_HIGH] = pData[CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_HIGH];
+                    /* copy data location */
+                    TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_LOW] = pData[CPC_TAPE_HEADER_DATA_LOCATION_LOW];
+                    TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_HIGH] = pData[CPC_TAPE_HEADER_DATA_LOCATION_HIGH];
+
+                    FileOffset += 128;
+                    FileLengthRemaining -= 128;
+
+                    /* override execution address? */
+                    if (ExecutionAddressOverride)
+                    {
+                        TapeHeader[CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_LOW] = ExecutionAddress & 0xFF;
+                        TapeHeader[CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_HIGH] = (ExecutionAddress >> 8) & 0xFF;
+                    }
+
+                    /* override type? */
+                    if (TypeOverride)
+                        TapeHeader[CPC_TAPE_HEADER_FILE_TYPE] = Type;
+
+                    /* override load address? */
+                    if (LoadAddressOverride)
+                    {
+                        TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_LOW] = LoadAddress & 0xFF;
+                        TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_HIGH] = (LoadAddress >> 8) & 0xFF;
+                    }
+
+                }
+                else
+                {
+                    /* set type */
+                    TapeHeader[CPC_TAPE_HEADER_FILE_TYPE] = Type;
+
+                    /* set execution address */
+                    TapeHeader[CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_LOW] = ExecutionAddress & 0xFF;
+                    TapeHeader[CPC_TAPE_HEADER_DATA_EXECUTION_ADDRESS_HIGH] = (ExecutionAddress >> 8) & 0xFF;
+
+                    /* set load address */
+                    TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_LOW] = LoadAddress & 0xFF;
+                    TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_HIGH] = (LoadAddress >> 8) & 0xFF;
+                }
+
+                if (pTapeFilename != NULL)
+                {
+                    int i;
+                    int nLength = strlen(pTapeFilename);
+                    if (nLength > 16)
+                        nLength = 16;
+                    for (i = 0; i < nLength; i++)
+                        TapeHeader[i] = toupper(pTapeFilename[i]);
+                }
+                TapeHeader[CPC_TAPE_HEADER_DATA_LOGICAL_LENGTH_LOW] = (FileLengthRemaining & 0x0ff);
+                TapeHeader[CPC_TAPE_HEADER_DATA_LOGICAL_LENGTH_HIGH] = (FileLengthRemaining >> 8) & 0x0ff;
+
+
+                BlockLocation = TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_LOW] |
+                                (TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_HIGH] << 8);
+
+                if (CPCMethod == CPC_METHOD_SPECTRUM)
+                {
+                    /* write data into block */
+                    WriteStandardSpeedDataBlock(pTZXFile, 0x0ff, &pData[FileOffset], FileLengthRemaining, 1000);
+                }
+                else
+                {
+                    do
+                    {
+                        unsigned char Flag;
+                        /*
+                                            CPC can't handle this one
+                                            if (CPCMethod == CPC_METHOD_2BLOCKS)
+                                            {
+                                                  if (FirstBlock)
+                                                  {
+                                                        TapeBlockSize=CPC_DATA_BLOCK_SIZE;
+                                                        LastBlock = FALSE;
+                                                  }
+                                                  else
+                                                  {
+                                                        TapeBlockSize = FileLengthRemaining;
+                                                        LastBlock = TRUE;
+                                                  }
+                                            }
+                                            else
+                        */
+                        if (CPCMethod == CPC_METHOD_BLOCKS)
+                        {
+                            /* calc size of tape data block */
+                            if (FileLengthRemaining > CPC_DATA_BLOCK_SIZE)
+                            {
+                                TapeBlockSize = CPC_DATA_BLOCK_SIZE;
+                                LastBlock = FALSE;
+                            }
+                            else
+                            {
+                                TapeBlockSize = FileLengthRemaining;
+                                LastBlock = TRUE;
+                            }
+                        }
+                        else if (CPCMethod == CPC_METHOD_HEADERLESS)
+                            TapeBlockSize = FileLengthRemaining;
+
+
+
+                        /**** HEADER ****/
+                        /* SETUP TAPE RELATED DATA */
+                        /* block index */
+                        TapeHeader[CPC_TAPE_HEADER_BLOCK_NUMBER] = BlockIndex;
+
+                        /* first block? */
+                        if (FirstBlock)
+                        {
+                            FirstBlock = FALSE;
+
+                            Flag = 0x0ff;
+                        }
+                        else
+                            Flag = 0;
+
+                        TapeHeader[CPC_TAPE_HEADER_FIRST_BLOCK_FLAG] = Flag;
+
+                        /* last block? */
+                        if (LastBlock)
+                            Flag = 0x0ff;
+                        else
+                            Flag = 0;
+
+                        TapeHeader[CPC_TAPE_HEADER_LAST_BLOCK_FLAG] = Flag;
+
+                        /* size of data following */
+                        TapeHeader[CPC_TAPE_HEADER_DATA_LENGTH_LOW] = (unsigned char)TapeBlockSize;
+                        TapeHeader[CPC_TAPE_HEADER_DATA_LENGTH_HIGH] = (unsigned char)(TapeBlockSize >> 8);
+
+                        /* location of block */
+                        TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_LOW] = (unsigned char)BlockLocation;
+                        TapeHeader[CPC_TAPE_HEADER_DATA_LOCATION_HIGH] = (unsigned char)(BlockLocation >> 8);
+
+                        /* don't write a header if headerless */
+                        if (CPCMethod != CPC_METHOD_HEADERLESS)
+                        {
+                            /* write header */
+                            CPC_WriteDataBlock(pTZXFile, 0x02c, TapeHeader, CPC_TAPE_HEADER_SIZE, 10);
+                        }
+
+                        /* write data into block */
+                        CPC_WriteDataBlock(pTZXFile, 0x016, &pData[FileOffset], TapeBlockSize, CPC_PAUSE_AFTER_BLOCK_IN_MS);
+
+                        BlockLocation += TapeBlockSize;
+                        BlockIndex++;
+                        FileOffset += TapeBlockSize;
+                        FileLengthRemaining -= TapeBlockSize;
+                    }
+                    while (FileLengthRemaining != 0);
+                }
+
+                free(pData);
+            }
+
+            /* write file */
+            if (BlankBeforeUse)
+                TZX_WriteFile(pTZXFile, pDestFilename);
+            else
+                TZX_AppendFile(pTZXFile, pDestFilename);
+
+            /* free it */
+            TZX_FreeFile(pTZXFile);
+        }
+        else
+        {
+            printf("Failed to open output file!\r\n");
+            exit(1);
+        }
+
+    }
+
+    exit(0);
+
+    return 0;
+}