Initial import of the open source release

12 files changed, 2423 insertions, 0 deletions

diff --git a/tools/2CDT/2cdt.cbp b/tools/2CDT/2cdt.cbp
new file mode 100644
index 0000000..41deaf1
--- /dev/null
+++ b/tools/2CDT/2cdt.cbp
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="4" />
+	<Project>
+		<Option title="2cdt" />
+		<Option makefile="makefile" />
+		<Option pch_mode="0" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="default">
+				<Option output="C:\2cdt\2cdt.exe" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Option parameters="-m 2 -r snake c:\blocks.bin c:\tester.cdt" />
+				<Option includeInTargetAll="1" />
+				<Option projectResourceIncludeDirsRelation="1" />
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-g" />
+		</Compiler>
+		<Unit filename="src\2cdt.c">
+			<Option compilerVar="CC" />
+			<Option target="default" />
+		</Unit>
+		<Unit filename="src\defs.h">
+			<Option compilerVar="CC" />
+			<Option compile="0" />
+			<Option link="0" />
+			<Option target="default" />
+		</Unit>
+		<Unit filename="src\tzxfile.c">
+			<Option compilerVar="CC" />
+			<Option target="default" />
+		</Unit>
+		<Unit filename="src\tzxfile.h">
+			<Option compilerVar="CC" />
+			<Option compile="0" />
+			<Option link="0" />
+			<Option target="default" />
+		</Unit>
+	</Project>
+</CodeBlocks_project_file>
\ No newline at end of file
diff --git a/tools/2CDT/2cdt.depend b/tools/2CDT/2cdt.depend
new file mode 100644
index 0000000..7427b7c
--- /dev/null
+++ b/tools/2CDT/2cdt.depend
@@ -0,0 +1,22 @@
+# depslib dependency file v1.0

+1137940710 source:d:\www\download\2cdt\2cdt\src\tzxfile.c

+	<stdio.h>

+	<stdlib.h>

+	<memory.h>

+	"tzxfile.h"

+

+991048958 d:\www\download\2cdt\2cdt\src\tzxfile.h

+	"defs.h"

+

+1014464942 d:\www\download\2cdt\2cdt\src\defs.h

+

+1280219172 source:d:\www\download\2cdt\2cdt\src\2cdt.c

+	<stdio.h>

+	<stdlib.h>

+	<string.h>

+	<sys/io.h>

+	<io.h>

+	"defs.h"

+	"tzxfile.h"

+	"getopt.h"

+

diff --git a/tools/2CDT/2cdt.layout b/tools/2CDT/2cdt.layout
new file mode 100644
index 0000000..b5fceb8
--- /dev/null
+++ b/tools/2CDT/2cdt.layout
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_layout_file>
+	<ActiveTarget name="All" />
+	<File name="src\2cdt.c" open="1" top="1" tabpos="1">
+		<Cursor position="26859" topLine="1012" />
+	</File>
+</CodeBlocks_layout_file>
diff --git a/tools/2CDT/COPYING b/tools/2CDT/COPYING
new file mode 100644
index 0000000..196760e
--- /dev/null
+++ b/tools/2CDT/COPYING
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE

+		       Version 2, June 1991

+

+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.

+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ Everyone is permitted to copy and distribute verbatim copies

+ of this license document, but changing it is not allowed.

+

+			    Preamble

+

+  The licenses for most software are designed to take away your

+freedom to share and change it.  By contrast, the GNU General Public

+License is intended to guarantee your freedom to share and change free

+software--to make sure the software is free for all its users.  This

+General Public License applies to most of the Free Software

+Foundation's software and to any other program whose authors commit to

+using it.  (Some other Free Software Foundation software is covered by

+the GNU Library General Public License instead.)  You can apply it to

+your programs, too.

+

+  When we speak of free software, we are referring to freedom, not

+price.  Our General Public Licenses are designed to make sure that you

+have the freedom to distribute copies of free software (and charge for

+this service if you wish), that you receive source code or can get it

+if you want it, that you can change the software or use pieces of it

+in new free programs; and that you know you can do these things.

+

+  To protect your rights, we need to make restrictions that forbid

+anyone to deny you these rights or to ask you to surrender the rights.

+These restrictions translate to certain responsibilities for you if you

+distribute copies of the software, or if you modify it.

+

+  For example, if you distribute copies of such a program, whether

+gratis or for a fee, you must give the recipients all the rights that

+you have.  You must make sure that they, too, receive or can get the

+source code.  And you must show them these terms so they know their

+rights.

+

+  We protect your rights with two steps: (1) copyright the software, and

+(2) offer you this license which gives you legal permission to copy,

+distribute and/or modify the software.

+

+  Also, for each author's protection and ours, we want to make certain

+that everyone understands that there is no warranty for this free

+software.  If the software is modified by someone else and passed on, we

+want its recipients to know that what they have is not the original, so

+that any problems introduced by others will not reflect on the original

+authors' reputations.

+

+  Finally, any free program is threatened constantly by software

+patents.  We wish to avoid the danger that redistributors of a free

+program will individually obtain patent licenses, in effect making the

+program proprietary.  To prevent this, we have made it clear that any

+patent must be licensed for everyone's free use or not licensed at all.

+

+  The precise terms and conditions for copying, distribution and

+modification follow.

+

+		    GNU GENERAL PUBLIC LICENSE

+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

+

+  0. This License applies to any program or other work which contains

+a notice placed by the copyright holder saying it may be distributed

+under the terms of this General Public License.  The "Program", below,

+refers to any such program or work, and a "work based on the Program"

+means either the Program or any derivative work under copyright law:

+that is to say, a work containing the Program or a portion of it,

+either verbatim or with modifications and/or translated into another

+language.  (Hereinafter, translation is included without limitation in

+the term "modification".)  Each licensee is addressed as "you".

+

+Activities other than copying, distribution and modification are not

+covered by this License; they are outside its scope.  The act of

+running the Program is not restricted, and the output from the Program

+is covered only if its contents constitute a work based on the

+Program (independent of having been made by running the Program).

+Whether that is true depends on what the Program does.

+

+  1. You may copy and distribute verbatim copies of the Program's

+source code as you receive it, in any medium, provided that you

+conspicuously and appropriately publish on each copy an appropriate

+copyright notice and disclaimer of warranty; keep intact all the

+notices that refer to this License and to the absence of any warranty;

+and give any other recipients of the Program a copy of this License

+along with the Program.

+

+You may charge a fee for the physical act of transferring a copy, and

+you may at your option offer warranty protection in exchange for a fee.

+

+  2. You may modify your copy or copies of the Program or any portion

+of it, thus forming a work based on the Program, and copy and

+distribute such modifications or work under the terms of Section 1

+above, provided that you also meet all of these conditions:

+

+    a) You must cause the modified files to carry prominent notices

+    stating that you changed the files and the date of any change.

+

+    b) You must cause any work that you distribute or publish, that in

+    whole or in part contains or is derived from the Program or any

+    part thereof, to be licensed as a whole at no charge to all third

+    parties under the terms of this License.

+

+    c) If the modified program normally reads commands interactively

+    when run, you must cause it, when started running for such

+    interactive use in the most ordinary way, to print or display an

+    announcement including an appropriate copyright notice and a

+    notice that there is no warranty (or else, saying that you provide

+    a warranty) and that users may redistribute the program under

+    these conditions, and telling the user how to view a copy of this

+    License.  (Exception: if the Program itself is interactive but

+    does not normally print such an announcement, your work based on

+    the Program is not required to print an announcement.)

+

+These requirements apply to the modified work as a whole.  If

+identifiable sections of that work are not derived from the Program,

+and can be reasonably considered independent and separate works in

+themselves, then this License, and its terms, do not apply to those

+sections when you distribute them as separate works.  But when you

+distribute the same sections as part of a whole which is a work based

+on the Program, the distribution of the whole must be on the terms of

+this License, whose permissions for other licensees extend to the

+entire whole, and thus to each and every part regardless of who wrote it.

+

+Thus, it is not the intent of this section to claim rights or contest

+your rights to work written entirely by you; rather, the intent is to

+exercise the right to control the distribution of derivative or

+collective works based on the Program.

+

+In addition, mere aggregation of another work not based on the Program

+with the Program (or with a work based on the Program) on a volume of

+a storage or distribution medium does not bring the other work under

+the scope of this License.

+

+  3. You may copy and distribute the Program (or a work based on it,

+under Section 2) in object code or executable form under the terms of

+Sections 1 and 2 above provided that you also do one of the following:

+

+    a) Accompany it with the complete corresponding machine-readable

+    source code, which must be distributed under the terms of Sections

+    1 and 2 above on a medium customarily used for software interchange; or,

+

+    b) Accompany it with a written offer, valid for at least three

+    years, to give any third party, for a charge no more than your

+    cost of physically performing source distribution, a complete

+    machine-readable copy of the corresponding source code, to be

+    distributed under the terms of Sections 1 and 2 above on a medium

+    customarily used for software interchange; or,

+

+    c) Accompany it with the information you received as to the offer

+    to distribute corresponding source code.  (This alternative is

+    allowed only for noncommercial distribution and only if you

+    received the program in object code or executable form with such

+    an offer, in accord with Subsection b above.)

+

+The source code for a work means the preferred form of the work for

+making modifications to it.  For an executable work, complete source

+code means all the source code for all modules it contains, plus any

+associated interface definition files, plus the scripts used to

+control compilation and installation of the executable.  However, as a

+special exception, the source code distributed need not include

+anything that is normally distributed (in either source or binary

+form) with the major components (compiler, kernel, and so on) of the

+operating system on which the executable runs, unless that component

+itself accompanies the executable.

+

+If distribution of executable or object code is made by offering

+access to copy from a designated place, then offering equivalent

+access to copy the source code from the same place counts as

+distribution of the source code, even though third parties are not

+compelled to copy the source along with the object code.

+

+  4. You may not copy, modify, sublicense, or distribute the Program

+except as expressly provided under this License.  Any attempt

+otherwise to copy, modify, sublicense or distribute the Program is

+void, and will automatically terminate your rights under this License.

+However, parties who have received copies, or rights, from you under

+this License will not have their licenses terminated so long as such

+parties remain in full compliance.

+

+  5. You are not required to accept this License, since you have not

+signed it.  However, nothing else grants you permission to modify or

+distribute the Program or its derivative works.  These actions are

+prohibited by law if you do not accept this License.  Therefore, by

+modifying or distributing the Program (or any work based on the

+Program), you indicate your acceptance of this License to do so, and

+all its terms and conditions for copying, distributing or modifying

+the Program or works based on it.

+

+  6. Each time you redistribute the Program (or any work based on the

+Program), the recipient automatically receives a license from the

+original licensor to copy, distribute or modify the Program subject to

+these terms and conditions.  You may not impose any further

+restrictions on the recipients' exercise of the rights granted herein.

+You are not responsible for enforcing compliance by third parties to

+this License.

+

+  7. If, as a consequence of a court judgment or allegation of patent

+infringement or for any other reason (not limited to patent issues),

+conditions are imposed on you (whether by court order, agreement or

+otherwise) that contradict the conditions of this License, they do not

+excuse you from the conditions of this License.  If you cannot

+distribute so as to satisfy simultaneously your obligations under this

+License and any other pertinent obligations, then as a consequence you

+may not distribute the Program at all.  For example, if a patent

+license would not permit royalty-free redistribution of the Program by

+all those who receive copies directly or indirectly through you, then

+the only way you could satisfy both it and this License would be to

+refrain entirely from distribution of the Program.

+

+If any portion of this section is held invalid or unenforceable under

+any particular circumstance, the balance of the section is intended to

+apply and the section as a whole is intended to apply in other

+circumstances.

+

+It is not the purpose of this section to induce you to infringe any

+patents or other property right claims or to contest validity of any

+such claims; this section has the sole purpose of protecting the

+integrity of the free software distribution system, which is

+implemented by public license practices.  Many people have made

+generous contributions to the wide range of software distributed

+through that system in reliance on consistent application of that

+system; it is up to the author/donor to decide if he or she is willing

+to distribute software through any other system and a licensee cannot

+impose that choice.

+

+This section is intended to make thoroughly clear what is believed to

+be a consequence of the rest of this License.

+

+  8. If the distribution and/or use of the Program is restricted in

+certain countries either by patents or by copyrighted interfaces, the

+original copyright holder who places the Program under this License

+may add an explicit geographical distribution limitation excluding

+those countries, so that distribution is permitted only in or among

+countries not thus excluded.  In such case, this License incorporates

+the limitation as if written in the body of this License.

+

+  9. The Free Software Foundation may publish revised and/or new versions

+of the General Public License from time to time.  Such new versions will

+be similar in spirit to the present version, but may differ in detail to

+address new problems or concerns.

+

+Each version is given a distinguishing version number.  If the Program

+specifies a version number of this License which applies to it and "any

+later version", you have the option of following the terms and conditions

+either of that version or of any later version published by the Free

+Software Foundation.  If the Program does not specify a version number of

+this License, you may choose any version ever published by the Free Software

+Foundation.

+

+  10. If you wish to incorporate parts of the Program into other free

+programs whose distribution conditions are different, write to the author

+to ask for permission.  For software which is copyrighted by the Free

+Software Foundation, write to the Free Software Foundation; we sometimes

+make exceptions for this.  Our decision will be guided by the two goals

+of preserving the free status of all derivatives of our free software and

+of promoting the sharing and reuse of software generally.

+

+			    NO WARRANTY

+

+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY

+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN

+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES

+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED

+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS

+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE

+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,

+REPAIR OR CORRECTION.

+

+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING

+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR

+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,

+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING

+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED

+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY

+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER

+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE

+POSSIBILITY OF SUCH DAMAGES.

+

+		     END OF TERMS AND CONDITIONS

+

+	    How to Apply These Terms to Your New Programs

+

+  If you develop a new program, and you want it to be of the greatest

+possible use to the public, the best way to achieve this is to make it

+free software which everyone can redistribute and change under these terms.

+

+  To do so, attach the following notices to the program.  It is safest

+to attach them to the start of each source file to most effectively

+convey the exclusion of warranty; and each file should have at least

+the "copyright" line and a pointer to where the full notice is found.

+

+    <one line to give the program's name and a brief idea of what it does.>

+    Copyright (C) 19yy  <name of author>

+

+    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

+

+

+Also add information on how to contact you by electronic and paper mail.

+

+If the program is interactive, make it output a short notice like this

+when it starts in an interactive mode:

+

+    Gnomovision version 69, Copyright (C) 19yy name of author

+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.

+    This is free software, and you are welcome to redistribute it

+    under certain conditions; type `show c' for details.

+

+The hypothetical commands `show w' and `show c' should show the appropriate

+parts of the General Public License.  Of course, the commands you use may

+be called something other than `show w' and `show c'; they could even be

+mouse-clicks or menu items--whatever suits your program.

+

+You should also get your employer (if you work as a programmer) or your

+school, if any, to sign a "copyright disclaimer" for the program, if

+necessary.  Here is a sample; alter the names:

+

+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program

+  `Gnomovision' (which makes passes at compilers) written by James Hacker.

+

+  <signature of Ty Coon>, 1 April 1989

+  Ty Coon, President of Vice

+

+This General Public License does not permit incorporating your program into

+proprietary programs.  If your program is a subroutine library, you may

+consider it more useful to permit linking proprietary applications with the

+library.  If this is what you want to do, use the GNU Library General

+Public License instead of this License.

diff --git a/tools/2CDT/Makefile b/tools/2CDT/Makefile
new file mode 100644
index 0000000..379c9c6
--- /dev/null
+++ b/tools/2CDT/Makefile
@@ -0,0 +1,24 @@
+# Makefile for 2cdt utility
+
+.PHONY: clean
+CC = gcc
+BIND = gcc
+RM = rm
+
+#   CFLAGS    flags for C compile
+#   LFLAGS1   flags after output file spec, before obj file list
+#   LFLAGS2   flags after obj file list (libraries, etc)
+
+CFLAGS = -O2 -O3 -DUNIX
+LFLAGS1 =
+LFLAGS2 = -s 
+
+CDT_O=	src/2cdt.o src/tzxfile.o
+
+2cdt:	$(CDT_O) 
+	$(BIND)  $(CDT_O) -o 2cdt $(LFLAGS1) $(LFLAGS2) $(LIBS)
+
+clean:
+	rm -rf src/*.o
+	rm -f 2cdt
+	rm -f 2cdt.exe
diff --git a/tools/2CDT/Makefile.win b/tools/2CDT/Makefile.win
new file mode 100644
index 0000000..39714b8
--- /dev/null
+++ b/tools/2CDT/Makefile.win
@@ -0,0 +1,33 @@
+# Project: 2cdt

+# Makefile created by Dev-C++ 4.9.9.2

+

+CPP  = g++.exe

+CC   = gcc.exe

+WINDRES = windres.exe

+RES  = 

+OBJ  = src/2cdt.o src/tzxfile.o $(RES)

+LINKOBJ  = src/2cdt.o src/tzxfile.o $(RES)

+LIBS =  -L"C:/Dev-Cpp/lib"  

+INCS =  -I"C:/Dev-Cpp/include" 

+CXXINCS =  -I"C:/Dev-Cpp/lib/gcc/mingw32/3.4.2/include"  -I"C:/Dev-Cpp/include/c++/3.4.2/backward"  -I"C:/Dev-Cpp/include/c++/3.4.2/mingw32"  -I"C:/Dev-Cpp/include/c++/3.4.2"  -I"C:/Dev-Cpp/include" 

+BIN  = 2cdt.exe

+CXXFLAGS = $(CXXINCS)  

+CFLAGS = $(INCS)  

+RM = rm -f

+

+.PHONY: all all-before all-after clean clean-custom

+

+all: all-before 2cdt.exe all-after

+

+

+clean: clean-custom

+	${RM} $(OBJ) $(BIN)

+

+$(BIN): $(OBJ)

+	$(CC) $(LINKOBJ) -o "2cdt.exe" $(LIBS)

+

+src/2cdt.o: src/2cdt.c

+	$(CC) -c src/2cdt.c -o src/2cdt.o $(CFLAGS)

+

+src/tzxfile.o: src/tzxfile.c

+	$(CC) -c src/tzxfile.c -o src/tzxfile.o $(CFLAGS)

diff --git a/tools/2CDT/file_id.diz b/tools/2CDT/file_id.diz
new file mode 100644
index 0000000..e1ff8f5
--- /dev/null
+++ b/tools/2CDT/file_id.diz
@@ -0,0 +1,16 @@
+2CDT

+Copyright (C) Kevin Thacker, 2000-2002

+

+23-February-2002

+

+2CDT is a tool to create a ".CDT"

+tape image from a file in the Amstrad

+operating system cassette format.

+It can be used to test support

+for ".TZX" in Amstrad emulators

+and a starting point for a Amstrad

+".CDT" tool.

+

+Source included.

+

+makefile included for UNIX
\ No newline at end of file
diff --git a/tools/2CDT/readme.txt b/tools/2CDT/readme.txt
new file mode 100644
index 0000000..b10fcc2
--- /dev/null
+++ b/tools/2CDT/readme.txt
@@ -0,0 +1,135 @@
+2CDT

+====

+

+(c) Kevin Thacker

+

+(Original code written in May 2000, fixed and released in May 2001)

+

+2CDT is a utility to transfer files into a ".CDT" Tape-Image.

+

+A ".CDT" is a tape-image file which describes the data stored on a cassette tape.

+ 

+This file format is very powerful and can describe fast and custom loaders as well

+as standard operating system formats.

+

+The ".CDT" file format is identical to the ".TZX" format. The extension is used

+to differentiate between Spectrum and Amstrad Tape-Images.

+

+The ".TZX" file format was originally designed to store Spectrum tape programs,

+it's format can be found from various sources, one of these is "World Of Spectrum":

+http://www.void.jump.org/

+

+There are a number of tools which already create .TZX files, Taper, Voc2TZX and MakeTZX.

+However, these are designed to recognise Spectrum tape loaders, and so do not do well

+at creating a tape-image for Amstrad formats.

+

+This tool has been designed as a starting point for furthur Amstrad CDT tools,

+and as a program to generate reference tape-images which can be used by emulator

+authors to support this tape-image format in their programs.

+

+This tool is designed to "inject" one or more file into a ".CDT" in the format written 

+by the Amstrad operating system. The tool allows the user to define the ".CDT" "recording" 

+method and baud rate.

+

+2CDT	[parameters]	<source file> <output CDT filename>

+

+parameters:

+	-n		

+			- Blank CDT file before use

+

+			Use this to create a new CDT, otherwise file

+			will be added to the end of an existing CDT.

+

+	-s <speed write>

+			- Write data with 'speed write' 0 or 1.

+

+			This is the same as typing "SPEED WRITE 0" or "SPEED WRITE 1"

+			in BASIC. Speed Write '0' is 1000 baud. Speed write '1' is

+			2000 baud.

+

+	-b <baud rate>  

+			- Specify Baud Rate.

+			

+			Allows you to specify faster or slower loading.

+			

+	-t <method>	

+			- Method to write data into TZX (for Amstrad blocks)

+			0 = Pure Data Block

+			1 = Turbo Loading Data Block (default)

+

+	-m <method>

+			- Method to write CPC data 

+			0 = blocks (default)

+			1 = headerless (Firmware function CAS READ for reading, CAS WRITE for writing )

+				To be loaded with firmware function CAS READ.

+				Not readable from BASIC. Allows entire program

+				to be stored as a single continuous block.

+			2 = Spectrum ROM loader

+

+	-r <tape filename>

+			- Give the tape file a name. Up to 16 characters.

+

+			 This allows you to give the file on tape a different

+			name to the name given on your local filesystem.

+

+			If no name is defined, the file will be unnamed.

+			This option applies to CPC 'blocks' methods only.

+

+	-X <address>

+			Define execution address (where file doesn't have header), or 

+			override execution address (where file has a header)

+			

+	-L <address>

+			Define load address (where file doesn't have header), or 

+			override load address (where file has a header)

+

+	-T <address>

+			Define type (where file doesn't have header), or 

+			override type address (where file has a header)

+			0 = BASIC, 2 = BINARY

+			

+	-p <number>

+			Set initial pause (default 3000ms)

+	

+	-P

+			Add a small initial pause block for buggy emulators (e.g. old versions of Arnold)

+			Not recommended. Please use newer version of this emulator.

+								

+Examples:

+

+The following in a bacth file will create the master tape for 'Stranded':

+

+REM create new CDT and put binary loader

+2cdt -n -r stranded strandlod.bin stranded.cdt

+REM add screen to existing CDT data

+2cdt -r screen loading.bin stranded.cdt

+REM add code to existing CDT data

+2cdt -r code stranded.bin stranded.cdt

+

+If you wanted to create a master tape for a game called 'Columns':

+

+REM create new CDT and put binary loader

+2cdt -n -r loader colload.bin columns.cdt

+REM put binary file as headerless

+2cdt -m 1 colcode.bin columns.cdt

+

+

+

+This archive contains a Windows command-line executable that will run under Win95, Win98,

+Win2000 and WinNT.

+

+License:

+

+   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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
\ No newline at end of file
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;
+}
diff --git a/tools/2CDT/src/defs.h b/tools/2CDT/src/defs.h
new file mode 100644
index 0000000..f042dde
--- /dev/null
+++ b/tools/2CDT/src/defs.h
@@ -0,0 +1,36 @@
+/* 
+ *  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.
+ */
+#ifndef __DEFS_HEADER_INCLUDED__
+#define __DEFS_HEADER_INCLUDED__
+
+
+typedef int BOOL;
+
+#ifndef TRUE
+#define TRUE (1==1)
+#endif
+
+#ifndef FALSE
+#define FALSE (1==0)
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#endif
diff --git a/tools/2CDT/src/tzxfile.c b/tools/2CDT/src/tzxfile.c
new file mode 100644
index 0000000..3f550b0
--- /dev/null
+++ b/tools/2CDT/src/tzxfile.c
@@ -0,0 +1,445 @@
+/*

+ *  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.

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <memory.h>

+/* TZX file support */

+#include "tzxfile.h"

+/* header for TZX file */

+const unsigned char *TZX_FileHeader = (const unsigned char *)"ZXTape!\x1a";

+

+/* the internal format for the TZX is a link-list system.

+Blocks can be edited. A new file can be written with the new data */

+

+

+

+/**************************************/

+/* insert block after block specified */

+void	TZX_InsertBlockAfter(TZX_FILE *pFile,TZX_BLOCK *pBlock, TZX_BLOCK *pPrev)

+{

+	/* setup block pointers */

+	pBlock->pPrev = pPrev;

+	pBlock->pNext = pPrev->pNext;

+

+	/* setup pointers for block before */

+	pPrev->pNext = pBlock;

+}

+

+/***************************************/

+/* insert block before block specified */

+void	TZX_InsertBlockBefore(TZX_FILE *pFile, TZX_BLOCK *pBlock, TZX_BLOCK *pNext)

+{

+	/* setup block pointers */

+	pBlock->pNext = pNext;

+	pBlock->pPrev = pNext->pPrev;

+

+	/* setup pointers for block before */

+	pNext->pPrev = pBlock;

+

+	/* is block we are inserting after the first in the list? */

+	if (pFile->pFirstBlock == pNext)

+	{

+		/* yes. New block is now the start of the list */

+		pFile->pFirstBlock = pBlock;

+	}

+}

+

+

+/*****************************************/

+/* insert a block at the end of the file */

+void	TZX_AddBlockToEndOfFile(TZX_FILE *pFile, TZX_BLOCK *pBlock)

+{

+	/* blocks in file? */

+	if (pFile->pFirstBlock==NULL)

+	{

+		/* no */

+		pFile->pFirstBlock = pBlock;

+	}

+	else

+	{

+		/* yes */

+		TZX_BLOCK *pCurrentBlock;

+

+		/* search for last block in list */

+		pCurrentBlock = pFile->pFirstBlock;

+

+		while (pCurrentBlock->pNext!=NULL)

+			pCurrentBlock = pCurrentBlock->pNext;

+

+		TZX_InsertBlockAfter(pFile,pBlock, pCurrentBlock);

+	}

+}

+

+/********************************/

+/* detach block from block list */

+void	TZX_DetachBlock(TZX_FILE *pFile,TZX_BLOCK *pBlock)

+{

+	/* block before this block? */

+	if (pBlock->pPrev!=NULL)

+	{

+		/* yes */

+		pBlock->pPrev->pNext = pBlock->pNext;

+	}

+	else

+	{

+		/* no, this block is first in list */

+		pFile->pFirstBlock = pBlock->pNext;

+	}

+

+	/* block after this block? */

+	if (pBlock->pNext!=NULL)

+	{

+		/* yes */

+		pBlock->pNext->pPrev = pBlock->pPrev;

+	}

+}

+

+/************************/

+/* free data in a block */

+void	TZX_FreeBlock(TZX_BLOCK *pBlock)

+{

+	/* free it */

+	free(pBlock);

+}

+

+

+

+/******************************/

+/* create a internal TZX file */

+

+TZX_FILE *TZX_CreateFile(unsigned char VersionMajor, unsigned char VersionMinor)

+{

+	TZX_FILE *pTZXFile;

+

+	/* alloc the header */

+	pTZXFile = malloc(sizeof(TZX_FILE));

+

+	if (pTZXFile!=NULL)

+	{

+		/* set version */

+		pTZXFile->VersionMajor = VersionMajor;

+		pTZXFile->VersionMinor = VersionMinor;

+

+		/* initialise block linked list */

+		pTZXFile->pFirstBlock = NULL;

+	}

+

+	return pTZXFile;

+}

+

+/*******************/

+/* free a TZX file */

+

+void	TZX_FreeFile(TZX_FILE *pFile)

+{

+	TZX_BLOCK *pBlock;

+

+	pBlock = pFile->pFirstBlock;

+

+	while (pBlock!=NULL)

+	{

+		TZX_BLOCK *pNextBlock = pBlock->pNext;

+

+		/* remove block from list */

+		TZX_DetachBlock(pFile, pBlock);

+

+		/* free TZX block */

+		TZX_FreeBlock(pBlock);

+

+		pBlock = pNextBlock;

+	}

+

+	/* free TZX file header */

+	free(pFile);

+}

+

+/*****************************************************************************************************/

+/* write a TZX file */

+

+void TZX_WriteBlocks(TZX_FILE *pTZXFile, FILE *fh)

+{

+    TZX_BLOCK *pBlock;

+

+    /* get pointer to first block */

+    pBlock = pTZXFile->pFirstBlock;

+

+    /* write each block in turn to file */

+    while (pBlock!=NULL)

+    {

+        if (pBlock->pBlockHeader!=NULL)

+        {

+            BOOL BlockHasData;

+            int BlockHeaderSize;

+            unsigned char BlockID;

+

+            /* get block ID */

+            BlockID = pBlock->pBlockHeader[0];

+            /* get size of header */

+            BlockHeaderSize = TZX_GetBlockHeaderSize(BlockID);

+            /* does block have additional data ? */

+            BlockHasData = TZX_BlockHasData(BlockID);

+

+            if ((!BlockHasData) || ((BlockHasData) && (pBlock->pBlockData!=NULL)))

+            {

+                /* block requires data and has data, or block doesn't require data */

+

+                /* write the header */

+                fwrite(pBlock->pBlockHeader, BlockHeaderSize, sizeof(unsigned char), fh);

+

+                if (pBlock->pBlockData!=NULL)

+                {

+                    /* write the data */

+

+                    fwrite(pBlock->pBlockData, pBlock->DataBlockSize, sizeof(unsigned char), fh);

+                }

+            }

+        }

+

+        /* next block */

+        pBlock = pBlock->pNext;

+    }

+}

+

+

+void	TZX_AppendFile(TZX_FILE *pTZXFile, unsigned char *pFilename)

+{

+	FILE *fh;

+

+	/* open TZX file */

+	fh = fopen((const char *)pFilename,"r+b");

+

+	if (fh!=NULL)

+	{

+		TZX_BLOCK *pBlock;

+

+        fseek(fh, 0, SEEK_END);

+

+        TZX_WriteBlocks(pTZXFile, fh);

+

+		/* close TZX file */

+		fclose(fh);

+	}

+}

+

+

+void	TZX_WriteFile(TZX_FILE *pTZXFile, unsigned char *pFilename)

+{

+	FILE *fh;

+

+	/* open TZX file */

+	fh = fopen((const char *)pFilename,"wb");

+

+	if (fh!=NULL)

+	{

+		TZX_BLOCK *pBlock;

+

+		/* write header */

+		fwrite(TZX_FileHeader, 8, sizeof(unsigned char), fh);

+		/* write version numbers */

+		fwrite(&pTZXFile->VersionMajor, 1, sizeof(unsigned char), fh);

+		fwrite(&pTZXFile->VersionMinor, 1, sizeof(unsigned char), fh);

+

+        TZX_WriteBlocks(pTZXFile, fh);

+

+		/* close TZX file */

+		fclose(fh);

+	}

+}

+

+void	TZX_SetupPauseBlock(TZX_BLOCK *pBlock,unsigned long PauseInMilliseconds)

+{

+	unsigned char *pHeader = TZX_GetBlockHeaderPtr(pBlock);

+

+	if (pHeader!=NULL)

+	{

+		if (pHeader[0] == TZX_PAUSE_BLOCK)

+		{

+			pHeader[1] = (unsigned char)PauseInMilliseconds;

+			pHeader[2] = (unsigned char)(PauseInMilliseconds>>8);

+		}

+	}

+}

+

+/*****************************************************************************************************/

+

+/* given a TZX block ID, this returns the size of the header */

+int	TZX_GetBlockHeaderSize(unsigned char ID)

+{

+	switch (ID)

+	{

+		case TZX_STANDARD_SPEED_DATA_BLOCK:

+			return 4+1;

+		case TZX_TURBO_LOADING_DATA_BLOCK:

+			return 18+1;

+

+		case TZX_PAUSE_BLOCK:

+			return 2+1;

+		case TZX_PURE_DATA_BLOCK:

+			return 0x0a + 1;

+		case TZX_DIRECT_RECORDING_BLOCK:

+			return 0x08 + 1;

+

+		default:

+			break;

+	}

+

+	return 0;

+}

+

+/*****************************************************************************************************/

+/* return TRUE if the block has additional data, false if not */

+BOOL TZX_BlockHasData(unsigned char ID)

+{

+	switch (ID)

+	{

+		case TZX_STANDARD_SPEED_DATA_BLOCK:

+		case TZX_TURBO_LOADING_DATA_BLOCK:

+		case TZX_PURE_DATA_BLOCK:

+		case TZX_DIRECT_RECORDING_BLOCK:

+			return TRUE;

+

+		case TZX_PAUSE_BLOCK:

+			return FALSE;

+

+		default:

+			break;

+	}

+

+	return FALSE;

+

+}

+

+/*****************************************************************************************************/

+/* set block size */

+void	TZX_SetBlockSizeInHeader(TZX_BLOCK *pBlock, unsigned long Size)

+{

+	unsigned char ID = pBlock->pBlockHeader[0];

+	unsigned char *pBlockData;

+

+	pBlockData = &pBlock->pBlockHeader[1];

+

+	switch (ID)

+	{

+		case TZX_STANDARD_SPEED_DATA_BLOCK:

+		{

+			pBlockData[2] = (unsigned char)Size;

+			pBlockData[3] = (unsigned char)(Size>>8);

+

+		}

+		break;

+

+		case TZX_TURBO_LOADING_DATA_BLOCK:

+		{

+			pBlockData[0x0f] = (unsigned char)Size;

+			pBlockData[0x010] = (unsigned char)(Size>>8);

+			pBlockData[0x011] = (unsigned char)(Size>>16);

+

+		}

+		break;

+

+		case TZX_PURE_DATA_BLOCK:

+		{

+			pBlockData[0x07] = (unsigned char)Size;

+			pBlockData[0x08] = (unsigned char)(Size>>8);

+			pBlockData[0x09] = (unsigned char)(Size>>16);

+		}

+		break;

+

+		case TZX_DIRECT_RECORDING_BLOCK:

+		{

+			pBlockData[0x05] = (unsigned char)Size;

+			pBlockData[0x06] = (unsigned char)(Size>>8);

+			pBlockData[0x07] = (unsigned char)(Size>>16);

+		}

+		break;

+

+		default:

+			break;

+	}

+}

+

+

+/*****************************************************************************************************/

+/* create a block of the specified ID in the TZX image file */

+TZX_BLOCK *TZX_CreateBlock(unsigned char ID)

+{

+	TZX_BLOCK *pBlock;

+

+	pBlock = malloc(sizeof(TZX_BLOCK));

+

+	if (pBlock!=NULL)

+	{

+		int BlockHeaderSize;

+

+		/* reset block data */

+		memset(pBlock, 0, sizeof(TZX_BLOCK));

+

+		BlockHeaderSize = TZX_GetBlockHeaderSize(ID);

+

+		pBlock->pBlockHeader = malloc(BlockHeaderSize);

+

+		if (pBlock->pBlockHeader!=NULL)

+		{

+			pBlock->pBlockHeader[0] = ID;

+		}

+	}

+

+	return pBlock;

+}

+

+/*****************************************************************************************************/

+/* create a block of the specified ID in the TZX image file */

+void	TZX_AddDataToBlock(TZX_BLOCK *pBlock, int DataSize)

+{

+	/* only add data if a header exists */

+	if (pBlock->pBlockHeader!=NULL)

+	{

+		/* get block id */

+		unsigned char BlockID = pBlock->pBlockHeader[0];

+

+		/* does this block ID have additional data? */

+		if (TZX_BlockHasData(BlockID))

+		{

+			/* allocate memory for the additional data */

+			pBlock->pBlockData = malloc(DataSize);

+

+			if (pBlock->pBlockData!=NULL)

+			{

+				pBlock->DataBlockSize = DataSize;

+

+				/* set size in TZX header */

+				TZX_SetBlockSizeInHeader(pBlock, DataSize);

+			}

+		}

+	}

+}

+

+/*****************************************************************************************************/

+/* get pointer to TZX data block */

+unsigned char *TZX_GetBlockDataPtr(TZX_BLOCK *pBlock)

+{

+	return pBlock->pBlockData;

+}

+

+/*****************************************************************************************************/

+/* get pointer to TZX data block */

+unsigned char *TZX_GetBlockHeaderPtr(TZX_BLOCK *pBlock)

+{

+	return pBlock->pBlockHeader;

+}

diff --git a/tools/2CDT/src/tzxfile.h b/tools/2CDT/src/tzxfile.h
new file mode 100644
index 0000000..397f5d1
--- /dev/null
+++ b/tools/2CDT/src/tzxfile.h
@@ -0,0 +1,79 @@
+/* 

+ *  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.

+ */

+

+#ifndef __TZX_FILE_HEADER__

+#define __TZX_FILE_HEADER__

+

+#include "defs.h"

+

+#define TZX_VERSION_MAJOR	1

+#define TZX_VERSION_MINOR	10

+

+#define TZX_STANDARD_SPEED_DATA_BLOCK	0x010

+#define TZX_TURBO_LOADING_DATA_BLOCK	0x011

+#define TZX_PAUSE_BLOCK					0x020

+#define TZX_PURE_DATA_BLOCK				0x014

+#define TZX_DIRECT_RECORDING_BLOCK		0x015

+

+#define TZX_T_STATES 3500000

+

+

+#define TZX_HARDWARE_COMPUTER_CPC464	    0x015 /* Amstrad CPC 464 */

+#define TZX_HARDWARE_COMPUTER_CPC664		0x016 /* Amstrad CPC 664 */

+#define TZX_HARDWARE_COMPUTER_CPC6128		0x017 /* Amstrad CPC 6128 */

+#define TZX_HARDWARE_COMPUTER_CPC464PLUS	0x018 /* Amstrad CPC 464+ */

+#define TZX_HARDWARE_COMPUTER_CPC6128PLUS	0x019 /* Amstrad CPC 6128+ */

+

+typedef struct TZX_BLOCK

+{

+	/* previous TZX block */

+	struct TZX_BLOCK *pPrev;

+	/* next TZX block */

+	struct TZX_BLOCK *pNext;

+	/* pointer to header data allocated for this block */

+	unsigned char *pBlockHeader;

+	/* size of data block */

+	unsigned long DataBlockSize;

+	/* pointer to data added to this block */

+	unsigned char *pBlockData;

+} TZX_BLOCK;

+

+typedef struct TZX_FILE

+{

+	/* version of TZX file */

+	unsigned char VersionMajor;

+	unsigned char VersionMinor;

+	/* pointer to first block */

+	TZX_BLOCK *pFirstBlock;

+} TZX_FILE;

+

+void	TZX_WriteFile(TZX_FILE *pTZXFile, unsigned char *pFilename);

+unsigned char *TZX_GetBlockDataPtr(TZX_BLOCK *);

+unsigned char *TZX_GetBlockHeaderPtr(TZX_BLOCK *);

+

+TZX_FILE *TZX_CreateFile(unsigned char VersionMajor, unsigned char VersionMinor);

+void	TZX_FreeFile(TZX_FILE *pFile);

+void	TZX_AddDataToBlock(TZX_BLOCK *pBlock, int DataSize);

+unsigned char *TZX_GetDataBlockPtr(TZX_BLOCK *pBlock);

+void	TZX_AddBlockToEndOfFile(TZX_FILE *pFile, TZX_BLOCK *pBlock);

+int	TZX_GetBlockHeaderSize(unsigned char ID);

+BOOL TZX_BlockHasData(unsigned char ID);

+TZX_BLOCK *TZX_CreateBlock(unsigned char ID);

+void	TZX_SetupPauseBlock(TZX_BLOCK *pBlock,unsigned long PauseInMilliseconds);

+#endif

+