├── ipf
    ├── ipf.ico
    ├── update.png
    ├── App.xaml
    ├── BufferWindow.xaml
    ├── App.xaml.cs
    ├── Properties
    │   ├── Settings.settings
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   ├── Settings.Designer.cs
    │   └── Resources.resx
    ├── App.config
    ├── Floppy.cs
    ├── ipf.dox
    ├── MainWindow.xaml
    ├── BufferWindow.xaml.cs
    ├── utilities.cs
    ├── ipf.csproj
    ├── MainWindow.xaml.cs
    ├── IPFStruct.cs
    └── IPFWriter.cs
├── pasti
    ├── PastiStruct.cs
    ├── App.config
    ├── Properties
    │   ├── Settings.settings
    │   ├── Settings.Designer.cs
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   └── Resources.resx
    ├── App.xaml
    ├── App.xaml.cs
    ├── BufferWindow.xaml
    ├── pasti.dox
    ├── MainWindow.xaml
    ├── FloppyStruct.cs
    ├── BufferWindow.xaml.cs
    ├── pasti.csproj
    ├── MainWindow.xaml.cs
    ├── PastiRead.cs
    └── PastiWrite.cs
├── kfstream
    ├── App.config
    ├── Properties
    │   ├── Settings.settings
    │   ├── Settings.Designer.cs
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   └── Resources.resx
    ├── App.xaml
    ├── App.xaml.cs
    ├── content.xaml
    ├── content.xaml.cs
    ├── MainWindow.xaml
    ├── KFStream.csproj
    ├── KFWriter.cs
    ├── MainWindow.xaml.cs
    └── ProcessStream.cs
├── README.md
├── AIR.sln
├── .gitattributes
└── .gitignore


/ipf/ipf.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DrCoolzic/AIR/HEAD/ipf/ipf.ico


--------------------------------------------------------------------------------
/ipf/update.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DrCoolzic/AIR/HEAD/ipf/update.png


--------------------------------------------------------------------------------
/pasti/PastiStruct.cs:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DrCoolzic/AIR/HEAD/pasti/PastiStruct.cs


--------------------------------------------------------------------------------
/kfstream/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8" ?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
5 |     </startup>
6 | </configuration>


--------------------------------------------------------------------------------
/pasti/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8" ?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
5 |     </startup>
6 | </configuration>


--------------------------------------------------------------------------------
/kfstream/Properties/Settings.settings:
--------------------------------------------------------------------------------
1 | <?xml version='1.0' encoding='utf-8'?>
2 | <SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
3 |   <Profiles>
4 |     <Profile Name="(Default)" />
5 |   </Profiles>
6 |   <Settings />
7 | </SettingsFile>


--------------------------------------------------------------------------------
/pasti/Properties/Settings.settings:
--------------------------------------------------------------------------------
1 | <?xml version='1.0' encoding='utf-8'?>
2 | <SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
3 |   <Profiles>
4 |     <Profile Name="(Default)" />
5 |   </Profiles>
6 |   <Settings />
7 | </SettingsFile>


--------------------------------------------------------------------------------
/pasti/App.xaml:
--------------------------------------------------------------------------------
1 | <Application x:Class="Pasti.App"
2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4 |              StartupUri="MainWindow.xaml">
5 |     <Application.Resources>
6 |          
7 |     </Application.Resources>
8 | </Application>
9 | 


--------------------------------------------------------------------------------
/kfstream/App.xaml:
--------------------------------------------------------------------------------
1 | <Application x:Class="KFStream.App"
2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4 |              StartupUri="MainWindow.xaml">
5 |     <Application.Resources>
6 |          
7 |     </Application.Resources>
8 | </Application>
9 | 


--------------------------------------------------------------------------------
/ipf/App.xaml:
--------------------------------------------------------------------------------
1 | <Application x:Class="ipf.App"
2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4 |              StartupUri="MainWindow.xaml" Exit="Application_Exit">
5 |     <Application.Resources>
6 |          
7 |     </Application.Resources>
8 | </Application>
9 | 


--------------------------------------------------------------------------------
/pasti/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Configuration;
 4 | using System.Data;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using System.Windows;
 8 | 
 9 | namespace Pasti {
10 | 	/// <summary>
11 | 	/// Interaction logic for App.xaml
12 | 	/// </summary>
13 | 	public partial class App : Application {
14 | 	}
15 | }
16 | 


--------------------------------------------------------------------------------
/kfstream/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Configuration;
 4 | using System.Data;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using System.Windows;
 8 | 
 9 | namespace KFStream {
10 | 	/// <summary>
11 | 	/// Interaction logic for App.xaml
12 | 	/// </summary>
13 | 	public partial class App : Application {
14 | 	}
15 | }
16 | 


--------------------------------------------------------------------------------
/ipf/BufferWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="ipf.BufferWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         Title="Buffer Content" Height="400" Width="850">
 5 |     <Grid>
 6 |         <ScrollViewer VerticalScrollBarVisibility="Auto" >
 7 |             <TextBox Name="displayBuffer" Background="Transparent" />
 8 |         </ScrollViewer>
 9 | 
10 |     </Grid>
11 | </Window>
12 | 


--------------------------------------------------------------------------------
/kfstream/content.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="KFStream.ContentWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         Title="Transitions Display" Height="400" Width="850">
 5 |     <Grid>
 6 |         <ScrollViewer VerticalScrollBarVisibility="Auto" >
 7 |             <TextBox Name="displayBuffer" Background="Transparent" />
 8 |         </ScrollViewer>
 9 |     </Grid>
10 | </Window>
11 | 


--------------------------------------------------------------------------------
/pasti/BufferWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="Pasti.BufferWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         Title="Buffer Content" Height="400" Width="850">
 5 |     <Grid>
 6 |         <ScrollViewer VerticalScrollBarVisibility="Auto" >
 7 |             <TextBox Name="displayBuffer" Background="Transparent" />
 8 |         </ScrollViewer>
 9 | 
10 |     </Grid>
11 | </Window>
12 | 
13 | 


--------------------------------------------------------------------------------
/ipf/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Configuration;
 4 | using System.Data;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using System.Windows;
 8 | 
 9 | namespace ipf {
10 | 	/// <summary>
11 | 	/// Interaction logic for App.xaml
12 | 	/// </summary>
13 | 	public partial class App : Application {
14 | 		// used to save size and position
15 | 		private void Application_Exit(object sender, ExitEventArgs e) {
16 | 			ipf.Properties.Settings.Default.Save();
17 | 		}
18 | 
19 | 	}
20 | 
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/ipf/Properties/Settings.settings:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='utf-8'?>
 2 | <SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)" GeneratedClassNamespace="ipf.Properties" GeneratedClassName="Settings">
 3 |   <Profiles />
 4 |   <Settings>
 5 |     <Setting Name="Top" Type="System.Double" Scope="User">
 6 |       <Value Profile="(Default)">0</Value>
 7 |     </Setting>
 8 |     <Setting Name="Left" Type="System.Double" Scope="User">
 9 |       <Value Profile="(Default)">0</Value>
10 |     </Setting>
11 |     <Setting Name="Height" Type="System.Double" Scope="User">
12 |       <Value Profile="(Default)">600</Value>
13 |     </Setting>
14 |     <Setting Name="Width" Type="System.Double" Scope="User">
15 |       <Value Profile="(Default)">900</Value>
16 |     </Setting>
17 |     <Setting Name="DataElemChecked" Type="System.Boolean" Scope="User">
18 |       <Value Profile="(Default)">True</Value>
19 |     </Setting>
20 |   </Settings>
21 | </SettingsFile>


--------------------------------------------------------------------------------
/pasti/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.34014
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace pasti.Properties {
12 | 
13 | 
14 | 	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
15 | 	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
16 | 	internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
17 | 
18 | 		private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
19 | 
20 | 		public static Settings Default {
21 | 			get {
22 | 				return defaultInstance;
23 | 			}
24 | 		}
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/kfstream/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.34209
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace KFStream.Properties {
12 | 
13 | 
14 | 	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
15 | 	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
16 | 	internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
17 | 
18 | 		private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
19 | 
20 | 		public static Settings Default {
21 | 			get {
22 | 				return defaultInstance;
23 | 			}
24 | 		}
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/ipf/App.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8" ?>
 2 | <configuration>
 3 |     <configSections>
 4 |         <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
 5 |             <section name="ipf.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
 6 |         </sectionGroup>
 7 |     </configSections>
 8 |     <startup> 
 9 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
10 |     </startup>
11 |     <userSettings>
12 |         <ipf.Properties.Settings>
13 |             <setting name="Top" serializeAs="String">
14 |                 <value>0</value>
15 |             </setting>
16 |             <setting name="Left" serializeAs="String">
17 |                 <value>0</value>
18 |             </setting>
19 |             <setting name="Height" serializeAs="String">
20 |                 <value>600</value>
21 |             </setting>
22 |             <setting name="Width" serializeAs="String">
23 |                 <value>900</value>
24 |             </setting>
25 |             <setting name="DataElemChecked" serializeAs="String">
26 |                 <value>True</value>
27 |             </setting>
28 |         </ipf.Properties.Settings>
29 |     </userSettings>
30 | </configuration>


--------------------------------------------------------------------------------
/ipf/Floppy.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | using System.Threading.Tasks;
 6 | 
 7 | namespace ipf {
 8 | 
 9 | 	/// <summary>
10 | 	/// Store the content of a gap element including the gap value
11 | 	/// </summary>
12 | 	public class GapElement {
13 | 		public uint gapBytes;
14 | 		public byte value;
15 | 		public GapType type;
16 | 	}
17 | 
18 | 	/// <summary>
19 | 	/// Store the content of a data element. The sample is a list
20 | 	/// </summary>
21 | 	public class DataElem {
22 | 		public uint dataBytes;
23 | 		public List<byte> value;
24 | 		public DataType type;
25 | 	}
26 | 
27 | 	/// <summary>
28 | 	/// Store the sector/bloc information
29 | 	/// </summary>
30 | 	public class Sector {
31 | 		public uint dataBits;
32 | 		public uint gapBits;
33 | 		public List<GapElement> gapElems = new List<GapElement>();
34 | 		public List<DataElem> dataElems = new List<DataElem>();
35 | 		public BlockFlags flags = BlockFlags.None;
36 | 	}
37 | 
38 | 	/// <summary>
39 | 	/// Store information about one track
40 | 	/// </summary>
41 | 	public class Track {
42 | 		public uint trackBytes;
43 | 		public uint dataBits;
44 | 		public uint gapBits;
45 | 		public Density density;
46 | 		public uint startBitPos;
47 | 		public uint blockCount;
48 | 		public TrackFlags trackFlags;
49 | 		public List<Sector> sectors = new List<Sector>();
50 | 	}
51 | 
52 | 	/// <summary>
53 | 	/// Store information about all tracks of a FD
54 | 	/// </summary>
55 | 	/// <remarks>We also store the info record to be able to rewrite the same info record</remarks>
56 | 	public class Floppy {
57 | 		public Track[,] tracks;
58 | 		public InfoRecord info;
59 | 	}
60 | }
61 | 


--------------------------------------------------------------------------------
/ipf/ipf.dox:
--------------------------------------------------------------------------------
 1 | /*! @mainpage IPF File Reader /Writer
 2 | 
 3 | <div class="jlg">Copyright (C) 2014 Jean Louis-Guerin\n\n
 4 | This file is part of the Atari Image Reader (AIR) project.\n
 5 | The Atari Image Reader project may be used and distributed without restriction provided
 6 | that this copyright statement is not removed from the file and that any
 7 | derivative work contains the original copyright notice and the associated
 8 | disclaimer.\n
 9 | The Atari Image Reader project is free software; you can redistribute it
10 | and/or modify  it under the terms of the GNU General Public License
11 | as published by the Free Software Foundation; either version 2
12 | of the License, or (at your option) any later version.\n
13 | The Atari Image Reader project is distributed in the hope that it will be useful,
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 | See the GNU General Public License for more details.\n\n
17 | You should have received a copy of the GNU General Public License
18 | along with the Atari Universal FD Image Tool project; if not, write to the Free Software
19 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n</div>
20 | 
21 | @section _intro Introduction
22 | The IPF Reader / Writer is a simple program that reads and writes an IPF file.
23 | It displays in the main window the structure of the IPF file
24 | The main goal of this program is to provide an example of how to read / write an IPF File
25 | 
26 | @section progdes Program Description
27 | TODO
28 | 
29 | @section proguse Program Usage
30 | Usage should be obvious ...
31 | 
32 | @author	Jean Louis-Guerin
33 | 
34 | */
35 | 
36 | 
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/pasti/pasti.dox:
--------------------------------------------------------------------------------
 1 | /*! @mainpage Pasti Reader
 2 | 
 3 | <div class="jlg">Copyright (C) 2014 Jean Louis-Guerin\n\n
 4 | This file is part of the Atari Image Reader (AIR) project.\n
 5 | The Atari Image Reader project may be used and distributed without restriction provided
 6 | that this copyright statement is not removed from the file and that any
 7 | derivative work contains the original copyright notice and the associated
 8 | disclaimer.\n
 9 | The Atari Image Reader project is free software; you can redistribute it
10 | and/or modify  it under the terms of the GNU General Public License
11 | as published by the Free Software Foundation; either version 2
12 | of the License, or (at your option) any later version.\n
13 | The Atari Image Reader project is distributed in the hope that it will be useful,
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 | See the GNU General Public License for more details.\n\n
17 | You should have received a copy of the GNU General Public License
18 | along with the Atari Universal FD Image Tool project; if not, write to the Free Software
19 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n</div>
20 | 
21 | @section _intro Introduction
22 | The Pasti Reader is a simple program that reads a Pasti file.
23 | It displays in a window the structure of the PastiFile
24 | The main goal of this program is to provide an example of how to read a Pasti File
25 | 
26 | @section progdes Program Description
27 | TODO
28 | 
29 | @section proguse Program Usage
30 | This is a Windows Presentation Foundation (WPF) program. 
31 | TODO
32 | 
33 | @author	Jean Louis-Guerin
34 | $Revision: 1.0 $
35 | $Date: January 2014 $
36 | */
37 | 
38 | 
39 | 
40 | 
41 | 


--------------------------------------------------------------------------------
/kfstream/content.xaml.cs:
--------------------------------------------------------------------------------
 1 | using KFStreamPackage;
 2 | using System;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | using System.Threading.Tasks;
 7 | using System.Windows;
 8 | using System.Windows.Controls;
 9 | using System.Windows.Data;
10 | using System.Windows.Documents;
11 | using System.Windows.Input;
12 | using System.Windows.Media;
13 | using System.Windows.Media.Imaging;
14 | using System.Windows.Shapes;
15 | 
16 | namespace KFStream {
17 | 	/// <summary>
18 | 	/// Interaction logic for content.xaml
19 | 	/// </summary>
20 | 	public partial class ContentWindow : Window {
21 | 		public ContentWindow() {
22 | 			InitializeComponent();
23 | 		}
24 | 
25 | 
26 | 		/// <summary>
27 | 		/// Display the flux array for the specified revolution
28 | 		/// </summary>
29 | 		public void displayFlux(FluxData data, FluxDataRev[] dataRev, int rev) {
30 | 
31 | 			displayBuffer.FontFamily = new FontFamily("Consolas");
32 | 			displayBuffer.FontSize = 16;
33 | 			displayBuffer.FontStyle = FontStyles.Normal;
34 | 			displayBuffer.FontWeight = FontWeights.Normal;
35 | 
36 | 			displayBuffer.AppendText(String.Format("Revolution {0} has {1} transitions --- time {2} µs\n\n",
37 | 				rev + 1, dataRev[rev].fluxCount, dataRev[rev].revolutionTime / 1000));
38 | 			int firstFlux = dataRev[rev].firstFluxIndex;
39 | 			int lastFlux = firstFlux + dataRev[rev].fluxCount;
40 | 			for (int i = firstFlux; i < lastFlux; i += 16) {
41 | 				displayBuffer.AppendText(String.Format("{0:D5}  ", i - firstFlux));
42 | 				for (int j = 0; j < 16; j++) {
43 | 					if ((i + j) < lastFlux) {
44 | 						int flux = data.fluxValue[i + j];
45 | 						displayBuffer.AppendText(String.Format("{0:D4} ", flux));
46 | 					}
47 | 				}
48 | 				displayBuffer.AppendText(String.Format("\n"));
49 | 			}
50 | 		}
51 | 	}
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | AIR
 2 | ===
 3 | Atari Image File Reader
 4 | 
 5 | The Atari Image-file Reader-Writer (AIR) public domain project is a collection of programs 
 6 | that demonstrate how to read or write several of the Atari Image file formats. The source 
 7 | of the programs can be used as a reasonable example if you need to read or write image files. 
 8 | While reading or writing the image file the program displays a lot of information about the 
 9 | internal content of the file. It should be used in conjunction with the image file format 
10 | description that I also provide.
11 | 
12 | The programs have a nice WPF (Windows Presentation Foundation) Graphical User Interface and are developed in C#. 
13 | 
14 | Currently the AIR project is composed of
15 | - Pasti File format Reader-Writer 
16 | - IPF File format Reader-Writer
17 | - KryoFlux Raw stream file Reader-Writer
18 | 
19 | The Atari Image file Reader/Writer project is free software; you can redistribute it
20 | and/or modify  it under the terms of the GNU General Public License
21 | as published by the Free Software Foundation; either version 3
22 | of the License, or (at your option) any later version.
23 | https://gnu.org/licenses/gpl.html
24 | 
25 | The different Atari image file formats are described in my Atari FD Image Format page http://info-coach.fr/atari/software/Images-formats.php
26 | - Atari Standard Image File Formats http://info-coach.fr/atari/documents/_mydoc/FD_Image_File_Format.pdf
27 | - Interchangeable Preservation Format (IPF) Documentation http://info-coach.fr/atari/documents/_mydoc/IPF-Documentation.pdf
28 | - Pasti File (STX) Documentation http://info-coach.fr/atari/documents/_mydoc/Pasti-documentation.pdf
29 | - Kryoflux Raw Stream File Documentation http://info-coach.fr/atari/documents/_mydoc/kryoflux_stream_protocol.pdf
30 | 
31 | Specific documentations can be downloaded from Atari Documentation from DrCoolZic page http://info-coach.fr/atari/documents/myDoc.php
32 | 


--------------------------------------------------------------------------------
/kfstream/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="KFStream.MainWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         Title="MainWindow" Height="600" Width="900" AllowDrop="True" Drop="fileDrop">
 5 |     <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch" >
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="auto"/>
 8 |             <RowDefinition Height="*"/>
 9 |             <RowDefinition Height="auto"/>
10 |         </Grid.RowDefinitions>
11 |         <StackPanel  Grid.Row="0" Orientation="Horizontal" HorizontalAlignment="Stretch" Height="20" VerticalAlignment="Top" Grid.ColumnSpan="2" Margin="5">
12 |             <Button Margin="0,0,5,0" Content="Read Raw File" Width="100" Click="btReadClick" />
13 |             <Button Margin="0,0,5,0" Content="Write Raw File" Width="100" Click="btWriteClick" />
14 |             <TextBox Name="fileName" Margin="5,0" BorderThickness="0" />
15 |         </StackPanel>
16 |         <TextBox Grid.Row="1" Name="infoBox" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"  VerticalScrollBarVisibility="Auto" 
17 |                  TextWrapping="Wrap" Text="" AllowDrop="True" PreviewDragEnter="dragEnter" PreviewDragOver="dragEnter" PreviewDrop="fileDrop" />
18 |         <StackPanel  Grid.Row="2" Orientation="Horizontal" HorizontalAlignment="Stretch" VerticalAlignment="Top" Grid.ColumnSpan="2" Margin="5">
19 |             <Label Content="Revolution:" Padding="0" HorizontalContentAlignment="Right" VerticalContentAlignment="Center"/>
20 |             <TextBox Name="tbRev" Text="1" Width="40" BorderThickness="0"  HorizontalContentAlignment="Left" VerticalContentAlignment="Center" Padding="5,0,15,0"/>
21 |             <Button Content="Transitions" Width="100" Click="btTransitions" />
22 |             <TextBox Name="tbStatus" HorizontalAlignment="Stretch" Padding="10,0,0,0" BorderThickness="0"/>        
23 |         </StackPanel>
24 |     </Grid>
25 | </Window>
26 | 


--------------------------------------------------------------------------------
/pasti/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="Pasti.MainWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         Title="Pasti File Reader / Writer 0.8" Height="600" Width="900" AllowDrop="True" Drop="fileDrop">
 5 |     <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch" >
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="20"/>
 8 |             <RowDefinition Height="*"/>
 9 |             <RowDefinition Height="22"/>
10 |         </Grid.RowDefinitions>
11 |         <StackPanel  Grid.Row="0" Orientation="Horizontal" HorizontalAlignment="Stretch" Height="20" VerticalAlignment="Top" Grid.ColumnSpan="2">
12 |             <Button Margin="0,0,5,0" Content="Read Pasti File" Width="100" Click="btFileClick" />
13 |             <Button Margin="0,0,5,0" Content="Write Pasti File" Width="100" Click="btWriteClick" />
14 |             <TextBox Name="fileName" Margin="5,0" BorderThickness="0" />
15 |         </StackPanel>
16 |         <TextBox Grid.Row="1" Name="infoBox" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"  VerticalScrollBarVisibility="Auto" Margin="0,5"
17 |                  TextWrapping="Wrap" Text="" AllowDrop="True" PreviewDragEnter="dragEnter" PreviewDragOver="dragEnter" PreviewDrop="fileDrop" />
18 |         <StackPanel  Grid.Row="2" Orientation="Horizontal" HorizontalAlignment="Stretch" Height="20" VerticalAlignment="Top" Grid.ColumnSpan="2" >
19 |             <Label Content="Track" Padding="0" Width="38" Height="22" HorizontalContentAlignment="Right" Margin="0,0,5,0" />
20 |             <TextBox Name="tbTrack" MinWidth="30" Height="22" Text="00" BorderThickness="0"  />
21 |             <Label Content="Side" Padding="0" Width="38" Height="22" HorizontalContentAlignment="Right" Margin="0,0,5,0" />
22 |             <TextBox Name="tbSide" MinWidth="30" Height="22" Text="0" BorderThickness="0"/>
23 |             <Button Margin="0,0,5,0" Content="Track content" Width="100" Click="btTrackClick" />
24 |             <Button Margin="0,0,5,0" Content="Sectors content" Width="100" Click="btSectorsClick" />
25 |             <Button Margin="0,0,5,0" Content="Save All Sectors" Width="100" Click="btAllSectorsClick" />
26 |             <TextBox Name="tbStatus" Height="22" BorderThickness="0" />
27 |         </StackPanel>
28 |     </Grid>
29 | </Window>
30 | 
31 | 


--------------------------------------------------------------------------------
/pasti/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // General Information about an assembly is controlled through the following 
 8 | // set of attributes. Change these attribute values to modify the information
 9 | // associated with an assembly.
10 | [assembly: AssemblyTitle("pasti")]
11 | [assembly: AssemblyDescription("")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("")]
14 | [assembly: AssemblyProduct("pasti")]
15 | [assembly: AssemblyCopyright("Copyright ©  2015")]
16 | [assembly: AssemblyTrademark("")]
17 | [assembly: AssemblyCulture("")]
18 | 
19 | // Setting ComVisible to false makes the types in this assembly not visible 
20 | // to COM components.  If you need to access a type in this assembly from 
21 | // COM, set the ComVisible attribute to true on that type.
22 | [assembly: ComVisible(false)]
23 | 
24 | //In order to begin building localizable applications, set 
25 | //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
26 | //inside a <PropertyGroup>.  For example, if you are using US english
27 | //in your source files, set the <UICulture> to en-US.  Then uncomment
28 | //the NeutralResourceLanguage attribute below.  Update the "en-US" in
29 | //the line below to match the UICulture setting in the project file.
30 | 
31 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
32 | 
33 | 
34 | [assembly: ThemeInfo(
35 | 	ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
36 | 	//(used if a resource is not found in the page, 
37 | 	// or application resource dictionaries)
38 | 	ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
39 | 	//(used if a resource is not found in the page, 
40 | 	// app, or any theme specific resource dictionaries)
41 | )]
42 | 
43 | 
44 | // Version information for an assembly consists of the following four values:
45 | //
46 | //      Major Version
47 | //      Minor Version 
48 | //      Build Number
49 | //      Revision
50 | //
51 | // You can specify all the values or you can default the Build and Revision Numbers 
52 | // by using the '*' as shown below:
53 | // [assembly: AssemblyVersion("1.0.*")]
54 | [assembly: AssemblyVersion("1.0.*")]
55 | [assembly: AssemblyFileVersion("1.0")]
56 | 


--------------------------------------------------------------------------------
/kfstream/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // General Information about an assembly is controlled through the following 
 8 | // set of attributes. Change these attribute values to modify the information
 9 | // associated with an assembly.
10 | [assembly: AssemblyTitle("kfstream")]
11 | [assembly: AssemblyDescription("")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("")]
14 | [assembly: AssemblyProduct("kfstream")]
15 | [assembly: AssemblyCopyright("Copyright ©  2015")]
16 | [assembly: AssemblyTrademark("")]
17 | [assembly: AssemblyCulture("")]
18 | 
19 | // Setting ComVisible to false makes the types in this assembly not visible 
20 | // to COM components.  If you need to access a type in this assembly from 
21 | // COM, set the ComVisible attribute to true on that type.
22 | [assembly: ComVisible(false)]
23 | 
24 | //In order to begin building localizable applications, set 
25 | //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
26 | //inside a <PropertyGroup>.  For example, if you are using US english
27 | //in your source files, set the <UICulture> to en-US.  Then uncomment
28 | //the NeutralResourceLanguage attribute below.  Update the "en-US" in
29 | //the line below to match the UICulture setting in the project file.
30 | 
31 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
32 | 
33 | 
34 | [assembly: ThemeInfo(
35 | 	ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
36 | 	//(used if a resource is not found in the page, 
37 | 	// or application resource dictionaries)
38 | 	ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
39 | 	//(used if a resource is not found in the page, 
40 | 	// app, or any theme specific resource dictionaries)
41 | )]
42 | 
43 | 
44 | // Version information for an assembly consists of the following four values:
45 | //
46 | //      Major Version
47 | //      Minor Version 
48 | //      Build Number
49 | //      Revision
50 | //
51 | // You can specify all the values or you can default the Build and Revision Numbers 
52 | // by using the '*' as shown below:
53 | // [assembly: AssemblyVersion("1.0.*")]
54 | [assembly: AssemblyVersion("0.1.*")]
55 | [assembly: AssemblyFileVersion("1.0.0.0")]
56 | 


--------------------------------------------------------------------------------
/ipf/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // General Information about an assembly is controlled through the following 
 8 | // set of attributes. Change these attribute values to modify the information
 9 | // associated with an assembly.
10 | [assembly: AssemblyTitle("IPF")]
11 | [assembly: AssemblyDescription("IPF")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("DrCoolZic")]
14 | [assembly: AssemblyProduct("IPF Files reader / writer")]
15 | [assembly: AssemblyCopyright("Copyright ©  2015")]
16 | [assembly: AssemblyTrademark("© Copyright 2014-2015 DrCoolZic")]
17 | [assembly: AssemblyCulture("")]
18 | 
19 | // Setting ComVisible to false makes the types in this assembly not visible 
20 | // to COM components.  If you need to access a type in this assembly from 
21 | // COM, set the ComVisible attribute to true on that type.
22 | [assembly: ComVisible(false)]
23 | 
24 | //In order to begin building localizable applications, set 
25 | //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
26 | //inside a <PropertyGroup>.  For example, if you are using US english
27 | //in your source files, set the <UICulture> to en-US.  Then uncomment
28 | //the NeutralResourceLanguage attribute below.  Update the "en-US" in
29 | //the line below to match the UICulture setting in the project file.
30 | 
31 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
32 | 
33 | 
34 | [assembly: ThemeInfo(
35 | 	ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
36 | 	//(used if a resource is not found in the page, 
37 | 	// or application resource dictionaries)
38 | 	ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
39 | 	//(used if a resource is not found in the page, 
40 | 	// app, or any theme specific resource dictionaries)
41 | )]
42 | 
43 | 
44 | // Version information for an assembly consists of the following four values:
45 | //
46 | //      Major Version
47 | //      Minor Version 
48 | //      Build Number
49 | //      Revision
50 | //
51 | // You can specify all the values or you can default the Build and Revision Numbers 
52 | // by using the '*' as shown below:
53 | // [assembly: AssemblyVersion("1.0.*")]
54 | [assembly: AssemblyVersion("1.1.*")]
55 | [assembly: AssemblyFileVersion("1.1")]
56 | 


--------------------------------------------------------------------------------
/AIR.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 2013
 4 | VisualStudioVersion = 12.0.40629.0
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{EB1DF796-879F-4D47-BE90-93F142EC2CE2}"
 7 | 	ProjectSection(SolutionItems) = preProject
 8 | 		doxygen.css = doxygen.css
 9 | 		README.md = README.md
10 | 	EndProjectSection
11 | EndProject
12 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Pasti", "pasti\Pasti.csproj", "{6C747094-3588-42A3-A868-341CC2148933}"
13 | EndProject
14 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IPF", "ipf\IPF.csproj", "{AA467937-452A-4AE0-AD9D-674EEF0811EB}"
15 | EndProject
16 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "KFStream", "kfstream\KFStream.csproj", "{19A3C77B-31CD-4F12-AC49-E88161D73A70}"
17 | EndProject
18 | Global
19 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
20 | 		Debug|Any CPU = Debug|Any CPU
21 | 		Release|Any CPU = Release|Any CPU
22 | 	EndGlobalSection
23 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
24 | 		{6C747094-3588-42A3-A868-341CC2148933}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
25 | 		{6C747094-3588-42A3-A868-341CC2148933}.Debug|Any CPU.Build.0 = Debug|Any CPU
26 | 		{6C747094-3588-42A3-A868-341CC2148933}.Release|Any CPU.ActiveCfg = Release|Any CPU
27 | 		{6C747094-3588-42A3-A868-341CC2148933}.Release|Any CPU.Build.0 = Release|Any CPU
28 | 		{AA467937-452A-4AE0-AD9D-674EEF0811EB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
29 | 		{AA467937-452A-4AE0-AD9D-674EEF0811EB}.Debug|Any CPU.Build.0 = Debug|Any CPU
30 | 		{AA467937-452A-4AE0-AD9D-674EEF0811EB}.Release|Any CPU.ActiveCfg = Release|Any CPU
31 | 		{AA467937-452A-4AE0-AD9D-674EEF0811EB}.Release|Any CPU.Build.0 = Release|Any CPU
32 | 		{19A3C77B-31CD-4F12-AC49-E88161D73A70}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
33 | 		{19A3C77B-31CD-4F12-AC49-E88161D73A70}.Debug|Any CPU.Build.0 = Debug|Any CPU
34 | 		{19A3C77B-31CD-4F12-AC49-E88161D73A70}.Release|Any CPU.ActiveCfg = Release|Any CPU
35 | 		{19A3C77B-31CD-4F12-AC49-E88161D73A70}.Release|Any CPU.Build.0 = Release|Any CPU
36 | 	EndGlobalSection
37 | 	GlobalSection(SolutionProperties) = preSolution
38 | 		HideSolutionNode = FALSE
39 | 	EndGlobalSection
40 | 	GlobalSection(NestedProjects) = preSolution
41 | 		{6C747094-3588-42A3-A868-341CC2148933} = {EB1DF796-879F-4D47-BE90-93F142EC2CE2}
42 | 		{AA467937-452A-4AE0-AD9D-674EEF0811EB} = {EB1DF796-879F-4D47-BE90-93F142EC2CE2}
43 | 		{19A3C77B-31CD-4F12-AC49-E88161D73A70} = {EB1DF796-879F-4D47-BE90-93F142EC2CE2}
44 | 	EndGlobalSection
45 | EndGlobal
46 | 


--------------------------------------------------------------------------------
/ipf/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.34014
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace ipf.Properties {
12 | 
13 | 
14 | 	/// <summary>
15 | 	///   A strongly-typed resource class, for looking up localized strings, etc.
16 | 	/// </summary>
17 | 	// This class was auto-generated by the StronglyTypedResourceBuilder
18 | 	// class via a tool like ResGen or Visual Studio.
19 | 	// To add or remove a member, edit your .ResX file then rerun ResGen
20 | 	// with the /str option, or rebuild your VS project.
21 | 	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
22 | 	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
23 | 	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
24 | 	internal class Resources {
25 | 
26 | 		private static global::System.Resources.ResourceManager resourceMan;
27 | 
28 | 		private static global::System.Globalization.CultureInfo resourceCulture;
29 | 
30 | 		[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
31 | 		internal Resources() {
32 | 		}
33 | 
34 | 		/// <summary>
35 | 		///   Returns the cached ResourceManager instance used by this class.
36 | 		/// </summary>
37 | 		[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
38 | 		internal static global::System.Resources.ResourceManager ResourceManager {
39 | 			get {
40 | 				if ((resourceMan == null)) {
41 | 					global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ipf.Properties.Resources", typeof(Resources).Assembly);
42 | 					resourceMan = temp;
43 | 				}
44 | 				return resourceMan;
45 | 			}
46 | 		}
47 | 
48 | 		/// <summary>
49 | 		///   Overrides the current thread's CurrentUICulture property for all
50 | 		///   resource lookups using this strongly typed resource class.
51 | 		/// </summary>
52 | 		[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
53 | 		internal static global::System.Globalization.CultureInfo Culture {
54 | 			get {
55 | 				return resourceCulture;
56 | 			}
57 | 			set {
58 | 				resourceCulture = value;
59 | 			}
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/pasti/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.34014
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace pasti.Properties {
12 | 
13 | 
14 | 	/// <summary>
15 | 	///   A strongly-typed resource class, for looking up localized strings, etc.
16 | 	/// </summary>
17 | 	// This class was auto-generated by the StronglyTypedResourceBuilder
18 | 	// class via a tool like ResGen or Visual Studio.
19 | 	// To add or remove a member, edit your .ResX file then rerun ResGen
20 | 	// with the /str option, or rebuild your VS project.
21 | 	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
22 | 	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
23 | 	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
24 | 	internal class Resources {
25 | 
26 | 		private static global::System.Resources.ResourceManager resourceMan;
27 | 
28 | 		private static global::System.Globalization.CultureInfo resourceCulture;
29 | 
30 | 		[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
31 | 		internal Resources() {
32 | 		}
33 | 
34 | 		/// <summary>
35 | 		///   Returns the cached ResourceManager instance used by this class.
36 | 		/// </summary>
37 | 		[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
38 | 		internal static global::System.Resources.ResourceManager ResourceManager {
39 | 			get {
40 | 				if ((resourceMan == null)) {
41 | 					global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("pasti.Properties.Resources", typeof(Resources).Assembly);
42 | 					resourceMan = temp;
43 | 				}
44 | 				return resourceMan;
45 | 			}
46 | 		}
47 | 
48 | 		/// <summary>
49 | 		///   Overrides the current thread's CurrentUICulture property for all
50 | 		///   resource lookups using this strongly typed resource class.
51 | 		/// </summary>
52 | 		[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
53 | 		internal static global::System.Globalization.CultureInfo Culture {
54 | 			get {
55 | 				return resourceCulture;
56 | 			}
57 | 			set {
58 | 				resourceCulture = value;
59 | 			}
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/kfstream/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.34209
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace KFStream.Properties {
12 | 
13 | 
14 | 	/// <summary>
15 | 	///   A strongly-typed resource class, for looking up localized strings, etc.
16 | 	/// </summary>
17 | 	// This class was auto-generated by the StronglyTypedResourceBuilder
18 | 	// class via a tool like ResGen or Visual Studio.
19 | 	// To add or remove a member, edit your .ResX file then rerun ResGen
20 | 	// with the /str option, or rebuild your VS project.
21 | 	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
22 | 	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
23 | 	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
24 | 	internal class Resources {
25 | 
26 | 		private static global::System.Resources.ResourceManager resourceMan;
27 | 
28 | 		private static global::System.Globalization.CultureInfo resourceCulture;
29 | 
30 | 		[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
31 | 		internal Resources() {
32 | 		}
33 | 
34 | 		/// <summary>
35 | 		///   Returns the cached ResourceManager instance used by this class.
36 | 		/// </summary>
37 | 		[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
38 | 		internal static global::System.Resources.ResourceManager ResourceManager {
39 | 			get {
40 | 				if ((resourceMan == null)) {
41 | 					global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("kfstream.Properties.Resources", typeof(Resources).Assembly);
42 | 					resourceMan = temp;
43 | 				}
44 | 				return resourceMan;
45 | 			}
46 | 		}
47 | 
48 | 		/// <summary>
49 | 		///   Overrides the current thread's CurrentUICulture property for all
50 | 		///   resource lookups using this strongly typed resource class.
51 | 		/// </summary>
52 | 		[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
53 | 		internal static global::System.Globalization.CultureInfo Culture {
54 | 			get {
55 | 				return resourceCulture;
56 | 			}
57 | 			set {
58 | 				resourceCulture = value;
59 | 			}
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | ###############################################################################
 2 | # Set default behavior to automatically normalize line endings.
 3 | ###############################################################################
 4 | * text=auto
 5 | 
 6 | ###############################################################################
 7 | # Set default behavior for command prompt diff.
 8 | #
 9 | # This is need for earlier builds of msysgit that does not have it on by
10 | # default for csharp files.
11 | # Note: This is only used by command line
12 | ###############################################################################
13 | #*.cs     diff=csharp
14 | 
15 | ###############################################################################
16 | # Set the merge driver for project and solution files
17 | #
18 | # Merging from the command prompt will add diff markers to the files if there
19 | # are conflicts (Merging from VS is not affected by the settings below, in VS
20 | # the diff markers are never inserted). Diff markers may cause the following 
21 | # file extensions to fail to load in VS. An alternative would be to treat
22 | # these files as binary and thus will always conflict and require user
23 | # intervention with every merge. To do so, just uncomment the entries below
24 | ###############################################################################
25 | #*.sln       merge=binary
26 | #*.csproj    merge=binary
27 | #*.vbproj    merge=binary
28 | #*.vcxproj   merge=binary
29 | #*.vcproj    merge=binary
30 | #*.dbproj    merge=binary
31 | #*.fsproj    merge=binary
32 | #*.lsproj    merge=binary
33 | #*.wixproj   merge=binary
34 | #*.modelproj merge=binary
35 | #*.sqlproj   merge=binary
36 | #*.wwaproj   merge=binary
37 | 
38 | ###############################################################################
39 | # behavior for image files
40 | #
41 | # image files are treated as binary by default.
42 | ###############################################################################
43 | #*.jpg   binary
44 | #*.png   binary
45 | #*.gif   binary
46 | 
47 | ###############################################################################
48 | # diff behavior for common document formats
49 | # 
50 | # Convert binary document formats to text before diffing them. This feature
51 | # is only available from the command line. Turn it on by uncommenting the 
52 | # entries below.
53 | ###############################################################################
54 | #*.doc   diff=astextplain
55 | #*.DOC   diff=astextplain
56 | #*.docx  diff=astextplain
57 | #*.DOCX  diff=astextplain
58 | #*.dot   diff=astextplain
59 | #*.DOT   diff=astextplain
60 | #*.pdf   diff=astextplain
61 | #*.PDF   diff=astextplain
62 | #*.rtf   diff=astextplain
63 | #*.RTF   diff=astextplain
64 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | # my Doxygen files
  4 | html/
  5 | *.tag
  6 | 
  7 | # User-specific files
  8 | *.suo
  9 | *.user
 10 | *.sln.docstates
 11 | 
 12 | Archive/
 13 | .vs/
 14 | 
 15 | # Build results
 16 | 
 17 | [Dd]ebug/
 18 | [Rr]elease/
 19 | x64/
 20 | build/
 21 | [Bb]in/
 22 | [Oo]bj/
 23 | 
 24 | # Enable "build/" folder in the NuGet Packages folder since NuGet packages use it for MSBuild targets
 25 | !packages/*/build/
 26 | 
 27 | # MSTest test Results
 28 | [Tt]est[Rr]esult*/
 29 | [Bb]uild[Ll]og.*
 30 | 
 31 | *_i.c
 32 | *_p.c
 33 | *.ilk
 34 | *.meta
 35 | *.obj
 36 | *.pch
 37 | *.pdb
 38 | *.pgc
 39 | *.pgd
 40 | *.rsp
 41 | *.sbr
 42 | *.tlb
 43 | *.tli
 44 | *.tlh
 45 | *.tmp
 46 | *.tmp_proj
 47 | *.log
 48 | *.vspscc
 49 | *.vssscc
 50 | .builds
 51 | *.pidb
 52 | *.log
 53 | *.scc
 54 | *.vcxproj.user
 55 | 
 56 | # Visual C++ cache files
 57 | ipch/
 58 | *.aps
 59 | *.ncb
 60 | *.opensdf
 61 | *.sdf
 62 | *.cachefile
 63 | 
 64 | # Visual Studio profiler
 65 | *.psess
 66 | *.vsp
 67 | *.vspx
 68 | 
 69 | # Guidance Automation Toolkit
 70 | *.gpState
 71 | 
 72 | # ReSharper is a .NET coding add-in
 73 | _ReSharper*/
 74 | *.[Rr]e[Ss]harper
 75 | 
 76 | # TeamCity is a build add-in
 77 | _TeamCity*
 78 | 
 79 | # DotCover is a Code Coverage Tool
 80 | *.dotCover
 81 | 
 82 | # NCrunch
 83 | *.ncrunch*
 84 | .*crunch*.local.xml
 85 | 
 86 | # Installshield output folder
 87 | [Ee]xpress/
 88 | 
 89 | # DocProject is a documentation generator add-in
 90 | DocProject/buildhelp/
 91 | DocProject/Help/*.HxT
 92 | DocProject/Help/*.HxC
 93 | DocProject/Help/*.hhc
 94 | DocProject/Help/*.hhk
 95 | DocProject/Help/*.hhp
 96 | DocProject/Help/Html2
 97 | DocProject/Help/html
 98 | 
 99 | # Click-Once directory
100 | publish/
101 | 
102 | # Publish Web Output
103 | *.Publish.xml
104 | *.pubxml
105 | 
106 | # NuGet Packages Directory
107 | ## TODO: If you have NuGet Package Restore enabled, uncomment the next line
108 | #packages/
109 | 
110 | # Windows Azure Build Output
111 | csx
112 | *.build.csdef
113 | 
114 | # Windows Store app package directory
115 | AppPackages/
116 | 
117 | # Others
118 | sql/
119 | *.Cache
120 | ClientBin/
121 | [Ss]tyle[Cc]op.*
122 | ~$*
123 | *~
124 | *.dbmdl
125 | *.[Pp]ublish.xml
126 | *.pfx
127 | *.publishsettings
128 | 
129 | # RIA/Silverlight projects
130 | Generated_Code/
131 | 
132 | # Backup & report files from converting an old project file to a newer
133 | # Visual Studio version. Backup files are not needed, because we have git ;-)
134 | _UpgradeReport_Files/
135 | Backup*/
136 | UpgradeLog*.XML
137 | UpgradeLog*.htm
138 | 
139 | # SQL Server files
140 | App_Data/*.mdf
141 | App_Data/*.ldf
142 | 
143 | # =========================
144 | # Windows detritus
145 | # =========================
146 | 
147 | # Windows image file caches
148 | Thumbs.db
149 | ehthumbs.db
150 | 
151 | # Folder config file
152 | Desktop.ini
153 | 
154 | # Recycle Bin used on file shares
155 | $RECYCLE.BIN/
156 | 
157 | # Mac crap
158 | .DS_Store


--------------------------------------------------------------------------------
/ipf/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.34014
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace ipf.Properties {
12 |     
13 |     
14 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
15 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "12.0.0.0")]
16 |     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
17 |         
18 |         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
19 |         
20 |         public static Settings Default {
21 |             get {
22 |                 return defaultInstance;
23 |             }
24 |         }
25 |         
26 |         [global::System.Configuration.UserScopedSettingAttribute()]
27 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
28 |         [global::System.Configuration.DefaultSettingValueAttribute("0")]
29 |         public double Top {
30 |             get {
31 |                 return ((double)(this["Top"]));
32 |             }
33 |             set {
34 |                 this["Top"] = value;
35 |             }
36 |         }
37 |         
38 |         [global::System.Configuration.UserScopedSettingAttribute()]
39 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
40 |         [global::System.Configuration.DefaultSettingValueAttribute("0")]
41 |         public double Left {
42 |             get {
43 |                 return ((double)(this["Left"]));
44 |             }
45 |             set {
46 |                 this["Left"] = value;
47 |             }
48 |         }
49 |         
50 |         [global::System.Configuration.UserScopedSettingAttribute()]
51 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
52 |         [global::System.Configuration.DefaultSettingValueAttribute("600")]
53 |         public double Height {
54 |             get {
55 |                 return ((double)(this["Height"]));
56 |             }
57 |             set {
58 |                 this["Height"] = value;
59 |             }
60 |         }
61 |         
62 |         [global::System.Configuration.UserScopedSettingAttribute()]
63 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
64 |         [global::System.Configuration.DefaultSettingValueAttribute("900")]
65 |         public double Width {
66 |             get {
67 |                 return ((double)(this["Width"]));
68 |             }
69 |             set {
70 |                 this["Width"] = value;
71 |             }
72 |         }
73 |         
74 |         [global::System.Configuration.UserScopedSettingAttribute()]
75 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
76 |         [global::System.Configuration.DefaultSettingValueAttribute("True")]
77 |         public bool DataElemChecked {
78 |             get {
79 |                 return ((bool)(this["DataElemChecked"]));
80 |             }
81 |             set {
82 |                 this["DataElemChecked"] = value;
83 |             }
84 |         }
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/ipf/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="ipf.MainWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         xmlns:jlg="clr-namespace:ipf" 
 5 |         Height="{jlg:SettingBinding Height}" Width="{jlg:SettingBinding Width}" Left="{jlg:SettingBinding Left}" Top="{jlg:SettingBinding Top}"
 6 |         Title="IPF File Reader / Writer V0.1" Closing="mainWinClosing" AllowDrop="True" Drop="fileDropped">
 7 | 
 8 |     <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
 9 |         <Grid.RowDefinitions>
10 |             <RowDefinition Height="Auto"/>
11 |             <RowDefinition Height="*"/>
12 |             <RowDefinition Height="Auto"/>
13 |         </Grid.RowDefinitions>
14 |         <StackPanel Grid.Row="0" Orientation="Horizontal" HorizontalAlignment="Stretch" VerticalAlignment="Center" Margin="1">
15 |             <Button Margin="0,0,5,0" Width="24" Click="btUpdateClick" HorizontalAlignment="Right">
16 |                 <Button.Content><Image Source="update.png" /></Button.Content>
17 |             </Button>
18 |             <Button Margin="0,0,5,0" Content="Read IPF File" Width="100" Click="btFileClick" />
19 |             <Button Margin="0,0,5,0" Content="Write IPF File" Width="100" Click="btWriteClick" />
20 |             
21 |             <TextBox Name="fileName" Margin="5,0" BorderThickness="0" VerticalContentAlignment="Center"/>
22 |         </StackPanel>
23 |         <TextBox Grid.Row="1" Name="infoBox" HorizontalAlignment="Stretch" TextWrapping="NoWrap" Text="" 
24 |                  VerticalAlignment="Stretch"  VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto" Margin="1" 
25 |                  AllowDrop="True" PreviewDragEnter="dragEnter" PreviewDragOver="dragEnter" PreviewDrop="fileDropped"/>
26 |         <Grid  Grid.Row="2" HorizontalAlignment="Stretch" VerticalAlignment="Top" Margin="5">
27 |             <Grid.ColumnDefinitions>
28 |                 <ColumnDefinition Width="Auto"/>
29 |                 <ColumnDefinition Width="Auto"/>
30 |                 <ColumnDefinition Width="Auto"/>
31 |                 <ColumnDefinition Width="Auto"/>
32 |                 <ColumnDefinition Width="Auto"/>
33 |                 <ColumnDefinition Width="Auto"/>
34 |                 <ColumnDefinition Width="*"/>
35 |                 <ColumnDefinition Width="Auto"/>
36 |             </Grid.ColumnDefinitions>
37 |             <Label Grid.Column="0" Content="Track" Padding="0" Width="38" HorizontalContentAlignment="Right" VerticalContentAlignment="Center" Margin="0,0,5,0" />
38 |             <TextBox Grid.Column="1" Name="tbTrack" Width="30" Text="00" VerticalContentAlignment="Center" BorderThickness="0"  />
39 |             <Label Grid.Column="2" Content="Side" Padding="0" Width="38" HorizontalContentAlignment="Right" VerticalContentAlignment="Center" Margin="0,0,5,0" />
40 |             <TextBox Grid.Column="3" Name="tbSide" Width="30" Text="0" VerticalContentAlignment="Center" BorderThickness="0"/>
41 |             <CheckBox Grid.Column="4" Name="cbDataElem" Content="DataElem" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="0,0,5,0" IsChecked="{jlg:SettingBinding DataElemChecked}" />
42 |             <Button Grid.Column="5" Margin="0,0,5,0" Content="Data Blocks" Width="80" Click="btBlocksClick" />
43 |             <TextBox Grid.Column="6" Name="tbStatus" Height="24" BorderThickness="0" VerticalContentAlignment="Center" Margin="0,0,10,0" />
44 |             <Button Grid.Column="7" Margin="5,0,0,0" Content="Write Log" Width="80" Click="writeLogClick" />
45 |         </Grid>
46 |     </Grid>
47 | </Window>
48 | 
49 | 


--------------------------------------------------------------------------------
/pasti/FloppyStruct.cs:
--------------------------------------------------------------------------------
 1 | /*!
 2 | @file FloppyStruct.cs
 3 | <summary>This file provide a Floppy Disk description structures</summary>	
 4 | 
 5 | <div class="jlg">Copyright (C) 2014 Jean Louis-Guerin\n\n
 6 | This file is part of the Atari Image Reader (AIR) project.\n
 7 | The Atari Image Reader project may be used and distributed without restriction provided
 8 | that this copyright statement is not removed from the file and that any
 9 | derivative work contains the original copyright notice and the associated
10 | disclaimer.\n
11 | The Atari Image Reader project is free software; you can redistribute it
12 | and/or modify  it under the terms of the GNU General Public License
13 | as published by the Free Software Foundation; either version 2
14 | of the License, or (at your option) any later version.\n
15 | The Atari Image Reader project is distributed in the hope that it will be useful,
16 | but WITHOUT ANY WARRANTY; without even the implied warranty of
17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
18 | See the GNU General Public License for more details.\n\n
19 | You should have received a copy of the GNU General Public License
20 | along with the Atari Universal FD Image Tool project; if not, write to the Free Software
21 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n</div>
22 | 
23 | @author Jean Louis-Guerin
24 | */
25 | using System;
26 | using System.Collections.Generic;
27 | using System.Linq;
28 | using System.Text;
29 | using System.Threading.Tasks;
30 | 
31 | namespace Pasti {
32 | 	/// <summary>Contains information about one sector</summary>
33 | 	/// <remarks>This class is used to store all information required to read or write a specific sector</remarks>
34 | 	public class Sector {
35 | 		/// <summary>buffer for the sector data</summary> 
36 | 		public byte[] sectorData;
37 | 		/// <summary>buffer for fuzzy mask bytes if necessary</summary> 
38 | 		public byte[] fuzzyData;
39 | 		/// <summary>buffer for timing bytes if necessary</summary>
40 | 		public ushort[] timmingData;
41 | 		/// <summary>position in the track of the sector address field in bits</summary>
42 | 		public ushort bitPosition;
43 | 		/// <summary>read time of the track in ms or 0 if standard sector</summary>
44 | 		public ushort readTime;
45 | 		/// <summary>Address field content</summary>
46 | 		public IDField id = new IDField();
47 | 		/// <summary>Status returned by the FDC</summary>
48 | 		public byte fdcFlags;
49 | 	}
50 | 
51 | 
52 | 	/// <summary>Contains information about one Track</summary>
53 | 	public class Track {
54 | 		/// <summary>Array of Sectors</summary>
55 | 		public Sector[] sectors;
56 | 
57 | 		/// <summary>Number of sectors for this track</summary>
58 | 		public uint sectorCount;
59 | 
60 | 		/// <summary>buffer for the track data if necessary</summary>
61 | 		public byte[] trackData;
62 | 
63 | 		/// <summary>First sync byte offset: This is the offset in byte of the first 0xA1 sync byte found in the track.</summary> 
64 | 		/// <remarks>This is usually the sync byte in front of the first address field.</remarks>
65 | 		public ushort firstSyncOffset;
66 | 
67 | 		/// <summary>Number of bytes in the track</summary>
68 | 		public uint byteCount;
69 | 
70 | 		/// <summary>track number</summary>
71 | 		public uint number;
72 | 
73 | 		/// <summary>track side</summary>
74 | 		public uint side;
75 | 
76 | 		/// <summary>All the sectors of the track follow the Atari standard</summary>
77 | 		/// <remarks>This is used to define if Sector Descriptor are required</remarks>
78 | 		public bool standardSectors = true;
79 | 
80 | 		/// <summary>The track follow the Atari standard</summary>
81 | 		/// <remarks>This is used to define if Track Data is required</remarks>
82 | 		public bool standardTrack = true;
83 | 	}
84 | 
85 | 
86 | 	/// <summary>Contains information about a complete Floppy disk</summary>
87 | 	/// <remarks>Complete floppy information (i.e. all tracks)</remarks>
88 | 	public class Floppy {
89 | 		/// <summary>Array of Tracks</summary>
90 | 		public Track[,] tracks;
91 | 	}
92 | 
93 | }
94 | 


--------------------------------------------------------------------------------
/ipf/BufferWindow.xaml.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Threading.Tasks;
  6 | using System.Windows;
  7 | using System.Windows.Controls;
  8 | using System.Windows.Data;
  9 | using System.Windows.Documents;
 10 | using System.Windows.Input;
 11 | using System.Windows.Media;
 12 | using System.Windows.Media.Imaging;
 13 | using System.Windows.Shapes;
 14 | 
 15 | namespace ipf {
 16 | 	/// <summary>
 17 | 	/// Interaction logic for BufferWindow.xaml
 18 | 	/// </summary>
 19 | 	public partial class BufferWindow : Window {
 20 | 		public BufferWindow() {
 21 | 			InitializeComponent();
 22 | 		}
 23 | 
 24 | 		/// <summary>
 25 | 		/// Draw the content of the buffer
 26 | 		/// </summary>
 27 | 		/// <param name="floppy">Pointer to the floppy disk structure</param>
 28 | 		/// <param name="track">The track number of the track to display</param>
 29 | 		/// <param name="side">The side of the track to display</param>
 30 | 		public void displayBlocksBuffer(Floppy floppy, int track, int side) {
 31 | 			displayBuffer.FontFamily = new FontFamily("Consolas");
 32 | 			displayBuffer.FontSize = 16;
 33 | 			displayBuffer.FontStyle = FontStyles.Normal;
 34 | 			displayBuffer.FontWeight = FontWeights.Normal;
 35 | 
 36 | 			Track t = floppy.tracks[track, side];
 37 | 			displayBuffer.AppendText(String.Format("Track {0:D2}.{1} has {2} blocks\n", track, side, t.blockCount));
 38 | 			uint trackGapSum = 0;
 39 | 			uint trackDataSum = 0;
 40 | 
 41 | 			for (int sect = 0; sect < t.blockCount; sect++) {
 42 | 				uint gapSum = 0;
 43 | 				uint dataSum = 0;
 44 | 				Sector s = t.sectors[sect];
 45 | 				foreach (GapElement gap in s.gapElems)
 46 | 					gapSum += gap.gapBytes;
 47 | 				foreach (DataElem data in s.dataElems)
 48 | 					dataSum += (data.type == DataType.Sync) ? (data.dataBytes / 2) : data.dataBytes;
 49 | 				displayBuffer.AppendText(String.Format("Sector {0} Total={1} bytes (Gap={2} Data={3}) in Block Descriptor: (Gap={4} Data={5})\n", 
 50 | 					sect, gapSum + dataSum, gapSum, dataSum, s.gapBits * 8, s.dataBits * 8));
 51 | 
 52 | 				foreach (GapElement gap in s.gapElems) {
 53 | 					displayBuffer.AppendText(String.Format("   - {0} Gap {1} Value={2:X2}\n",
 54 | 						(gap.type == GapType.Forward) ? "Forward" : "Backward", (gap.gapBytes == 0) ? "Repeat" : gap.gapBytes.ToString() + " bytes", gap.value));
 55 | 				}
 56 | 				if (gapSum != (s.gapBits * 8))
 57 | 					displayBuffer.AppendText(String.Format("   = Gap filling required: only {0} bytes specified out of {1}\n", gapSum, s.gapBits * 8));
 58 | 
 59 | 				foreach (DataElem data in s.dataElems) {
 60 | 					displayBuffer.AppendText(String.Format("   + {0} {1} bytes\n",
 61 | 						data.type.ToString(), (data.type == DataType.Sync) ? (data.dataBytes / 2) : data.dataBytes));
 62 | 					if (data.type != DataType.Fuzzy)
 63 | 						drawBuffer(data.value, data.type == DataType.Sync);
 64 | 				}
 65 | 				trackDataSum += dataSum;
 66 | 				trackGapSum += gapSum;
 67 | 			}
 68 | 			displayBuffer.AppendText(String.Format("Track {0:D2}.{1} Specified Bytes={2} ({3}) Data={4} ({5}) Gap={6} ({7})\n", track, side, 
 69 | 				trackDataSum + trackGapSum, (trackDataSum+trackGapSum)*8, trackDataSum, trackDataSum*8, trackGapSum, trackGapSum*8));
 70 | 		}
 71 | 
 72 | 
 73 | 
 74 | 
 75 | 		/// <summary>
 76 | 		/// Display the content of	 TrackBuffer buffer in the displayBuffer TextBox
 77 | 		/// </summary>
 78 | 		/// <param name="buffer">The buffer to display</param>
 79 | 		public void drawBuffer(List<byte> buffer, bool sync) {
 80 | 			displayBuffer.FontFamily = new FontFamily("Consolas");
 81 | 			displayBuffer.FontSize = 16;
 82 | 			displayBuffer.FontStyle = FontStyles.Normal;
 83 | 			displayBuffer.FontWeight = FontWeights.Normal;
 84 | 
 85 | 			for (int i = 0; i < buffer.Count(); i += 16) {
 86 | 				displayBuffer.AppendText(String.Format("   {0:D4}  ", i));
 87 | 
 88 | 				string ascii = "  ";
 89 | 				for (int j = 0; j < 16; j++) {
 90 | 					if ((i + j) < buffer.Count()) {
 91 | 						displayBuffer.AppendText(String.Format("{0:X2}{1}", buffer[i + j], (sync && (j % 2 == 0)) ? "" : " "));
 92 | 						char ch = Convert.ToChar(buffer[i + j]);
 93 | 						ascii += Char.IsControl(ch) ? "." : ch.ToString();
 94 | 					}
 95 | 					else
 96 | 						displayBuffer.AppendText(String.Format("   "));
 97 | 				}	// one more line
 98 | 				displayBuffer.AppendText(ascii);
 99 | 				displayBuffer.AppendText(String.Format("\n"));
100 | 			}	// all lines
101 | 		}
102 | 
103 | 	}
104 | }
105 | 


--------------------------------------------------------------------------------
/ipf/utilities.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Threading.Tasks;
  6 | 
  7 | namespace ipf {
  8 | 	public class Utilities {
  9 | 
 10 | 	private	static uint[] crc32_tab = {
 11 | 		0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
 12 | 		0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
 13 | 		0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
 14 | 		0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
 15 | 		0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
 16 | 		0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
 17 | 		0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
 18 | 		0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
 19 | 		0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
 20 | 		0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
 21 | 		0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
 22 | 		0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
 23 | 		0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
 24 | 		0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
 25 | 		0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
 26 | 		0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
 27 | 
 28 | 		0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
 29 | 		0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
 30 | 		0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
 31 | 		0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
 32 | 		0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
 33 | 		0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
 34 | 		0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
 35 | 		0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
 36 | 		0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
 37 | 		0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
 38 | 		0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
 39 | 		0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
 40 | 		0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
 41 | 		0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
 42 | 		0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
 43 | 		0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
 44 | 
 45 | 		0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
 46 | 		0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
 47 | 		0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
 48 | 		0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
 49 | 		0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
 50 | 		0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
 51 | 		0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
 52 | 		0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
 53 | 		0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
 54 | 		0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
 55 | 		0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
 56 | 		0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
 57 | 		0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
 58 | 		0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
 59 | 		0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
 60 | 		0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
 61 | 
 62 | 		0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
 63 | 		0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
 64 | 		0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
 65 | 		0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
 66 | 		0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
 67 | 		0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
 68 | 		0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
 69 | 		0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
 70 | 		0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
 71 | 		0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
 72 | 		0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
 73 | 		0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
 74 | 		0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
 75 | 		0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
 76 | 		0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
 77 | 		0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D,
 78 | 	};
 79 | 
 80 | 
 81 | 	public static uint crc32Header(byte[] buf, uint start, uint len) {
 82 | 		uint crc = 0;
 83 | 		crc = ~crc;
 84 | 		if ((start + len) > buf.Count()) return crc;
 85 | 		// the content of bytes 8, 9, 10, 11 are set to zero when computing the CRC
 86 | 		for (uint i = 0; i < len; i++)
 87 | 			crc = crc32_tab[(crc ^ (((i > 7) && (i < 12)) ? 0 : buf[start + i]) ) & 0xff] ^ (crc >> 8);
 88 | 		return ~crc;
 89 | 	}
 90 | 
 91 | 	public static uint crc32Buffer(byte[] buf, uint start, uint len) {
 92 | 		uint crc = 0;
 93 | 		if (len == 0) return 0;
 94 | 		crc = ~crc;
 95 | 		for (uint i = 0; i < len; i++)
 96 | 			crc = crc32_tab[(crc ^ buf[start + i]) & 0xff] ^ (crc >> 8);
 97 | 		return ~crc;
 98 | 	}
 99 | 
100 | 	public static uint crc32Buffer(List<byte> buf, int start, int len) {
101 | 		uint crc = 0;
102 | 		if (len == 0) return 0;
103 | 		crc = ~crc;
104 | 		for (int i = 0; i < len; i++)
105 | 			crc = crc32_tab[(crc ^ buf[(int)start + i]) & 0xff] ^ (crc >> 8);
106 | 		return ~crc;
107 | 	}
108 | 
109 | 
110 | 	public static uint crc32(uint crc, byte c) {
111 | 		return ~crc32_tab[(~crc ^ c) & 0xff] ^ (~crc >> 8);
112 | 	}
113 | 
114 | 
115 | 	public static ushort crc16(ushort crc, byte b) {
116 | 		for (int i = 0 ; i < 8 ; i++)
117 | 			crc = (ushort)((crc << 1) ^ (((((crc >> 8) ^ (b << i)) & 0x0080) != 0) ? 0x1021 : 0));
118 | 		return crc;
119 | 	} /* end of crc16 */
120 | 
121 | 	}
122 | 
123 | }
124 | 


--------------------------------------------------------------------------------
/kfstream/KFStream.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{19A3C77B-31CD-4F12-AC49-E88161D73A70}</ProjectGuid>
  8 |     <OutputType>WinExe</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>kfstream</RootNamespace>
 11 |     <AssemblyName>kfstream</AssemblyName>
 12 |     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
 13 |     <FileAlignment>512</FileAlignment>
 14 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 15 |     <WarningLevel>4</WarningLevel>
 16 |   </PropertyGroup>
 17 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 18 |     <PlatformTarget>AnyCPU</PlatformTarget>
 19 |     <DebugSymbols>true</DebugSymbols>
 20 |     <DebugType>full</DebugType>
 21 |     <Optimize>false</Optimize>
 22 |     <OutputPath>bin\Debug\</OutputPath>
 23 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 24 |     <ErrorReport>prompt</ErrorReport>
 25 |     <WarningLevel>4</WarningLevel>
 26 |   </PropertyGroup>
 27 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 28 |     <PlatformTarget>AnyCPU</PlatformTarget>
 29 |     <DebugType>pdbonly</DebugType>
 30 |     <Optimize>true</Optimize>
 31 |     <OutputPath>bin\Release\</OutputPath>
 32 |     <DefineConstants>TRACE</DefineConstants>
 33 |     <ErrorReport>prompt</ErrorReport>
 34 |     <WarningLevel>4</WarningLevel>
 35 |   </PropertyGroup>
 36 |   <ItemGroup>
 37 |     <Reference Include="System" />
 38 |     <Reference Include="System.Data" />
 39 |     <Reference Include="System.Xml" />
 40 |     <Reference Include="Microsoft.CSharp" />
 41 |     <Reference Include="System.Core" />
 42 |     <Reference Include="System.Xml.Linq" />
 43 |     <Reference Include="System.Data.DataSetExtensions" />
 44 |     <Reference Include="System.Xaml">
 45 |       <RequiredTargetFramework>4.0</RequiredTargetFramework>
 46 |     </Reference>
 47 |     <Reference Include="WindowsBase" />
 48 |     <Reference Include="PresentationCore" />
 49 |     <Reference Include="PresentationFramework" />
 50 |   </ItemGroup>
 51 |   <ItemGroup>
 52 |     <ApplicationDefinition Include="App.xaml">
 53 |       <Generator>MSBuild:Compile</Generator>
 54 |       <SubType>Designer</SubType>
 55 |     </ApplicationDefinition>
 56 |     <Page Include="content.xaml">
 57 |       <SubType>Designer</SubType>
 58 |       <Generator>MSBuild:Compile</Generator>
 59 |     </Page>
 60 |     <Page Include="MainWindow.xaml">
 61 |       <Generator>MSBuild:Compile</Generator>
 62 |       <SubType>Designer</SubType>
 63 |     </Page>
 64 |     <Compile Include="App.xaml.cs">
 65 |       <DependentUpon>App.xaml</DependentUpon>
 66 |       <SubType>Code</SubType>
 67 |     </Compile>
 68 |     <Compile Include="content.xaml.cs">
 69 |       <DependentUpon>content.xaml</DependentUpon>
 70 |     </Compile>
 71 |     <Compile Include="KFReader.cs" />
 72 |     <Compile Include="KFWriter.cs" />
 73 |     <Compile Include="MainWindow.xaml.cs">
 74 |       <DependentUpon>MainWindow.xaml</DependentUpon>
 75 |       <SubType>Code</SubType>
 76 |     </Compile>
 77 |   </ItemGroup>
 78 |   <ItemGroup>
 79 |     <Compile Include="ProcessStream.cs" />
 80 |     <Compile Include="Properties\AssemblyInfo.cs">
 81 |       <SubType>Code</SubType>
 82 |     </Compile>
 83 |     <Compile Include="Properties\Resources.Designer.cs">
 84 |       <AutoGen>True</AutoGen>
 85 |       <DesignTime>True</DesignTime>
 86 |       <DependentUpon>Resources.resx</DependentUpon>
 87 |     </Compile>
 88 |     <Compile Include="Properties\Settings.Designer.cs">
 89 |       <AutoGen>True</AutoGen>
 90 |       <DependentUpon>Settings.settings</DependentUpon>
 91 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
 92 |     </Compile>
 93 |     <EmbeddedResource Include="Properties\Resources.resx">
 94 |       <Generator>ResXFileCodeGenerator</Generator>
 95 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
 96 |     </EmbeddedResource>
 97 |     <None Include="Properties\Settings.settings">
 98 |       <Generator>SettingsSingleFileGenerator</Generator>
 99 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
100 |     </None>
101 |     <AppDesigner Include="Properties\" />
102 |   </ItemGroup>
103 |   <ItemGroup>
104 |     <None Include="App.config" />
105 |   </ItemGroup>
106 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
107 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
108 |        Other similar extension points exist, see Microsoft.Common.targets.
109 |   <Target Name="BeforeBuild">
110 |   </Target>
111 |   <Target Name="AfterBuild">
112 |   </Target>
113 |   -->
114 | </Project>


--------------------------------------------------------------------------------
/kfstream/KFWriter.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using System.Linq;
  5 | using System.Text;
  6 | using System.Threading.Tasks;
  7 | using System.Windows.Controls;
  8 | 
  9 | using KFStreamPackage;
 10 | using System.Globalization;
 11 | 
 12 | namespace KFStreamPackage {
 13 | 
 14 | 	class KFWriter {
 15 | 		double _sckValue;
 16 | 		double _ickValue;
 17 | 		TextBox _infoBox;
 18 | 
 19 | 		private static void addShort(List<byte> buffer, short value) {
 20 | 			buffer.Add((byte)value);
 21 | 			buffer.Add((byte)(value >> 8));
 22 | 
 23 | 		}
 24 | 
 25 | 		private static void addInt(List<byte> buffer, int value) {
 26 | 			buffer.Add((byte)value);
 27 | 			buffer.Add((byte)(value >> 8));
 28 | 			buffer.Add((byte)(value >> 16));
 29 | 			buffer.Add((byte)(value >> 24));
 30 | 		}
 31 | 
 32 | 		private void writeStreamInfo(List<byte> buffer, int streamPosition, int transferTime) {
 33 | 			buffer.Add((byte)BHeader.BHOOB);
 34 | 			buffer.Add((byte)OOBType.OOBStreamInfo);
 35 | 			KFWriter.addShort(buffer, 8);
 36 | 			KFWriter.addInt(buffer, streamPosition);
 37 | 			KFWriter.addInt(buffer, transferTime);
 38 | 		}
 39 | 
 40 | 		private void writeStreamIndex(List<byte> buffer, int streamPosition, int sampleCounter, int indexCounter) {
 41 | 			buffer.Add((byte)BHeader.BHOOB);
 42 | 			buffer.Add((byte)OOBType.OOBIndex);
 43 | 			addShort(buffer, 12);
 44 | 			addInt(buffer, streamPosition);
 45 | 			addInt(buffer, sampleCounter);
 46 | 			addInt(buffer, indexCounter);
 47 | 		}
 48 | 
 49 | 		private void writeStreamEnd(List<byte> buffer, int streamPosition, int resultCode) {
 50 | 			buffer.Add((byte)BHeader.BHOOB);
 51 | 			buffer.Add((byte)OOBType.OOBStreamEnd);
 52 | 			addShort(buffer, 8);
 53 | 			addInt(buffer, streamPosition);
 54 | 			addInt(buffer, resultCode);
 55 | 		}
 56 | 
 57 | 		private void writeHardwareInfo(List<byte> buffer, string info) {
 58 | 			buffer.Add((byte)BHeader.BHOOB);
 59 | 			buffer.Add((byte)OOBType.OOBHWInfo);
 60 | 			short size = (short)(info.Count() + 1);
 61 | 			addShort(buffer, size);
 62 | 			for (int i = 0; i < info.Count(); i++)
 63 | 				buffer.Add((byte)info[i]);
 64 | 			buffer.Add((byte)0);
 65 | 		}
 66 | 
 67 | 		private void writeStreamEOF(List<byte> buffer) {
 68 | 			buffer.Add((byte)BHeader.BHOOB);
 69 | 			buffer.Add((byte)OOBType.OOBEof);
 70 | 			addShort(buffer, 0x0D0D);
 71 | 		}
 72 | 
 73 | 		/// <summary>
 74 | 		/// The KFStream Writer Constructor
 75 | 		/// </summary>
 76 | 		/// <param name="tb">The TextBox used to display information</param>
 77 | 		public KFWriter(TextBox tb) {
 78 | 			// set clock default values
 79 | 			_sckValue = ((18432000.0 * 73.0) / 14.0) / 4.0;
 80 | 			_ickValue = _sckValue / 8;
 81 | 			_infoBox = tb;
 82 | 		}
 83 | 
 84 | 
 85 | 		/// <summary>
 86 | 		/// Write a KF raw file from a xxxx
 87 | 		/// </summary>
 88 | 		/// <param name="fileName">Name of the Pasti file to read</param>
 89 | 		/// <param name="fd">the Floppy parameter</param>
 90 | 		/// <returns>The status</returns>
 91 | 		public bool writeStream(string fileName, FluxData data, FluxDataRev[] rev) {
 92 | 			FileStream fs;
 93 | 
 94 | 			// encode file into buffer
 95 | 			List<byte> buffer = new List<byte>();
 96 | 			bool status;
 97 | 			status = encodeStream(buffer, data, rev);
 98 | 
 99 | 			try {
100 | 				fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Read);
101 | 			}
102 | 			catch (Exception exc) {
103 | 				Console.WriteLine("Error: {0}", exc.Message);
104 | 				return false;
105 | 			}
106 | 			fs.Write(buffer.ToArray(), 0 , buffer.Count);
107 | 			fs.Close();
108 | 
109 | 			return status;		
110 | 		}
111 | 
112 | 		private bool encodeStream(List<byte> buffer, FluxData data, FluxDataRev[] revolutions) {
113 | 			int streampos = 0;
114 | 			int indexCounter = 0;
115 | 
116 | 			string info = "sck=" + Convert.ToString(_sckValue, new CultureInfo("en-US")) +
117 | 				",ick=" + Convert.ToString(_ickValue, new CultureInfo("en-US"));
118 | 			writeHardwareInfo(buffer, info);
119 | 
120 | 			for (int rev = 0; rev < revolutions.Count(); rev++) {
121 | 				writeStreamInfo(buffer, streampos, 0);
122 | 				int samplePos = (int)((double)revolutions[rev].preIndexTime * _sckValue / 1000000000.0);
123 | 				writeStreamIndex(buffer, streampos, samplePos, indexCounter);
124 | 
125 | 				indexCounter += (int)(revolutions[rev].revolutionTime * _ickValue / 1000000000.0);
126 | 
127 | 				for (int fluxIndex = revolutions[rev].firstFluxIndex;
128 | 					fluxIndex < revolutions[rev].firstFluxIndex + revolutions[rev].fluxCount; 
129 | 					fluxIndex++) {
130 | 					int flux = (int)(data.fluxValue[fluxIndex] * _sckValue / 1000000000.0);
131 | 					while (flux > 0x10000) {
132 | 						buffer.Add(0x0B);
133 | 						flux -= 0x10000;
134 | 						streampos++;
135 | 					}	// Ovl16 - flux > 0xFFFF
136 | 					if (flux > 0x7FF) {
137 | 						buffer.Add(0xC);
138 | 						buffer.Add((byte)(flux >> 8));
139 | 						buffer.Add((byte)flux);
140 | 						streampos += 3;
141 | 					}	// flux3 0x0800 - 0xFFFF
142 | 					else {
143 | 						if (flux > 0xFF) {
144 | 							buffer.Add((byte)(flux >> 8));
145 | 							buffer.Add((byte)flux);
146 | 							streampos += 2;
147 | 						}	// flux2 0x0100 - 0x07FF
148 | 						else {
149 | 							if (flux > 0x0D) {
150 | 								buffer.Add((byte)flux);
151 | 								streampos++;
152 | 							}	// flux1 0x0E - 0xFF
153 | 							else {
154 | 								buffer.Add(0);
155 | 								buffer.Add((byte)flux);
156 | 								streampos += 2;
157 | 							}	// flux2 0x00 - 0x0D
158 | 						}	// flux < 0x100
159 | 					}	// flux < 0x800
160 | 				}	// write all flux for this revolution
161 | 			}	// all revolutions
162 | 
163 | 			writeStreamEnd(buffer, streampos, 0);
164 | 			writeStreamIndex(buffer, streampos, 1, indexCounter);
165 | 			writeStreamEOF(buffer);
166 | 			return true;
167 | 		}
168 | 	}
169 | }
170 | 


--------------------------------------------------------------------------------
/kfstream/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
  1 | using Microsoft.Win32;
  2 | using System;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Text;
  6 | using System.Threading.Tasks;
  7 | using System.Windows;
  8 | using System.Windows.Controls;
  9 | using System.Windows.Data;
 10 | using System.Windows.Documents;
 11 | using System.Windows.Input;
 12 | using System.Windows.Media;
 13 | using System.Windows.Media.Imaging;
 14 | using System.Windows.Navigation;
 15 | using System.Windows.Shapes;
 16 | 
 17 | using KFStreamPackage;
 18 | 
 19 | namespace KFStream {
 20 | 	/// <summary>
 21 | 	/// Interaction logic for MainWindow.xaml
 22 | 	/// </summary>
 23 | 	public partial class MainWindow : Window {
 24 | 		FluxData _fluxData;
 25 | 		FluxDataRev[] _fluxDataRev;
 26 | 		ContentWindow _contentWindow = null;
 27 | 		bool _contentOpen = false;
 28 | 
 29 | 		public MainWindow() {
 30 | 			InitializeComponent();
 31 | 			Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
 32 | 			DateTime dateTimeOfBuild = new DateTime(2000, 1, 1)
 33 | 								+ new TimeSpan(version.Build, 0, 0, 0)
 34 | 								+ TimeSpan.FromSeconds(version.Revision * 2);
 35 | 			Title = "KF Reader/Writer " + version.Major + "." + version.Minor + " - " + dateTimeOfBuild;
 36 | 		}
 37 | 
 38 | 
 39 | 		private void btReadClick(object sender, RoutedEventArgs e) {
 40 | 			OpenFileDialog ofd = new OpenFileDialog();
 41 | 			ofd.Filter = "KF Raw file|*.raw|All Files|*.*";
 42 | 			bool? ok = ofd.ShowDialog();
 43 | 			if (ok == true) {
 44 | 				fileName.Text = ofd.FileName;
 45 | 				processFile(ofd.FileName);
 46 | 			}
 47 | 		}
 48 | 
 49 | 
 50 | 		private void btWriteClick(object sender, RoutedEventArgs e) {
 51 | 			if (_fluxData == null) {
 52 | 				tbStatus.Text = "Nothing to write!";
 53 | 				return;
 54 | 			}
 55 | 
 56 | 			tbStatus.Clear();
 57 | 			infoBox.Clear();
 58 | 
 59 | 			SaveFileDialog sfd = new SaveFileDialog();
 60 | 			sfd.Filter = "KF Raw file|*.raw|All Files|*.*";
 61 | 
 62 | 			bool? ok = sfd.ShowDialog();
 63 | 			if (ok == true) {
 64 | 				fileName.Text = sfd.FileName;
 65 | 				KFWriter kf = new KFWriter(infoBox);
 66 | 				bool status = kf.writeStream(sfd.FileName, _fluxData, _fluxDataRev);
 67 | 				infoBox.AppendText(String.Format("file {0} written {1}\n", sfd.FileName, status ? "OK" : " with errors"));
 68 | 			}
 69 | 		}
 70 | 
 71 | 
 72 | 		private void processFile(string file) {
 73 | 			tbStatus.Clear();
 74 | 			infoBox.Clear();
 75 | 
 76 | 			infoBox.AppendText(String.Format("Reading stream file: {0}\n", fileName));
 77 | 			ProcessStream s = new ProcessStream();
 78 | 			StreamStatus status = s.readStreamTrack(file, infoBox);
 79 | 			infoBox.AppendText(String.Format("file read {0}\n", status == StreamStatus.sdsOk ? "correctly" : "incorrectly status = " + status.ToString()));
 80 | 			if (status != StreamStatus.sdsOk) return;
 81 | 
 82 | 			KFReader kfr = s.Reader;
 83 | 			 _fluxData = s.Data;
 84 | 			_fluxDataRev = s.Rev;
 85 | 
 86 | 			double totalFlux = 0;
 87 | 			for (int i = 0; i < _fluxData.totalFluxCount; i++)
 88 | 				totalFlux += _fluxData.fluxValue[i];
 89 | 			infoBox.AppendText(string.Format("\nFlux Count={0} - total time {1} ms for {2} revolutions\n",
 90 | 					_fluxData.totalFluxCount, totalFlux / 1000, _fluxDataRev.Count()));
 91 | 
 92 | 			double tick = 1000000.0 / kfr.SampleClock;
 93 | 			infoBox.AppendText(string.Format("Min flux={0:f2} µs / Max flux={1:f2} µs\n",
 94 | 					kfr.StreamStat.fluxMin * tick, kfr.StreamStat.fluxMax * tick));
 95 | 
 96 | 			for (int rev = 0; rev < _fluxDataRev.Count(); rev++) {
 97 | 				infoBox.AppendText(String.Format("   Rev {0} has {1} transitions - revolution time {2:F3} ms\n", rev, _fluxDataRev[rev].fluxCount, _fluxDataRev[rev].revolutionTime / 1000000.0));
 98 | 			}
 99 | 			
100 | 			infoBox.AppendText(string.Format("\nDisk Speed (min-avg-max):  {0:F3} - {1:F3} - {2:F3} RPM\n",
101 | 				kfr.StreamStat.minrpm, kfr.StreamStat.avgrpm, kfr.StreamStat.maxrpm));
102 | 
103 | 			string hardware = kfr.InfoString;
104 | 			if (hardware != "") {
105 | 				string[] info = hardware.Split(',');
106 | 				infoBox.AppendText("\nHardware information \n");
107 | 				for (int i = 0; i < info.Count(); i++)
108 | 					infoBox.AppendText(string.Format("   {0}\n", info[i]));
109 | 			}
110 | 		}
111 | 
112 | 
113 | 		private void fileDrop(object sender, DragEventArgs e) {
114 | 			string[] droppedFiles = null;
115 | 			if (e.Data.GetDataPresent(DataFormats.FileDrop)) {
116 | 				droppedFiles = e.Data.GetData(DataFormats.FileDrop, true) as string[];
117 | 			}
118 | 
119 | 			if ((null == droppedFiles) || (!droppedFiles.Any())) { return; }
120 | 			processFile(droppedFiles[0]);
121 | 		}
122 | 
123 | 		private void dragEnter(object sender, DragEventArgs e) {
124 | 			e.Handled = true;
125 | 		}
126 | 
127 | 		private void btTransitions(object sender, RoutedEventArgs e) {
128 | 			int revNumber;
129 | 			if (_fluxData == null) {
130 | 				tbStatus.Text = "Nothing to display";
131 | 				return;
132 | 			}
133 | 
134 | 			tbStatus.Clear();
135 | 			if (Int32.TryParse(tbRev.Text, out revNumber) == false) {
136 | 				tbStatus.Text = "Invalid track number - please correct and try again";
137 | 				return;
138 | 			}
139 | 
140 | 			// test rev number
141 | 			if ((revNumber > _fluxDataRev.Count()) || (revNumber < 1)) {
142 | 				tbStatus.Text = "Not that many revolutions - please correct and try again";
143 | 				return;
144 | 			}
145 | 
146 | 			if (_contentOpen)
147 | 				_contentWindow.Close();
148 | 
149 | 			_contentWindow = new ContentWindow();
150 | 			_contentWindow.displayFlux(_fluxData, _fluxDataRev, revNumber - 1);
151 | 			_contentWindow.Closed += new EventHandler(contentWindowClosed);
152 | 			_contentOpen = true;
153 | 			_contentWindow.Show();
154 | 		}
155 | 
156 | 		void contentWindowClosed(object sender, EventArgs e) {
157 | 			_contentOpen = false;
158 | 		}
159 | 
160 | 
161 | 	}
162 | }
163 | 


--------------------------------------------------------------------------------
/ipf/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:element name="root" msdata:IsDataSet="true">
 64 |       <xsd:complexType>
 65 |         <xsd:choice maxOccurs="unbounded">
 66 |           <xsd:element name="metadata">
 67 |             <xsd:complexType>
 68 |               <xsd:sequence>
 69 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 70 |               </xsd:sequence>
 71 |               <xsd:attribute name="name" type="xsd:string" />
 72 |               <xsd:attribute name="type" type="xsd:string" />
 73 |               <xsd:attribute name="mimetype" type="xsd:string" />
 74 |             </xsd:complexType>
 75 |           </xsd:element>
 76 |           <xsd:element name="assembly">
 77 |             <xsd:complexType>
 78 |               <xsd:attribute name="alias" type="xsd:string" />
 79 |               <xsd:attribute name="name" type="xsd:string" />
 80 |             </xsd:complexType>
 81 |           </xsd:element>
 82 |           <xsd:element name="data">
 83 |             <xsd:complexType>
 84 |               <xsd:sequence>
 85 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 86 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 87 |               </xsd:sequence>
 88 |               <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
 89 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 90 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 91 |             </xsd:complexType>
 92 |           </xsd:element>
 93 |           <xsd:element name="resheader">
 94 |             <xsd:complexType>
 95 |               <xsd:sequence>
 96 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 97 |               </xsd:sequence>
 98 |               <xsd:attribute name="name" type="xsd:string" use="required" />
 99 |             </xsd:complexType>
100 |           </xsd:element>
101 |         </xsd:choice>
102 |       </xsd:complexType>
103 |     </xsd:element>
104 |   </xsd:schema>
105 |   <resheader name="resmimetype">
106 |     <value>text/microsoft-resx</value>
107 |   </resheader>
108 |   <resheader name="version">
109 |     <value>2.0</value>
110 |   </resheader>
111 |   <resheader name="reader">
112 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
113 |   </resheader>
114 |   <resheader name="writer">
115 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 | </root>


--------------------------------------------------------------------------------
/pasti/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:element name="root" msdata:IsDataSet="true">
 64 |       <xsd:complexType>
 65 |         <xsd:choice maxOccurs="unbounded">
 66 |           <xsd:element name="metadata">
 67 |             <xsd:complexType>
 68 |               <xsd:sequence>
 69 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 70 |               </xsd:sequence>
 71 |               <xsd:attribute name="name" type="xsd:string" />
 72 |               <xsd:attribute name="type" type="xsd:string" />
 73 |               <xsd:attribute name="mimetype" type="xsd:string" />
 74 |             </xsd:complexType>
 75 |           </xsd:element>
 76 |           <xsd:element name="assembly">
 77 |             <xsd:complexType>
 78 |               <xsd:attribute name="alias" type="xsd:string" />
 79 |               <xsd:attribute name="name" type="xsd:string" />
 80 |             </xsd:complexType>
 81 |           </xsd:element>
 82 |           <xsd:element name="data">
 83 |             <xsd:complexType>
 84 |               <xsd:sequence>
 85 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 86 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 87 |               </xsd:sequence>
 88 |               <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
 89 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 90 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 91 |             </xsd:complexType>
 92 |           </xsd:element>
 93 |           <xsd:element name="resheader">
 94 |             <xsd:complexType>
 95 |               <xsd:sequence>
 96 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 97 |               </xsd:sequence>
 98 |               <xsd:attribute name="name" type="xsd:string" use="required" />
 99 |             </xsd:complexType>
100 |           </xsd:element>
101 |         </xsd:choice>
102 |       </xsd:complexType>
103 |     </xsd:element>
104 |   </xsd:schema>
105 |   <resheader name="resmimetype">
106 |     <value>text/microsoft-resx</value>
107 |   </resheader>
108 |   <resheader name="version">
109 |     <value>2.0</value>
110 |   </resheader>
111 |   <resheader name="reader">
112 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
113 |   </resheader>
114 |   <resheader name="writer">
115 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 | </root>


--------------------------------------------------------------------------------
/kfstream/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:element name="root" msdata:IsDataSet="true">
 64 |       <xsd:complexType>
 65 |         <xsd:choice maxOccurs="unbounded">
 66 |           <xsd:element name="metadata">
 67 |             <xsd:complexType>
 68 |               <xsd:sequence>
 69 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 70 |               </xsd:sequence>
 71 |               <xsd:attribute name="name" type="xsd:string" />
 72 |               <xsd:attribute name="type" type="xsd:string" />
 73 |               <xsd:attribute name="mimetype" type="xsd:string" />
 74 |             </xsd:complexType>
 75 |           </xsd:element>
 76 |           <xsd:element name="assembly">
 77 |             <xsd:complexType>
 78 |               <xsd:attribute name="alias" type="xsd:string" />
 79 |               <xsd:attribute name="name" type="xsd:string" />
 80 |             </xsd:complexType>
 81 |           </xsd:element>
 82 |           <xsd:element name="data">
 83 |             <xsd:complexType>
 84 |               <xsd:sequence>
 85 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 86 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 87 |               </xsd:sequence>
 88 |               <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
 89 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 90 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 91 |             </xsd:complexType>
 92 |           </xsd:element>
 93 |           <xsd:element name="resheader">
 94 |             <xsd:complexType>
 95 |               <xsd:sequence>
 96 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 97 |               </xsd:sequence>
 98 |               <xsd:attribute name="name" type="xsd:string" use="required" />
 99 |             </xsd:complexType>
100 |           </xsd:element>
101 |         </xsd:choice>
102 |       </xsd:complexType>
103 |     </xsd:element>
104 |   </xsd:schema>
105 |   <resheader name="resmimetype">
106 |     <value>text/microsoft-resx</value>
107 |   </resheader>
108 |   <resheader name="version">
109 |     <value>2.0</value>
110 |   </resheader>
111 |   <resheader name="reader">
112 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
113 |   </resheader>
114 |   <resheader name="writer">
115 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 | </root>


--------------------------------------------------------------------------------
/pasti/BufferWindow.xaml.cs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | @file BufferWindow.xaml.cs
  3 |  
  4 | <summary>Open a Window and displays buffer information</summary>
  5 | 
  6 | <div class="jlg">Copyright (C) 2011 Jean Louis-Guerin\n\n
  7 | This file is part of the Atari Universal FD Image Tool project.\n\n
  8 | The Atari Universal FD Image Tool project may be used and distributed without restriction provided
  9 | that this copyright statement is not removed from the file and that any
 10 | derivative work contains the original copyright notice and the associated
 11 | disclaimer.\n\n
 12 | The Atari Universal FD Image Tool project is free software; you can redistribute it
 13 | and/or modify  it under the terms of the GNU General Public License
 14 | as published by the Free Software Foundation; either version 3
 15 | of the License, or (at your option) any later version.\n\n
 16 | The Atari Universal FD Image Tool project is distributed in the hope that it will be useful,
 17 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n
 19 | See the GNU General Public License for more details.\n\n
 20 | You should have received a copy of the GNU General Public License
 21 | along with the Atari Universal FD Image Tool project; if not, write to the Free Software
 22 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n</div>
 23 | 
 24 | @author Jean Louis-Guerin
 25 | */
 26 | 
 27 | using System;
 28 | using System.Collections.Generic;
 29 | using System.IO;
 30 | using System.Linq;
 31 | using System.Text;
 32 | using System.Threading.Tasks;
 33 | using System.Windows;
 34 | using System.Windows.Controls;
 35 | using System.Windows.Data;
 36 | using System.Windows.Documents;
 37 | using System.Windows.Input;
 38 | using System.Windows.Media;
 39 | using System.Windows.Media.Imaging;
 40 | using System.Windows.Shapes;
 41 | 
 42 | 
 43 | namespace Pasti {
 44 | 	/// <summary>
 45 | 	/// Interaction logic for TrackBuffer.xaml
 46 | 	/// </summary>
 47 | 	public partial class BufferWindow : Window {
 48 | 		/// <summary>
 49 | 		/// Create a new BufferWindow object.
 50 | 		/// </summary>
 51 | 		public BufferWindow() {
 52 | 			InitializeComponent();
 53 | 		}
 54 | 
 55 | 		/// <summary>
 56 | 		/// Draw the content of the buffer
 57 | 		/// </summary>
 58 | 		/// <param name="floppy">Pointer to the floppy disk structure</param>
 59 | 		/// <param name="track">The track number of the track to display</param>
 60 | 		/// <param name="side">The side of the track to display</param>
 61 | 		public void displaySectorBuffer(Floppy floppy, int track, int side) {
 62 | 
 63 | 			displayBuffer.FontFamily = new FontFamily("Consolas");
 64 | 			displayBuffer.FontSize = 16;
 65 | 			displayBuffer.FontStyle = FontStyles.Normal;
 66 | 			displayBuffer.FontWeight = FontWeights.Normal;
 67 | 
 68 | 			Track t = floppy.tracks[track, side];
 69 | 
 70 | 			displayBuffer.AppendText(String.Format("Track {0:D2}.{1} has {2} sectors\n", track, side, t.sectorCount));
 71 | 			for (int sect = 0; sect < t.sectorCount; sect++) {
 72 | 				displayBuffer.AppendText(String.Format("Sector {0}", t.sectors[sect].id.number));
 73 | 				displayBuffer.AppendText(String.Format(" T={0} H={1} N={2} S={3} CRC={4:X4}",
 74 | 					t.sectors[sect].id.track, t.sectors[sect].id.side, t.sectors[sect].id.number, t.sectors[sect].id.size, t.sectors[sect].id.crc));
 75 | 
 76 | 				if (t.sectors[sect].sectorData != null) {
 77 | 					displayBuffer.AppendText(String.Format(" has {0} bytes\n", t.sectors[sect].sectorData.Count()));
 78 | 					displayBuffer.AppendText(String.Format("       bitPosition {0}, Flags {1:X2}", t.sectors[sect].bitPosition, t.sectors[sect].fdcFlags));
 79 | 					displayBuffer.AppendText(String.Format(" {0} {1}\n", ((t.sectors[sect].fdcFlags & SectorDesc.CRC_ERR) == 0) ?
 80 | 						"Good CRC" : "Bad CRC", (t.sectors[sect].fuzzyData != null) ? "Has Fuzzy bytes" : ""));
 81 | 					drawBuffer(t.sectors[sect].sectorData);
 82 | 					if (t.sectors[sect].fuzzyData != null) {
 83 | 						displayBuffer.AppendText(String.Format("\nFuzzy bytes for sector {0}\n", t.sectors[sect].fuzzyData.Count()));
 84 | 						drawBuffer(t.sectors[sect].fuzzyData);
 85 | 					}
 86 | 					if (t.sectors[sect].timmingData != null) {
 87 | 						displayBuffer.AppendText(String.Format("\nTiming values for sector {0}\n", t.sectors[sect].timmingData.Count()));
 88 | 						byte[] timming = new byte[t.sectors[sect].timmingData.Count()];
 89 | 						for (int i = 0; i < t.sectors[sect].timmingData.Count(); i++)
 90 | 							timming[i] = (byte)t.sectors[sect].timmingData[i];
 91 | 						drawBuffer(timming);
 92 | 					}
 93 | 
 94 | 				}
 95 | 				else
 96 | 					displayBuffer.AppendText(" *** Sector has no data ***\n");
 97 | 				displayBuffer.AppendText("\n");
 98 | 			}
 99 | 		}
100 | 
101 | 
102 | 
103 | 
104 | 		/// <summary>
105 | 		/// Display the content of the Track Information in a textbox
106 | 		/// </summary>
107 | 		/// <param name="track">Specifies the track from the disk</param>
108 | 		/// <param name="side">Specifies the side from the disk</param>
109 | 		/// <param name="floppy">The floppy disk structure</param>
110 | 		public void displayTrackBuffer(Floppy floppy, int track, int side) {
111 | 			if (floppy == null) return;
112 | 			Track t = floppy.tracks[track, side];
113 | 			displayBuffer.FontFamily = new FontFamily("Consolas");
114 | 			displayBuffer.FontSize = 16;
115 | 			displayBuffer.FontStyle = FontStyles.Normal;
116 | 			displayBuffer.FontWeight = FontWeights.Normal;
117 | 
118 | 			displayBuffer.AppendText(String.Format("Track {0:D2}.{1} {2} bytes with {3} sectors\n",
119 | 					track, side, t.byteCount, t.sectors.Count()));
120 | 			if (t.trackData != null)
121 | 				drawBuffer(t.trackData);
122 | 			else
123 | 				displayBuffer.AppendText("Track has no Track Image Data Record");
124 | 		}
125 | 
126 | 		/// <summary>
127 | 		/// Display the content of	 TrackBuffer buffer in the displayBuffer TextBox
128 | 		/// </summary>
129 | 		/// <param name="buffer">The buffer to display</param>
130 | 		/// <param name="message">an optional message to display before the buffer</param>
131 | 		public void drawBuffer(byte[] buffer, string message = null) {
132 | 			displayBuffer.FontFamily = new FontFamily("Consolas");
133 | 			displayBuffer.FontSize = 16;
134 | 			displayBuffer.FontStyle = FontStyles.Normal;
135 | 			displayBuffer.FontWeight = FontWeights.Normal;
136 | 			if (message != null)
137 | 				displayBuffer.AppendText(message);
138 | 
139 | 			for (int i = 0; i < buffer.Count(); i += 16) {
140 | 				displayBuffer.AppendText(String.Format("{0:D5}  ", i));
141 | 
142 | 				string ascii = "  ";
143 | 				for (int j = 0; j < 16; j++) {
144 | 					if ((i + j) < buffer.Count()) {
145 | 						displayBuffer.AppendText(String.Format("{0:X2} ", buffer[i + j]));
146 | 						char ch = Convert.ToChar(buffer[i + j]);
147 | 						ascii += Char.IsControl(ch) ? "." : ch.ToString();
148 | 					}
149 | 					else
150 | 						displayBuffer.AppendText(String.Format("   "));
151 | 				}	// one more line
152 | 				displayBuffer.AppendText(ascii);
153 | 				displayBuffer.AppendText(String.Format("\n"));
154 | 			}	// all lines
155 | 		}
156 | 
157 | 	}
158 | }
159 | 


--------------------------------------------------------------------------------
/kfstream/ProcessStream.cs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | @file ProcessStream.cs
  3 | <summary> Process information from the KryoFlux Stream File</summary>
  4 | 
  5 | <div class="jlg">Copyright (C) 2013-2015 Jean Louis-Guerin\n\n
  6 | This file is part of the Atari Universal FD Image Tool project.\n\n
  7 | The Atari Universal FD Image Tool project may be used and distributed without restriction provided
  8 | that this copyright statement is not removed from the file and that any
  9 | derivative work contains the original copyright notice and the associated
 10 | disclaimer.\n\n
 11 | The Atari Universal FD Image Tool project is free software; you can redistribute it
 12 | and/or modify  it under the terms of the GNU General Public License
 13 | as published by the Free Software Foundation; either version 3
 14 | of the License, or (at your option) any later version.\n\n
 15 | The Atari Universal FD Image Tool project is distributed in the hope that it will be useful,
 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n
 18 | See the GNU General Public License for more details.\n\n
 19 | You should have received a copy of the GNU General Public License
 20 | along with the Atari Universal FD Image Tool project; if not, write to the Free Software
 21 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n</div>
 22 | 
 23 | @author Jean Louis-Guerin
 24 | */
 25 | 
 26 | using System;
 27 | using System.Collections.Generic;
 28 | using System.Linq;
 29 | using System.Text;
 30 | using System.Threading;
 31 | using System.Threading.Tasks;
 32 | using System.Windows;
 33 | using System.Windows.Controls;
 34 | 
 35 | using KFStream;
 36 | using KFStreamPackage;
 37 | 
 38 | namespace KFStreamPackage {
 39 | 
 40 | 	/// <summary>
 41 | 	/// The FluxData structure contains the flux transition information
 42 | 	/// </summary>
 43 | 	/// <remarks>
 44 | 	/// This class is used when flux samples file is provided e.g. SCP or KF-RAW file.
 45 | 	/// </remarks>
 46 | 	public class FluxData {
 47 | 		/// <summary>
 48 | 		/// Array of flux transitions recorded for this track (including all revolutions). 
 49 | 		/// </summary>
 50 | 		/// <remarks> The values are stored in nanoseconds</remarks>
 51 | 		public int[] fluxValue;
 52 | 
 53 | 		/// <summary>Total number of flux transitions for ALL revolutions of this track</summary>
 54 | 		public int totalFluxCount;
 55 | 
 56 | 		/// <summary>Value of the shortest flux transition recorded for this track</summary>
 57 | 		/// <remarks> The values is stored in nanoseconds</remarks>
 58 | 		public int minFlux;
 59 | 
 60 | 		/// <summary>Value of the largest flux transition recorded for this track in sample clock</summary>
 61 | 		/// <remarks> The values is stored in nanoseconds</remarks>
 62 | 		public int maxFlux;
 63 | 	}
 64 | 
 65 | 
 66 | 	/// <summary>
 67 | 	/// The FluxDataRev structure contains the information for one revolution of one track 
 68 | 	/// This information is to be used with the FluxData class
 69 | 	/// </summary>
 70 | 	/// <remarks>
 71 | 	/// The FluxDataRev are kept in an array with an entry for each revolution and contains 
 72 | 	/// pointers to information in the FluxData class.
 73 | 	/// </remarks>
 74 | 	public struct FluxDataRev {
 75 | 		/// <summary>
 76 | 		/// The time it takes to complete a revolution in nanoseconds (time between two indexes). 
 77 | 		/// </summary>
 78 | 		public int revolutionTime;
 79 | 
 80 | 		/// <summary>
 81 | 		///  Index in FluxValue array of the first flux for this revolution.
 82 | 		/// </summary>
 83 | 		public int firstFluxIndex;
 84 | 
 85 | 		/// <summary>
 86 | 		/// The number of flux transitions for this revolution.
 87 | 		/// </summary>
 88 | 		public int fluxCount;
 89 | 
 90 | 		/// <summary>Gives the position of the index pulse inside the flux that contains it. The position 
 91 | 		/// before the index signal is given in nanoseconds . Note that in the case of no
 92 | 		/// flux area at the beginning of the track this value can be huge</summary>
 93 | 		public int preIndexTime;
 94 | 	}
 95 | 
 96 | 
 97 | 	/// <summary>
 98 | 	/// Class to Process all KryoFlux Stream files
 99 | 	/// </summary>
100 | 	public class ProcessStream {
101 | 		private FluxData _fluxData;
102 | 		private FluxDataRev[] _fluxDataRev;
103 | 		private KFReader _reader;
104 | 
105 | 		public FluxData Data { get { return _fluxData; }}
106 | 		public FluxDataRev[] Rev { get { return _fluxDataRev; }}
107 | 		public KFReader Reader { get { return _reader; } }
108 | 
109 | 		/// <summary>
110 | 		/// Reads, Parses and fills the FluxData and FluxDataRev structures
111 | 		/// </summary>
112 | 		/// <param name="fileName">Complete name of the stream file to read</param>
113 | 		/// <param name="infoBox">Text box used to display debug information</param>
114 | 		/// <returns>True if file processed without problem; false if error while processing</returns>
115 | 		public StreamStatus readStreamTrack(string fileName, TextBox infoBox) {
116 | 			_reader = new KFReader();
117 | 			StreamStatus status = _reader.readStream(fileName);
118 | 
119 | 			if (status == StreamStatus.sdsOk) {
120 | 				int fluxMin = Int32.MaxValue;
121 | 				int fluxMax = 0;
122 | 				double tick = 1000000000.0 / _reader.SampleClock;
123 | 				double sample = tick;
124 | 				
125 | 				_fluxData = new FluxData();
126 | 				_fluxData.fluxValue = new int[_reader.FluxCount];
127 | 				_fluxData.totalFluxCount = _reader.FluxCount;
128 | 				_fluxDataRev = new FluxDataRev[_reader.IndexCount - 1];
129 | 
130 | 				// convert samples before first index
131 | 				for (int i = 0; i <= _reader.Indexes[0].fluxPosition; i++ )
132 | 					_fluxData.fluxValue[i] = (int)((double)_reader.FluxValues[i] * sample);
133 | 
134 | 				for (int rev = 0; rev < _reader.IndexCount - 1; rev++) {
135 | 					// compute corrected sample clock
136 | 					//sample = 200000000.0 / (double)_reader.Indexes[rev + 1].indexTime;
137 | 					_fluxDataRev[rev].revolutionTime = (int)((double)_reader.Indexes[rev + 1].indexTime * sample);
138 | 					_fluxDataRev[rev].fluxCount = _reader.Indexes[rev + 1].fluxPosition - _reader.Indexes[rev].fluxPosition;
139 | 					int offset = _reader.Indexes[rev].fluxPosition;
140 | 					_fluxDataRev[rev].firstFluxIndex = offset;
141 | 					_fluxDataRev[rev].preIndexTime = (int)((double)_reader.Indexes[rev].preIndexTime * sample);
142 | 
143 | 					for (int f = 0; f < _fluxDataRev[rev].fluxCount; f++) {
144 | 						// convert samples for current revolution
145 | 						_fluxData.fluxValue[offset + f] = (int)((double)_reader.FluxValues[offset + f] * sample);
146 | 						int value = _fluxData.fluxValue[offset + f];
147 | 						if (value > fluxMax) fluxMax = value;
148 | 						if (value < fluxMin) fluxMin = value;
149 | 						if ((double)_reader.Indexes[rev].preIndexTime * sample > 10000.0) {
150 | 							// If we have a large NFA at border of revolution we split at position of the index.
151 | 							if (f == 0)
152 | 								_fluxData.fluxValue[offset + f] -= (int)((double)_reader.Indexes[rev].preIndexTime * sample);
153 | 							else if (f == (_fluxDataRev[rev].fluxCount - 1))
154 | 								_fluxData.fluxValue[offset + f] += (int)((double)(_reader.Indexes[rev].preIndexTime * sample));
155 | 						}	// NFA
156 | 					}	// all flux in current revolution
157 | 				}	// all revolutions
158 | 
159 | 				_fluxData.maxFlux = fluxMax;
160 | 				_fluxData.minFlux = fluxMin;
161 | 			}	// read correctly
162 | 
163 | 			return status;
164 | 		}
165 | 
166 | 		/// <summary>
167 | 		/// This is an asynchronous wrapper of the readTrack() function
168 | 		/// </summary>
169 | 		/// <param name="name">Name of the stream file to read</param>
170 | 		/// <param name="track">Store information for this track</param>
171 | 		/// <param name="side">Store the information for this side</param>
172 | 		/// <returns>True if file processed without problem; false if error while processing</returns>
173 | 		/// See also <see cref="readTrack()"/> function.
174 | 		public Task<StreamStatus> readStreamTrackAsync(string name, TextBox infoBox) {
175 | 			return Task<StreamStatus>.Run(() => readStreamTrack(name, infoBox));
176 | 		}
177 | 
178 | 	}	// streamProcess Class
179 | }	// name space


--------------------------------------------------------------------------------
/pasti/pasti.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{6C747094-3588-42A3-A868-341CC2148933}</ProjectGuid>
  8 |     <OutputType>WinExe</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>pasti</RootNamespace>
 11 |     <AssemblyName>pasti</AssemblyName>
 12 |     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
 13 |     <FileAlignment>512</FileAlignment>
 14 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 15 |     <WarningLevel>4</WarningLevel>
 16 |     <IsWebBootstrapper>true</IsWebBootstrapper>
 17 |     <PublishUrl>ftp://info-coach.fr/atari/software/pc-projects/_utilities/pasti/Publish/</PublishUrl>
 18 |     <Install>true</Install>
 19 |     <InstallFrom>Web</InstallFrom>
 20 |     <UpdateEnabled>true</UpdateEnabled>
 21 |     <UpdateMode>Background</UpdateMode>
 22 |     <UpdateInterval>7</UpdateInterval>
 23 |     <UpdateIntervalUnits>Days</UpdateIntervalUnits>
 24 |     <UpdatePeriodically>false</UpdatePeriodically>
 25 |     <UpdateRequired>false</UpdateRequired>
 26 |     <MapFileExtensions>true</MapFileExtensions>
 27 |     <InstallUrl>http://info-coach.fr/atari/software/pc-projects/_utilities/pasti/Publish/</InstallUrl>
 28 |     <UpdateUrl>http://info-coach.fr/atari/software/pc-projects/_utilities/pasti/Publish/</UpdateUrl>
 29 |     <ProductName>Pasti Reader Writer</ProductName>
 30 |     <PublisherName>DrCoolZic</PublisherName>
 31 |     <SuiteName>AIR</SuiteName>
 32 |     <CreateWebPageOnPublish>true</CreateWebPageOnPublish>
 33 |     <WebPage>publish.html</WebPage>
 34 |     <ApplicationRevision>2</ApplicationRevision>
 35 |     <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
 36 |     <UseApplicationTrust>false</UseApplicationTrust>
 37 |     <PublishWizardCompleted>true</PublishWizardCompleted>
 38 |     <BootstrapperEnabled>true</BootstrapperEnabled>
 39 |   </PropertyGroup>
 40 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 41 |     <PlatformTarget>AnyCPU</PlatformTarget>
 42 |     <DebugSymbols>true</DebugSymbols>
 43 |     <DebugType>full</DebugType>
 44 |     <Optimize>false</Optimize>
 45 |     <OutputPath>bin\Debug\</OutputPath>
 46 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 47 |     <ErrorReport>prompt</ErrorReport>
 48 |     <WarningLevel>4</WarningLevel>
 49 |   </PropertyGroup>
 50 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 51 |     <PlatformTarget>AnyCPU</PlatformTarget>
 52 |     <DebugType>pdbonly</DebugType>
 53 |     <Optimize>true</Optimize>
 54 |     <OutputPath>bin\Release\</OutputPath>
 55 |     <DefineConstants>TRACE</DefineConstants>
 56 |     <ErrorReport>prompt</ErrorReport>
 57 |     <WarningLevel>4</WarningLevel>
 58 |   </PropertyGroup>
 59 |   <PropertyGroup>
 60 |     <ManifestCertificateThumbprint>00B29AB1C93AB667A5E82F34DA242D0F024D07DC</ManifestCertificateThumbprint>
 61 |   </PropertyGroup>
 62 |   <PropertyGroup>
 63 |     <ManifestKeyFile>Pasti_2_TemporaryKey.pfx</ManifestKeyFile>
 64 |   </PropertyGroup>
 65 |   <PropertyGroup>
 66 |     <GenerateManifests>true</GenerateManifests>
 67 |   </PropertyGroup>
 68 |   <PropertyGroup>
 69 |     <SignManifests>true</SignManifests>
 70 |   </PropertyGroup>
 71 |   <PropertyGroup>
 72 |     <SignAssembly>false</SignAssembly>
 73 |   </PropertyGroup>
 74 |   <ItemGroup>
 75 |     <Reference Include="System" />
 76 |     <Reference Include="System.Data" />
 77 |     <Reference Include="System.Xml" />
 78 |     <Reference Include="Microsoft.CSharp" />
 79 |     <Reference Include="System.Core" />
 80 |     <Reference Include="System.Xml.Linq" />
 81 |     <Reference Include="System.Data.DataSetExtensions" />
 82 |     <Reference Include="System.Xaml">
 83 |       <RequiredTargetFramework>4.0</RequiredTargetFramework>
 84 |     </Reference>
 85 |     <Reference Include="WindowsBase" />
 86 |     <Reference Include="PresentationCore" />
 87 |     <Reference Include="PresentationFramework" />
 88 |   </ItemGroup>
 89 |   <ItemGroup>
 90 |     <ApplicationDefinition Include="App.xaml">
 91 |       <Generator>MSBuild:Compile</Generator>
 92 |       <SubType>Designer</SubType>
 93 |     </ApplicationDefinition>
 94 |     <Page Include="BufferWindow.xaml">
 95 |       <SubType>Designer</SubType>
 96 |       <Generator>MSBuild:Compile</Generator>
 97 |     </Page>
 98 |     <Page Include="MainWindow.xaml">
 99 |       <Generator>MSBuild:Compile</Generator>
100 |       <SubType>Designer</SubType>
101 |     </Page>
102 |     <Compile Include="App.xaml.cs">
103 |       <DependentUpon>App.xaml</DependentUpon>
104 |       <SubType>Code</SubType>
105 |     </Compile>
106 |     <Compile Include="BufferWindow.xaml.cs">
107 |       <DependentUpon>BufferWindow.xaml</DependentUpon>
108 |     </Compile>
109 |     <Compile Include="FloppyStruct.cs" />
110 |     <Compile Include="MainWindow.xaml.cs">
111 |       <DependentUpon>MainWindow.xaml</DependentUpon>
112 |       <SubType>Code</SubType>
113 |     </Compile>
114 |   </ItemGroup>
115 |   <ItemGroup>
116 |     <Compile Include="PastiRead.cs" />
117 |     <Compile Include="PastiStruct.cs" />
118 |     <Compile Include="PastiWrite.cs" />
119 |     <Compile Include="Properties\AssemblyInfo.cs">
120 |       <SubType>Code</SubType>
121 |     </Compile>
122 |     <Compile Include="Properties\Resources.Designer.cs">
123 |       <AutoGen>True</AutoGen>
124 |       <DesignTime>True</DesignTime>
125 |       <DependentUpon>Resources.resx</DependentUpon>
126 |     </Compile>
127 |     <Compile Include="Properties\Settings.Designer.cs">
128 |       <AutoGen>True</AutoGen>
129 |       <DependentUpon>Settings.settings</DependentUpon>
130 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
131 |     </Compile>
132 |     <EmbeddedResource Include="Properties\Resources.resx">
133 |       <Generator>ResXFileCodeGenerator</Generator>
134 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
135 |     </EmbeddedResource>
136 |     <None Include="Pasti.dcf" />
137 |     <None Include="pasti.dox" />
138 |     <None Include="Pasti_1_TemporaryKey.pfx" />
139 |     <None Include="Pasti_2_TemporaryKey.pfx" />
140 |     <None Include="pasti_TemporaryKey.pfx" />
141 |     <None Include="Properties\Settings.settings">
142 |       <Generator>SettingsSingleFileGenerator</Generator>
143 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
144 |     </None>
145 |     <AppDesigner Include="Properties\" />
146 |   </ItemGroup>
147 |   <ItemGroup>
148 |     <None Include="App.config" />
149 |   </ItemGroup>
150 |   <ItemGroup>
151 |     <BootstrapperPackage Include=".NETFramework,Version=v4.5">
152 |       <Visible>False</Visible>
153 |       <ProductName>Microsoft .NET Framework 4.5 %28x86 and x64%29</ProductName>
154 |       <Install>true</Install>
155 |     </BootstrapperPackage>
156 |     <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
157 |       <Visible>False</Visible>
158 |       <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
159 |       <Install>false</Install>
160 |     </BootstrapperPackage>
161 |     <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
162 |       <Visible>False</Visible>
163 |       <ProductName>.NET Framework 3.5 SP1</ProductName>
164 |       <Install>false</Install>
165 |     </BootstrapperPackage>
166 |   </ItemGroup>
167 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
168 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
169 |        Other similar extension points exist, see Microsoft.Common.targets.
170 |   <Target Name="BeforeBuild">
171 |   </Target>
172 |   <Target Name="AfterBuild">
173 |   </Target>
174 |   -->
175 | </Project>


--------------------------------------------------------------------------------
/ipf/ipf.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{AA467937-452A-4AE0-AD9D-674EEF0811EB}</ProjectGuid>
  8 |     <OutputType>WinExe</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>ipf</RootNamespace>
 11 |     <AssemblyName>ipf</AssemblyName>
 12 |     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
 13 |     <FileAlignment>512</FileAlignment>
 14 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 15 |     <WarningLevel>4</WarningLevel>
 16 |     <IsWebBootstrapper>true</IsWebBootstrapper>
 17 |     <PublishUrl>ftp://info-coach.fr/atari/software/pc-projects/_utilities/ipf/Publish/</PublishUrl>
 18 |     <Install>true</Install>
 19 |     <InstallFrom>Web</InstallFrom>
 20 |     <UpdateEnabled>false</UpdateEnabled>
 21 |     <UpdateMode>Background</UpdateMode>
 22 |     <UpdateInterval>7</UpdateInterval>
 23 |     <UpdateIntervalUnits>Days</UpdateIntervalUnits>
 24 |     <UpdatePeriodically>false</UpdatePeriodically>
 25 |     <UpdateRequired>false</UpdateRequired>
 26 |     <MapFileExtensions>true</MapFileExtensions>
 27 |     <InstallUrl>http://info-coach.fr/atari/software/pc-projects/_utilities/ipf/Publish/</InstallUrl>
 28 |     <UpdateUrl>http://info-coach.fr/atari/software/pc-projects/_utilities/ipf/Publish/</UpdateUrl>
 29 |     <ProductName>IPF Reader Writer</ProductName>
 30 |     <PublisherName>DrCoolZic</PublisherName>
 31 |     <SuiteName>Air</SuiteName>
 32 |     <CreateWebPageOnPublish>true</CreateWebPageOnPublish>
 33 |     <WebPage>publish.html</WebPage>
 34 |     <ApplicationRevision>9</ApplicationRevision>
 35 |     <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
 36 |     <UseApplicationTrust>false</UseApplicationTrust>
 37 |     <PublishWizardCompleted>true</PublishWizardCompleted>
 38 |     <BootstrapperEnabled>true</BootstrapperEnabled>
 39 |   </PropertyGroup>
 40 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 41 |     <PlatformTarget>AnyCPU</PlatformTarget>
 42 |     <DebugSymbols>true</DebugSymbols>
 43 |     <DebugType>full</DebugType>
 44 |     <Optimize>false</Optimize>
 45 |     <OutputPath>bin\Debug\</OutputPath>
 46 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 47 |     <ErrorReport>prompt</ErrorReport>
 48 |     <WarningLevel>4</WarningLevel>
 49 |   </PropertyGroup>
 50 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 51 |     <PlatformTarget>AnyCPU</PlatformTarget>
 52 |     <DebugType>pdbonly</DebugType>
 53 |     <Optimize>true</Optimize>
 54 |     <OutputPath>bin\Release\</OutputPath>
 55 |     <DefineConstants>TRACE</DefineConstants>
 56 |     <ErrorReport>prompt</ErrorReport>
 57 |     <WarningLevel>4</WarningLevel>
 58 |   </PropertyGroup>
 59 |   <PropertyGroup>
 60 |     <ManifestCertificateThumbprint>259CD416095ABA506BE91C011212602A1F509A2E</ManifestCertificateThumbprint>
 61 |   </PropertyGroup>
 62 |   <PropertyGroup>
 63 |     <ManifestKeyFile>IPF_2_TemporaryKey.pfx</ManifestKeyFile>
 64 |   </PropertyGroup>
 65 |   <PropertyGroup>
 66 |     <GenerateManifests>true</GenerateManifests>
 67 |   </PropertyGroup>
 68 |   <PropertyGroup>
 69 |     <SignManifests>true</SignManifests>
 70 |   </PropertyGroup>
 71 |   <PropertyGroup>
 72 |     <ApplicationIcon>ipf.ico</ApplicationIcon>
 73 |   </PropertyGroup>
 74 |   <ItemGroup>
 75 |     <Reference Include="System" />
 76 |     <Reference Include="System.Data" />
 77 |     <Reference Include="System.Deployment" />
 78 |     <Reference Include="System.Xml" />
 79 |     <Reference Include="Microsoft.CSharp" />
 80 |     <Reference Include="System.Core" />
 81 |     <Reference Include="System.Xml.Linq" />
 82 |     <Reference Include="System.Data.DataSetExtensions" />
 83 |     <Reference Include="System.Xaml">
 84 |       <RequiredTargetFramework>4.0</RequiredTargetFramework>
 85 |     </Reference>
 86 |     <Reference Include="WindowsBase" />
 87 |     <Reference Include="PresentationCore" />
 88 |     <Reference Include="PresentationFramework" />
 89 |   </ItemGroup>
 90 |   <ItemGroup>
 91 |     <ApplicationDefinition Include="App.xaml">
 92 |       <Generator>MSBuild:Compile</Generator>
 93 |       <SubType>Designer</SubType>
 94 |     </ApplicationDefinition>
 95 |     <Page Include="BufferWindow.xaml">
 96 |       <SubType>Designer</SubType>
 97 |       <Generator>MSBuild:Compile</Generator>
 98 |     </Page>
 99 |     <Page Include="MainWindow.xaml">
100 |       <Generator>MSBuild:Compile</Generator>
101 |       <SubType>Designer</SubType>
102 |     </Page>
103 |     <Compile Include="App.xaml.cs">
104 |       <DependentUpon>App.xaml</DependentUpon>
105 |       <SubType>Code</SubType>
106 |     </Compile>
107 |     <Compile Include="BufferWindow.xaml.cs">
108 |       <DependentUpon>BufferWindow.xaml</DependentUpon>
109 |     </Compile>
110 |     <Compile Include="Floppy.cs" />
111 |     <Compile Include="IPFWriter.cs" />
112 |     <Compile Include="utilities.cs" />
113 |     <Compile Include="IPFReader.cs" />
114 |     <Compile Include="IPFStruct.cs" />
115 |     <Compile Include="MainWindow.xaml.cs">
116 |       <DependentUpon>MainWindow.xaml</DependentUpon>
117 |       <SubType>Code</SubType>
118 |     </Compile>
119 |   </ItemGroup>
120 |   <ItemGroup>
121 |     <Compile Include="Properties\AssemblyInfo.cs">
122 |       <SubType>Code</SubType>
123 |     </Compile>
124 |     <Compile Include="Properties\Resources.Designer.cs">
125 |       <AutoGen>True</AutoGen>
126 |       <DesignTime>True</DesignTime>
127 |       <DependentUpon>Resources.resx</DependentUpon>
128 |     </Compile>
129 |     <Compile Include="Properties\Settings.Designer.cs">
130 |       <AutoGen>True</AutoGen>
131 |       <DependentUpon>Settings.settings</DependentUpon>
132 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
133 |     </Compile>
134 |     <EmbeddedResource Include="Properties\Resources.resx">
135 |       <Generator>ResXFileCodeGenerator</Generator>
136 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
137 |     </EmbeddedResource>
138 |     <None Include="ipf.dcf" />
139 |     <None Include="ipf.dox" />
140 |     <None Include="IPF_1_TemporaryKey.pfx" />
141 |     <None Include="IPF_2_TemporaryKey.pfx" />
142 |     <None Include="ipf_TemporaryKey.pfx" />
143 |     <None Include="Properties\Settings.settings">
144 |       <Generator>SettingsSingleFileGenerator</Generator>
145 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
146 |     </None>
147 |     <AppDesigner Include="Properties\" />
148 |   </ItemGroup>
149 |   <ItemGroup>
150 |     <None Include="App.config" />
151 |   </ItemGroup>
152 |   <ItemGroup>
153 |     <BootstrapperPackage Include=".NETFramework,Version=v4.5">
154 |       <Visible>False</Visible>
155 |       <ProductName>Microsoft .NET Framework 4.5 %28x86 and x64%29</ProductName>
156 |       <Install>true</Install>
157 |     </BootstrapperPackage>
158 |     <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
159 |       <Visible>False</Visible>
160 |       <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
161 |       <Install>false</Install>
162 |     </BootstrapperPackage>
163 |     <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
164 |       <Visible>False</Visible>
165 |       <ProductName>.NET Framework 3.5 SP1</ProductName>
166 |       <Install>false</Install>
167 |     </BootstrapperPackage>
168 |   </ItemGroup>
169 |   <ItemGroup>
170 |     <Resource Include="update.png" />
171 |   </ItemGroup>
172 |   <ItemGroup>
173 |     <Resource Include="ipf.ico" />
174 |   </ItemGroup>
175 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
176 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
177 |        Other similar extension points exist, see Microsoft.Common.targets.
178 |   <Target Name="BeforeBuild">
179 |   </Target>
180 |   <Target Name="AfterBuild">
181 |   </Target>
182 |   -->
183 | </Project>


--------------------------------------------------------------------------------
/ipf/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
  1 | using Microsoft.Win32;
  2 | using System;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Text;
  6 | using System.Threading.Tasks;
  7 | using System.Windows;
  8 | using System.Windows.Controls;
  9 | using System.Windows.Data;
 10 | using System.Windows.Documents;
 11 | using System.Windows.Input;
 12 | using System.Windows.Media;
 13 | using System.Windows.Media.Imaging;
 14 | using System.Windows.Navigation;
 15 | using System.Windows.Shapes;
 16 | using System.Deployment.Application;
 17 | using System.IO;
 18 | 
 19 | namespace ipf {
 20 | 	//http://www.thomaslevesque.com/2008/11/18/wpf-binding-to-application-settings-using-a-markup-extension/
 21 | 	public class SettingBindingExtension : Binding {
 22 | 		public SettingBindingExtension() {
 23 | 			Initialize();
 24 | 		}
 25 | 
 26 | 		public SettingBindingExtension(string path)
 27 | 			: base(path) {
 28 | 			Initialize();
 29 | 		}
 30 | 
 31 | 		private void Initialize() {
 32 | 			this.Source = ipf.Properties.Settings.Default;
 33 | 			this.Mode = BindingMode.TwoWay;
 34 | 		}
 35 | 	}
 36 | 
 37 | 	/// <summary>
 38 | 	/// Interaction logic for MainWindow.xaml
 39 | 	/// </summary>
 40 | 	public partial class MainWindow : Window {
 41 | 		Floppy _fd;
 42 | 		BufferWindow _trackWindow = null;
 43 | 		BufferWindow _sectorWindow = null;
 44 | 		bool _trackWindowOpen = false;
 45 | 		bool _sectorWindowOpen = false;
 46 | 
 47 | 		public MainWindow() {
 48 | 			InitializeComponent();
 49 | 			Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
 50 | 			DateTime dateTimeOfBuild = new DateTime(2000, 1, 1)
 51 | 								+ new TimeSpan(version.Build, 0, 0, 0)
 52 | 								+ TimeSpan.FromSeconds(version.Revision * 2);
 53 | 			Title = "IPF File Reader / Writer " + version.Major + "." + version.Minor + " - " + dateTimeOfBuild;
 54 | 		}
 55 | 
 56 | 		private bool checkForUpdate(bool showMessage) {
 57 | 			bool doUpdate = false;
 58 | 			UpdateCheckInfo info = null;
 59 | 
 60 | 			if (ApplicationDeployment.IsNetworkDeployed) {
 61 | 				ApplicationDeployment ad = ApplicationDeployment.CurrentDeployment;
 62 | 
 63 | 				try {
 64 | 					info = ad.CheckForDetailedUpdate();
 65 | 				}
 66 | 				catch (DeploymentDownloadException dde) {
 67 | 					MessageBox.Show("A new version of the application cannot be downloaded at this time. \n\nPlease check your network connection, or try again later. Error: " + dde.Message);
 68 | 					return false;
 69 | 				}
 70 | 				catch (InvalidDeploymentException ide) {
 71 | 					MessageBox.Show("Cannot check for a new version of the application. The ClickOnce deployment is corrupt. Please redeploy the application and try again. Error: " + ide.Message);
 72 | 					return false;
 73 | 				}
 74 | 				catch (InvalidOperationException ioe) {
 75 | 					MessageBox.Show("This application cannot be updated. It is likely not a ClickOnce application. Error: " + ioe.Message);
 76 | 					return false;
 77 | 				}
 78 | 
 79 | 				if (info.UpdateAvailable) {
 80 | 					doUpdate = true;
 81 | 					if (showMessage) {
 82 | 						MessageBoxResult result = MessageBox.Show(
 83 | 							"An update is available. Would you like to update the application now?",
 84 | 							"Update Available", MessageBoxButton.OKCancel, MessageBoxImage.Question, MessageBoxResult.OK);
 85 | 						if (result != MessageBoxResult.OK)
 86 | 							doUpdate = false;
 87 | 					}
 88 | 				}
 89 | 				else
 90 | 					if (showMessage) MessageBox.Show("No Update Available at this time");
 91 | 
 92 | 			}	// network deployed
 93 | 			else
 94 | 				MessageBox.Show("This application is not a ClickOnce application");
 95 | 			return doUpdate;
 96 | 		}
 97 | 
 98 | 
 99 | 		private void InstallUpdate() {
100 | 			ApplicationDeployment ad = ApplicationDeployment.CurrentDeployment;
101 | 			try {
102 | 				ad.Update();
103 | 				MessageBox.Show("The application has been updated and will be restarted");
104 | 				//System.Diagnostics.Process.Start(Application.ResourceAssembly.Location);
105 | 				String ApplicationEntryPoint = ApplicationDeployment.CurrentDeployment.UpdatedApplicationFullName;
106 | 				System.Diagnostics.Process.Start(ApplicationEntryPoint);
107 | 				Application.Current.Shutdown();
108 | 			}
109 | 			catch (DeploymentDownloadException dde) {
110 | 				MessageBox.Show("Cannot install the latest version of the application. \n\nPlease check your network connection, or try again later. Error: " + dde);
111 | 				return;
112 | 			}
113 | 		}
114 | 
115 | 
116 | 		private void btFileClick(object sender, RoutedEventArgs e) {
117 | 			OpenFileDialog ofd = new OpenFileDialog();
118 | 			ofd.Filter = "IPF/IPX file|*.ipf;*ipx|All Files|*.*";
119 | 			bool? ok = ofd.ShowDialog();
120 | 			if (ok == true) {				
121 | 				processFile(ofd.FileName);
122 | 			}			
123 | 		}
124 | 
125 | 
126 | 		private void processFile(string file) {
127 | 			fileName.Text = file;
128 | 			IPFReader ipf = new IPFReader(infoBox, cbDataElem);
129 | 			_fd = new Floppy();
130 | 			ipf.readIPF(file, _fd);
131 | 		}
132 | 
133 | 		private void btWriteClick(object sender, RoutedEventArgs e) {
134 | 			if (_fd == null) {
135 | 				MessageBox.Show("Nothing to write", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
136 | 				return;
137 | 			}
138 | 
139 | 			SaveFileDialog sfd = new SaveFileDialog();
140 | 			sfd.Filter = "IPF file|*.ipf|All Files|*.*";
141 | 
142 | 			bool? ok = sfd.ShowDialog();
143 | 			if (ok == true) {
144 | 				fileName.Text = sfd.FileName;
145 | 				//if (File.Exists(sfd.FileName)) {
146 | 				//	MessageBoxResult result = MessageBox.Show("Do you want to overwrite?", "File already exist", MessageBoxButton.YesNoCancel, MessageBoxImage.Question, MessageBoxResult.No); 
147 | 				//	if (result == MessageBoxResult.Cancel) return;
148 | 				//	if (result == MessageBoxResult.No) goto askOutput;					
149 | 				//}				
150 | 				IPFWriter ipf = new IPFWriter(infoBox);
151 | 				ipf.writeIPF(sfd.FileName, _fd);
152 | 			}
153 | 
154 | 		}
155 | 
156 | 
157 | 		private void btBlocksClick(object sender, RoutedEventArgs e) {
158 | 			if (_fd == null) {
159 | 				tbStatus.Text = "Nothing to display";
160 | 				return;
161 | 			}
162 | 			int trackNumber;
163 | 			int sideNumber;
164 | 			tbStatus.Clear();
165 | 			if (Int32.TryParse(tbTrack.Text, out trackNumber) == false) {
166 | 				tbStatus.Text = "Invalid track number - please correct and try again";
167 | 				return;
168 | 			}
169 | 			if (Int32.TryParse(tbSide.Text, out sideNumber) == false) {
170 | 				tbStatus.Text = "Invalid side number - please correct and try again";
171 | 				return;
172 | 			}
173 | 			if ((trackNumber < 0) || (trackNumber > 84) || (sideNumber < 0) || (sideNumber > 1)) {
174 | 				tbStatus.Text = "Track or Side out of range - please correct and try again";
175 | 				return;
176 | 			}
177 | 
178 | 			if (_sectorWindowOpen)
179 | 				_sectorWindow.Close();
180 | 
181 | 			_sectorWindow = new BufferWindow();
182 | 			_sectorWindow.displayBlocksBuffer(_fd, trackNumber, sideNumber);
183 | 			_sectorWindow.Closed += new EventHandler(sectorWindowClosed);
184 | 			_sectorWindowOpen = true;
185 | 			_sectorWindow.Show();
186 | 
187 | 		}
188 | 
189 | 
190 | 		void sectorWindowClosed(object sender, EventArgs e) {
191 | 			_sectorWindowOpen = false;
192 | 		}
193 | 
194 | 
195 | 		private void mainWinClosing(object sender, System.ComponentModel.CancelEventArgs e) {
196 | 			if (_sectorWindowOpen) _sectorWindow.Close();
197 | 			if (_trackWindowOpen) _trackWindow.Close();
198 | 		}
199 | 
200 | 
201 | 		private void fileDropped(object sender, DragEventArgs e) {
202 | 			string[] droppedFiles = null;
203 | 			if (e.Data.GetDataPresent(DataFormats.FileDrop)) {
204 | 				droppedFiles = e.Data.GetData(DataFormats.FileDrop, true) as string[];
205 | 			}
206 | 
207 | 			if ((null == droppedFiles) || (!droppedFiles.Any())) { return; }
208 | 			processFile(droppedFiles[0]);
209 | 		}
210 | 
211 | 
212 | 		private void dragEnter(object sender, DragEventArgs e) {
213 | 			e.Handled = true;
214 | 		}
215 | 
216 | 
217 | 		private void btUpdateClick(object sender, RoutedEventArgs e) {
218 | 			bool update = checkForUpdate(true);
219 | 			if (update)
220 | 				InstallUpdate();
221 | 		}
222 | 
223 | 		private void writeLogClick(object sender, RoutedEventArgs e) {
224 | 			SaveFileDialog sfd = new SaveFileDialog();
225 | 			//sfd.InitialDirectory = DirectoryName;
226 | 			//sfd.RestoreDirectory = true;
227 | 
228 | 			sfd.Filter = "Text file|*.txt|All Files|*.*";
229 | 			if (sfd.ShowDialog() == true)
230 | 				File.WriteAllText(sfd.FileName, infoBox.Text);
231 | 
232 | 		}
233 | 	}
234 | }
235 | 


--------------------------------------------------------------------------------
/ipf/IPFStruct.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Runtime.InteropServices;
  5 | using System.Text;
  6 | using System.Threading.Tasks;
  7 | 
  8 | namespace ipf {
  9 | 	/// <summary>Type of media imaged</summary>
 10 | 	public enum MediaType : uint { Unknown, Floppy_Disk };
 11 | 
 12 | 	/// <summary>Image encoder Type</summary>
 13 | 	public enum EncoderType : uint { Unknown, CAPS, SPS };
 14 | 
 15 | 	/// <summary>Platform on which the image can be run</summary>
 16 | 	/// <remarks>Platform can take the following values:
 17 | 	/// - 01 = Amiga
 18 | 	/// - 02 = Atari ST
 19 | 	/// - 03 = PC
 20 | 	/// - 04 = Amstrad CPC
 21 | 	/// - 05 = Spectrum
 22 | 	/// - 06 = Sam Coupe
 23 | 	/// - 07 = Archimedes
 24 | 	/// - 08 = C64
 25 | 	/// - 09 = Atari 8bit
 26 | 	/// </remarks>
 27 | 	public enum Platform : uint {
 28 | 		Unknown, Amiga, Atari_ST, PC, Amstrad_CPC, Spectrum, Sam_Coupe, Archimedes, C64, Atari_8bit
 29 | 	}
 30 | 
 31 | 	/// <summary>The cell density for this track</summary>
 32 | 	public enum Density : uint {
 33 | 		Unknown, Noise, Auto, Copylock_Amiga, Copylock_Amiga_New, Copylock_ST, Speedlock_Amiga,
 34 | 		Speedlock_Amiga_Old, Adam_Brierley_Amiga, Adam_Brierley_Key_Amiga
 35 | 	}
 36 | 
 37 | 	/// <summary>Signal Processing Type</summary>
 38 | 	public enum SignalType : uint { Unknown, cell_2us }
 39 | 
 40 | 	/// <summary>Flags for the track</summary>
 41 | 	[Flags]
 42 | 	public enum TrackFlags : uint {
 43 | 		None = 0x0,
 44 | 		Fuzzy = 0x1
 45 | 	}
 46 | 
 47 | 	/// <summary>Block Encoder Type</summary>
 48 | 	public enum BlockEncoderType : uint { Unknown, MFM, RAW }
 49 | 
 50 | 
 51 | 	/// <summary>Flags for a block descriptor</summary>
 52 | 	[Flags]
 53 | 	public enum BlockFlags : uint {
 54 | 		None = 0x00,
 55 | 		FwGap = 0x01,
 56 | 		BwGap = 0x02,
 57 | 		DataInBit = 0x04
 58 | 	}
 59 | 	
 60 | 	// Flags
 61 | 	// https://msdn.microsoft.com/fr-fr/library/cc138362.aspx
 62 | 	//if ((bd.blockFlags & BlockFlags.BwGap) == BlockFlags.BwGap) {
 63 | 	//if (bd.blockFlags.HasFlag(BlockFlags.BwGap)) {
 64 | 	//if(bd.blockFlags.Equals(BlockFlags.None))
 65 | 
 66 | 
 67 | 	/// <summary>Type of Data in data element</summary>
 68 | 	public enum DataType : uint { Unknown, Sync, Data, IGap, Raw, Fuzzy }
 69 | 
 70 | 	/// <summary>Type of a gap element</summary>
 71 | 	public enum GapType : uint { Unknown, Forward, Backward }
 72 | 
 73 | 	/// <summary>Type of information in a gap element</summary>
 74 | 	public enum GapElemType { Unknown, GapLength, SampleLength }
 75 | 
 76 | 	/// <summary>IPF record Header Descriptor</summary>
 77 | 	/// <remarks>Each record in IPF file starts with a record header</remarks>
 78 | 	public class RecordHeader {
 79 | 		/// <summary>Identify the record</summary>
 80 | 		public char[] type = new char[4];
 81 | 
 82 | 		/// <summary>Length of the record</summary>
 83 | 		public uint length;
 84 | 
 85 | 		/// <summary>CRC32 for the complete record</summary>
 86 | 		public uint crc;
 87 | 
 88 | 		/// <summary>Override ToString() to display record header info</summary>
 89 | 		/// <returns>The record header string</returns>
 90 | 		public override string ToString() {
 91 | 			return String.Format("Record={0} Size={1} CRC={2:X8}",
 92 | 				new string(type), length, crc);
 93 | 		}
 94 | 	}	// RecordHeader
 95 | 
 96 | 
 97 | 	/// <summary>
 98 | 	/// The info record definition
 99 | 	/// </summary>
100 | 	public class InfoRecord {
101 | 		/// <summary>Type of media imaged</summary>
102 | 		/// <remarks> The only type currently recognized is floppy disks (value=1)</remarks>
103 | 		public MediaType mediaType;
104 | 
105 | 		/// <summary>image encoder type</summary>
106 | 		/// <remarks>Depending on the encoder ID some fields in the IMGE records are interpreted differently. 
107 | 		/// Currently this field can take the following values: 01 = CAPS encoder or 02 = SPS encoder
108 | 		/// </remarks>
109 | 		public EncoderType encoderType;
110 | 
111 | 		/// <summary> Image encoder revision </summary>
112 | 		/// <remarks>Currently only revision 1 exists for CAPS or SPS encoders</remarks>
113 | 		public uint encoderRev;
114 | 
115 | 		/// <summary>
116 | 		/// Each IPF file has a unique ID that can be used as a unique key for database
117 | 		/// </summary>
118 | 		/// <remarks>More than one file can have the same Key for example for a game that has more than one disk.</remarks>
119 | 		public uint fileKey;
120 | 
121 | 		/// <summary>Revision of the file.</summary>
122 | 		/// <remarks>Normally the revision is one</remarks>
123 | 		public uint fileRev;
124 | 
125 | 		/// <summary>Reference to original source</summary>
126 | 		public uint origin;
127 | 
128 | 		/// <summary>The first track number of the floppy image. </summary>
129 | 		/// <remarks>Usually 0</remarks>
130 | 		public uint minTrack;
131 | 
132 | 		/// <summary>The last track number of the floppy image.</summary>
133 | 		/// <remarks>Usually 83</remarks>
134 | 		public uint maxTrack;
135 | 
136 | 		/// <summary>The lowest head (side) number of the floppy image.</summary>
137 | 		/// <remarks>Usually 0</remarks>
138 | 		public uint minSide;
139 | 
140 | 		/// <summary>The highest head (side) number of the floppy image. Usually 1</summary>
141 | 		public uint maxSide;
142 | 
143 | 		/// <summary>The image creation date: Specify the year, the month, the day</summary>
144 | 		/// <remarks>the date is packed into a 4 bytes integers. </remarks>
145 | 		public uint creationDate;
146 | 
147 | 		/// <summary>The image creation time: Specify the hour, the minute, the second, and the tick</summary>
148 | 		///  <remarks>the time is packed into a 4 bytes integers.</remarks>  
149 | 		public uint creationTime;
150 | 
151 | 		/// <summary>Array of four possible platforms</summary>
152 | 		/// <remarks>This array contains 4 values that identifies on which platforms the image can be run
153 | 		/// (one image can be run on several platform).</remarks>
154 | 		public Platform[] platforms = new Platform[4];
155 | 
156 | 		/// <summary>Number of the disk in a multi-disc release otherwise 0</summary>
157 | 		public uint diskNumber;
158 | 
159 | 		/// <summary>A unique user ID of the disk image creator</summary>
160 | 		public uint creatorId;
161 | 
162 | 		/// <summary>reserved for future</summary>
163 | 		public uint[] reserved = new uint[3];
164 | 
165 | 
166 | 		/// <summary>Override ToString() to display info record content</summary>
167 | 		/// <returns>The record header string</returns>
168 | 		public override string ToString() {
169 | 			string date = String.Format("{0:D2}/{1:D2}/{2:D2}", creationDate / 10000, (creationDate/100) % 100, creationDate % 100);
170 | 			string time = String.Format("{0:D2}:{1:D2}:{2:D2}.{3:D3}", creationTime/10000000, (creationTime/100000) % 100, 
171 | 				(creationTime/1000)%100, creationTime % 1000);
172 | 			string pstring = null;
173 | 			foreach (Platform p in platforms)
174 | 				if (p != 0) pstring += (p.ToString() + " ");
175 | 
176 | 			return String.Format(
177 | 					"   Type={0} Encoder={1}(V{2}) File={3}(V{4}) Disk={5} Origin={6:X8} Creator={7:X8}\n" +
178 | 					"   Track={8:D2}-{9:D2} Side={10}-{11} Date={12} Time={13} Platforms={14}\n",
179 | 					mediaType.ToString(), encoderType.ToString(), encoderRev, fileKey, fileRev, diskNumber, origin,
180 | 					creatorId, minTrack, maxTrack, minSide, maxSide, date, time, pstring);
181 | 		}
182 | 	}
183 | 
184 | 	/// <summary>
185 | 	/// The image record definition
186 | 	/// </summary>
187 | 	public class ImageRecord {
188 | 		public uint track;
189 | 		public uint side;
190 | 		public Density density;
191 | 		public SignalType signalType;
192 | 		public uint trackBytes;
193 | 		public uint startBytePos;
194 | 		public uint startBitPos;
195 | 		public uint dataBits;
196 | 		public uint gapBits;
197 | 		public uint trackBits;
198 | 		public uint blockCount;
199 | 		public uint encoder;
200 | 		public TrackFlags trackFlags;
201 | 		public uint dataKey;
202 | 		/// <summary>reserved for future</summary>
203 | 		public uint[] reserved = new uint[3];
204 | 
205 | 		/// <summary>Override ToString() to display Image record content</summary>
206 | 		/// <returns>The record header string</returns>
207 | 		public override string ToString() {
208 | 			return String.Format(
209 | 				"   T{0:D2}.{1} Size={2} bytes ({3} bits = Data={4} + Gap={5}) Start Byte={6} Bit={7}\n" +
210 | 				"   DataKey={8:D3} Block={9} Density={10} Signal={11} Encoder={12} Flags={13}\n",
211 | 				track, side, trackBytes, trackBits, dataBits, gapBits, startBytePos, startBitPos,
212 | 				dataKey, blockCount, density.ToString(), signalType.ToString(), encoder, trackFlags.ToString());
213 | 		}
214 | 	}
215 | 
216 | 
217 | 	/// <summary>
218 | 	/// The Data record definition
219 | 	/// </summary>
220 | 	public class DataRecord {
221 | 		public uint length;
222 | 		public uint bitSize;
223 | 		public uint crc;
224 | 		public uint key;
225 | 		public override string ToString() {
226 | 			return String.Format("== DataKey={0:D3} Length={1} bytes bitSize={2} bits CRC={3:X8}",
227 | 				key, length, bitSize, crc);
228 | 		}
229 | 	}
230 | 
231 | 
232 | 	/// <summary>
233 | 	/// Block descriptor definition
234 | 	/// </summary>
235 | 	/// <remarks>We use explicit position for an equivalent of union in C++</remarks>
236 | 	[StructLayout(LayoutKind.Explicit)]
237 | 	public struct BlockDescriptor {
238 | 		[FieldOffset(0)]
239 | 		public uint dataBits;
240 | 		[FieldOffset(4)]
241 | 		public uint gapBits;
242 | 
243 | 		[FieldOffset(8)]	// CAPS
244 | 		public uint dataBytes;
245 | 		[FieldOffset(12)]
246 | 		public uint gapBytes;
247 | 
248 | 		[FieldOffset(8)]	// SPS
249 | 		public uint gapOffset;
250 | 		[FieldOffset(12)]
251 | 		public SignalType cellType;
252 | 
253 | 		[FieldOffset(16)]
254 | 		public BlockEncoderType encoderType;
255 | 		[FieldOffset(20)]
256 | 		public BlockFlags blockFlags;
257 | 		[FieldOffset(24)]
258 | 		public uint gapDefaultValue;
259 | 		[FieldOffset(28)]
260 | 		public uint dataOffset;
261 | 	}
262 | 
263 | 
264 | 	public class CteiRecord {
265 | 		public uint releaseCrc;
266 | 		public uint analyzerRev;
267 | 		public uint[] reserved = new uint[14];
268 | 		public override string ToString() {
269 | 			return String.Format("   Associated IPF CRC={0:X8}  Analyzer revision={1}\n",
270 | 				releaseCrc, analyzerRev);
271 | 		}
272 | 	}
273 | 
274 | 
275 | 	public class CtexRecord {
276 | 		public uint track;
277 | 		public uint side;
278 | 		public Density density;
279 | 		public uint formatId;
280 | 		public uint fix;
281 | 		public uint trackSize;
282 | 		public uint[] reserved = new uint[2];
283 | 		public override string ToString() {
284 | 			return String.Format("   T{0:D2}.{1} Density={2} Format={3} Fix={4} TrackSize={5}\n",
285 | 				track, side, density.ToString(), formatId, fix, trackSize);
286 | 		}
287 | 	}
288 | 
289 |  
290 | }
291 | 


--------------------------------------------------------------------------------
/pasti/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | @file MainWindow.xaml.cs
  3 | <summary>Main WPF window to call the reader</summary>
  4 | 
  5 | <div class="jlg">Copyright (C) 2014 Jean Louis-Guerin\n\n
  6 | This file is part of the Atari Image Reader (AIR) project.\n
  7 | The Atari Image Reader project may be used and distributed without restriction provided
  8 | that this copyright statement is not removed from the file and that any
  9 | derivative work contains the original copyright notice and the associated
 10 | disclaimer.\n
 11 | The Atari Image Reader project is free software; you can redistribute it
 12 | and/or modify  it under the terms of the GNU General Public License
 13 | as published by the Free Software Foundation; either version 2
 14 | of the License, or (at your option) any later version.\n
 15 | The Atari Image Reader project is distributed in the hope that it will be useful,
 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 18 | See the GNU General Public License for more details.\n\n
 19 | You should have received a copy of the GNU General Public License
 20 | along with the Atari Universal FD Image Tool project; if not, write to the Free Software
 21 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n</div>
 22 | 
 23 | @author Jean Louis-Guerin
 24 | */
 25 | 
 26 | using Microsoft.Win32;
 27 | using System;
 28 | using System.Collections.Generic;
 29 | using System.IO;
 30 | using System.Linq;
 31 | using System.Text;
 32 | using System.Threading.Tasks;
 33 | using System.Windows;
 34 | using System.Windows.Controls;
 35 | using System.Windows.Data;
 36 | using System.Windows.Documents;
 37 | using System.Windows.Input;
 38 | using System.Windows.Media;
 39 | using System.Windows.Media.Imaging;
 40 | using System.Windows.Navigation;
 41 | using System.Windows.Shapes;
 42 | 
 43 | namespace Pasti {
 44 | 	/// <summary>
 45 | 	/// Interaction logic for MainWindow.xaml
 46 | 	/// </summary>
 47 | 	public partial class MainWindow : Window {
 48 | 		Floppy _fd;
 49 | 		BufferWindow _trackWindow = null;
 50 | 		BufferWindow _sectorWindow = null;
 51 | 		bool _trackWindowOpen = false;
 52 | 		bool _sectorWindowOpen = false;
 53 | 
 54 | 		public MainWindow() {
 55 | 			InitializeComponent();
 56 | 			//string version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
 57 | 			Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
 58 | 			DateTime dateTimeOfBuild = new DateTime(2000, 1, 1)
 59 | 								+ new TimeSpan(version.Build, 0, 0, 0)
 60 | 								+ TimeSpan.FromSeconds(version.Revision * 2);
 61 | 			Title = "Pasti STX File Reader-Writer " + version.Major + "." + version.Minor + " - " + dateTimeOfBuild;
 62 | 		}
 63 | 
 64 | 
 65 | 		private void btFileClick(object sender, RoutedEventArgs e) {
 66 | 			OpenFileDialog ofd = new OpenFileDialog();
 67 | 			ofd.Filter = "Pasti file|*.stx|All Files|*.*";
 68 | 			bool? ok = ofd.ShowDialog();
 69 | 			if (ok == true) {
 70 | 				processFile(ofd.FileName);
 71 | 			}
 72 | 		}
 73 | 
 74 | 
 75 | 		private void processFile(string file) {
 76 | 			PastiReader pasti = new PastiReader(infoBox);
 77 | 			_fd = new Floppy();
 78 | 			fileName.Text = file;
 79 | 			pasti.readPasti(file, _fd);
 80 | 		}
 81 | 
 82 | 
 83 | 
 84 | 		private void btWriteClick(object sender, RoutedEventArgs e) {
 85 | 
 86 | 			if (_fd == null) {
 87 | 				MessageBox.Show("Nothing to write", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
 88 | 				return;
 89 | 			}
 90 | 
 91 | 			SaveFileDialog sfd = new SaveFileDialog();
 92 | 			sfd.Filter = "Pasti file|*.stx|All Files|*.*";
 93 | 			//			askOutput:
 94 | 
 95 | 			bool? ok = sfd.ShowDialog();
 96 | 			if (ok == true) {
 97 | 				fileName.Text = sfd.FileName;
 98 | 				//if (File.Exists(sfd.FileName)) {
 99 | 				//	MessageBoxResult result = MessageBox.Show("Do you want to overwrite?", "File already exist", MessageBoxButton.YesNoCancel, MessageBoxImage.Question, MessageBoxResult.No); 
100 | 				//	if (result == MessageBoxResult.Cancel) return;
101 | 				//	if (result == MessageBoxResult.No) goto askOutput;					
102 | 				//}				
103 | 				PastiWriter pasti = new PastiWriter(infoBox);
104 | 				pasti.writePasti(sfd.FileName, _fd);
105 | 			}
106 | 		}
107 | 
108 | 		private void btTrackClick(object sender, RoutedEventArgs e) {
109 | 			if (_fd == null) {
110 | 				tbStatus.Text = "Nothing to display";
111 | 				return;
112 | 			}
113 | 			int trackNumber;
114 | 			int sideNumber;
115 | 			tbStatus.Clear();
116 | 			if (Int32.TryParse(tbTrack.Text, out trackNumber) == false)
117 | 				tbStatus.Text = "Invalid track number - please correct and try again";
118 | 			if (Int32.TryParse(tbSide.Text, out sideNumber) == false)
119 | 				tbStatus.Text = "Invalid side number - please correct and try again";
120 | 
121 | 			if ((trackNumber < 0) || (trackNumber > 84) || (sideNumber < 0) || (sideNumber > 1))
122 | 				tbStatus.Text = "Track or Side out of range - please correct and try again";
123 | 			if (_fd == null)
124 | 				tbStatus.Text = "Nothing to display";
125 | 
126 | 			if (_trackWindowOpen)
127 | 				_trackWindow.Close();
128 | 
129 | 			_trackWindow = new BufferWindow();
130 | 			_trackWindow.displayTrackBuffer(_fd, trackNumber, sideNumber);
131 | 			_trackWindow.Closed += new EventHandler(trackWindowClosed);
132 | 			_trackWindowOpen = true;
133 | 			_trackWindow.Show();
134 | 		}
135 | 
136 | 		void trackWindowClosed(object sender, EventArgs e) {
137 | 			_trackWindowOpen = false;
138 | 		}
139 | 
140 | 
141 | 		private void btSectorsClick(object sender, RoutedEventArgs e) {
142 | 			if (_fd == null) {
143 | 				tbStatus.Text = "Nothing to display";
144 | 				return;
145 | 			}
146 | 			int trackNumber;
147 | 			int sideNumber;
148 | 			tbStatus.Clear();
149 | 			if (Int32.TryParse(tbTrack.Text, out trackNumber) == false)
150 | 				tbStatus.Text = "Invalid track number - please correct and try again";
151 | 			if (Int32.TryParse(tbSide.Text, out sideNumber) == false)
152 | 				tbStatus.Text = "Invalid side number - please correct and try again";
153 | 
154 | 			if ((trackNumber < 0) || (trackNumber > 84) || (sideNumber < 0) || (sideNumber > 1))
155 | 				tbStatus.Text = "Track or Side out of range - please correct and try again";
156 | 			if (_fd == null)
157 | 				tbStatus.Text = "Nothing to display";
158 | 
159 | 			if (_sectorWindowOpen)
160 | 				_sectorWindow.Close();
161 | 
162 | 			_sectorWindow = new BufferWindow();
163 | 			_sectorWindow.displaySectorBuffer(_fd, trackNumber, sideNumber);
164 | 			_sectorWindow.Closed += new EventHandler(sectorWindowClosed);
165 | 			_sectorWindowOpen = true;
166 | 			_sectorWindow.Show();
167 | 		}
168 | 
169 | 
170 | 		void sectorWindowClosed(object sender, EventArgs e) {
171 | 			_sectorWindowOpen = false;
172 | 		}
173 | 
174 | 
175 | 		private void btAllSectorsClick(object sender, RoutedEventArgs e) {
176 | 			tbStatus.Clear();
177 | 			if (_fd == null) {
178 | 				tbStatus.Text = "Nothing to display";
179 | 				return;
180 | 			}
181 | 
182 | 			SaveFileDialog sfd = new SaveFileDialog();
183 | 			sfd.Filter = "Text file|*.txt|All Files|*.*";
184 | 			if (sfd.ShowDialog() == true) {
185 | 				displayAllSectorBuffer(_fd, sfd.FileName);
186 | 			}
187 | 
188 | 
189 | 		}
190 | 
191 | 		/// <summary>
192 | 		/// Display all the sectors
193 | 		/// </summary>
194 | 		/// <param name="floppy">Contains the DB</param>
195 | 		/// <param name="filename">The name of the open file</param>
196 | 		public void displayAllSectorBuffer(Floppy floppy, string filename) {
197 | 			StringBuilder sb = new StringBuilder();
198 | 
199 | 			for (int track = 0; track < 84; track++) {
200 | 				for (int side = 0; side < 2; side++) {
201 | 					Track t = floppy.tracks[track, side];
202 | 					if (t == null) continue;
203 | 
204 | 					sb.Append(String.Format("Track {0:D2}.{1} has {2} sectors\n", track, side, t.sectorCount));
205 | 					for (int sect = 0; sect < t.sectorCount; sect++) {
206 | 						sb.Append(String.Format("Sector {0}", t.sectors[sect].id.number));
207 | 						sb.Append(String.Format(" T={0} H={1} N={2} S={3} CRC={4:X4}",
208 | 							t.sectors[sect].id.track, t.sectors[sect].id.side, t.sectors[sect].id.number, t.sectors[sect].id.size, t.sectors[sect].id.crc));
209 | 
210 | 						if (t.sectors[sect].sectorData != null) {
211 | 							sb.Append(String.Format(" has {0} bytes\n", t.sectors[sect].sectorData.Count()));
212 | 							sb.Append(String.Format("       bitPosition {0}, Flags {1:X2}", t.sectors[sect].bitPosition, t.sectors[sect].fdcFlags));
213 | 							sb.Append(String.Format(" {0} {1}\n", ((t.sectors[sect].fdcFlags & SectorDesc.CRC_ERR) == 0) ?
214 | 								"Good CRC" : "Bad CRC", (t.sectors[sect].fuzzyData != null) ? "Has Fuzzy bytes" : ""));
215 | 							saveBuffer(t.sectors[sect].sectorData, sb);
216 | 							if (t.sectors[sect].fuzzyData != null) {
217 | 								sb.Append(String.Format("\nFuzzy bytes for sector {0}\n", t.sectors[sect].fuzzyData.Count()));
218 | 								saveBuffer(t.sectors[sect].fuzzyData, sb);
219 | 							}
220 | 							if (t.sectors[sect].timmingData != null) {
221 | 								sb.Append(String.Format("\nTiming values for sector {0}\n", t.sectors[sect].timmingData.Count()));
222 | 								byte[] timming = new byte[t.sectors[sect].timmingData.Count()];
223 | 								for (int i = 0; i < t.sectors[sect].timmingData.Count(); i++)
224 | 									timming[i] = (byte)t.sectors[sect].timmingData[i];
225 | 								saveBuffer(timming, sb);
226 | 							}
227 | 
228 | 						}
229 | 						else
230 | 							sb.Append(" *** Sector has no data ***\n");
231 | 						sb.Append("\n");
232 | 					}
233 | 				}
234 | 			}
235 | 			using (StreamWriter outputfile = new StreamWriter(filename)) {
236 | 				outputfile.Write(sb.ToString());
237 | 			}
238 | 		}
239 | 
240 | 
241 | 		/// <summary>
242 | 		/// Save the content of the buffer
243 | 		/// </summary>
244 | 		/// <param name="buffer">Buffer to save</param>
245 | 		/// <param name="sb">Save in a string builder</param>
246 | 		public void saveBuffer(byte[] buffer, StringBuilder sb) {
247 | 			for (int i = 0; i < buffer.Count(); i += 16) {
248 | 				sb.Append(String.Format("{0:D5}  ", i));
249 | 
250 | 				string ascii = "  ";
251 | 				for (int j = 0; j < 16; j++) {
252 | 					if ((i + j) < buffer.Count()) {
253 | 						sb.Append(String.Format("{0:X2} ", buffer[i + j]));
254 | 						char ch = Convert.ToChar(buffer[i + j]);
255 | 						ascii += Char.IsControl(ch) ? "." : ch.ToString();
256 | 					}
257 | 					else
258 | 						sb.Append(String.Format("   "));
259 | 				}	// one more line
260 | 				sb.Append(ascii);
261 | 				sb.Append(String.Format("\n"));
262 | 			}	// all lines
263 | 		}
264 | 
265 | 
266 | 		private void fileDrop(object sender, DragEventArgs e) {
267 | 			string[] droppedFiles = null;
268 | 			if (e.Data.GetDataPresent(DataFormats.FileDrop)) {
269 | 				droppedFiles = e.Data.GetData(DataFormats.FileDrop, true) as string[];
270 | 			}
271 | 
272 | 			if ((null == droppedFiles) || (!droppedFiles.Any())) { return; }
273 | 			processFile(droppedFiles[0]);
274 | 		}
275 | 
276 | 
277 | 		private void dragEnter(object sender, DragEventArgs e) {
278 | 			e.Handled = true;
279 | 		}
280 | 
281 | 	}
282 | }
283 | 


--------------------------------------------------------------------------------
/ipf/IPFWriter.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.IO;
  5 | using System.Linq;
  6 | using System.Text;
  7 | using System.Threading.Tasks;
  8 | using System.Windows.Controls;
  9 | 
 10 | namespace ipf {
 11 | 	class IPFWriter {
 12 | 		private TextBox _infoBox;
 13 | 
 14 | 		/// <summary>
 15 | 		/// The IPF Writer Constructor
 16 | 		/// </summary>
 17 | 		/// <param name="tb">The TextBox used to display information</param>
 18 | 		public IPFWriter(TextBox tb) {
 19 | 			_infoBox = tb;
 20 | 		}
 21 | 
 22 | 
 23 | 		/// <summary>
 24 | 		/// Write an IPF file from the Floppy structure
 25 | 		/// </summary>
 26 | 		/// <param name="fileName">Name of the Pasti file to read</param>
 27 | 		/// <param name="fd">the Floppy parameter</param>
 28 | 		/// <returns>The status</returns>
 29 | 		public bool writeIPF(string fileName, Floppy fd) {
 30 | 			FileStream fs;
 31 | 
 32 | 			// encode file into buffer
 33 | 			List<byte> buffer = new List<byte>();
 34 | 			bool status = encodeIPF(buffer, fd);
 35 | 
 36 | 			try {
 37 | 				fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Read);
 38 | 			}
 39 | 			catch (Exception exc) {
 40 | 				Console.WriteLine("Error: {0}", exc.Message);
 41 | 				return false;
 42 | 			}
 43 | 			fs.Write(buffer.ToArray(), 0, buffer.Count);
 44 | 			fs.Close();
 45 | 
 46 | 			return status;
 47 | 		}
 48 | 
 49 | 		
 50 | 		private bool encodeIPF(List<byte> buffer, Floppy fd) {
 51 | 			uint crc;
 52 | 			int start;
 53 | 			int crc_pos;
 54 | 
 55 | 			// write CAPS Record
 56 | 			start = buffer.Count;
 57 | 			writeByte(buffer, (byte)'C');			// File header
 58 | 			writeByte(buffer, (byte)'A');
 59 | 			writeByte(buffer, (byte)'P');
 60 | 			writeByte(buffer, (byte)'S');
 61 | 			writeInt32(buffer, 12);					// record length
 62 | 			crc_pos = buffer.Count;
 63 | 			writeInt32(buffer, 0);					// CRC
 64 | 
 65 | 			crc = Utilities.crc32Buffer(buffer, 0, 12);
 66 | 			writeInt32(buffer, crc_pos, crc);
 67 | 
 68 | 			// in real life creating an info record may look like the commented code below
 69 | 
 70 | 			//DateTime now = DateTime.Now;
 71 | 			//int date = now.Year * 10000 + now.Month * 100 + now.Day;
 72 | 			//int time = now.Hour * 10000000 + now.Minute * 100000 + now.Second * 1000 + now.Millisecond;
 73 | 
 74 | 			//InfoRecord info = new InfoRecord();
 75 | 			//info.mediaType = MediaType.Floppy_Disk;
 76 | 			//info.encoderType = EncoderType.SPS;
 77 | 			//info.encoderRev = 1;
 78 | 			//info.fileKey = 0;
 79 | 			//info.fileRev = 1;
 80 | 			//info.origin = 0;
 81 | 			//info.minTrack = 0;
 82 | 			//info.maxTrack = 83;
 83 | 			//info.minSide = 0;
 84 | 			//info.maxSide = 1;
 85 | 			//info.creationDate = (uint)date;
 86 | 			//info.creationTime = (uint)time;
 87 | 			//info.platforms = new Platform[4];
 88 | 			//info.platforms[0] = Platform.Atari_ST;
 89 | 			//info.diskNumber = 1;
 90 | 			//info.creatorId = 0xAFAFAFAF;
 91 | 			//info.reserved = new uint[3];
 92 | 
 93 | 			// but to compare with original ipf file we just reuse the same content
 94 | 			InfoRecord info = fd.info;
 95 | 
 96 | 			// Write INFO Record
 97 | 			start = buffer.Count;
 98 | 			writeByte(buffer, (byte)'I');			// File header
 99 | 			writeByte(buffer, (byte)'N');
100 | 			writeByte(buffer, (byte)'F');
101 | 			writeByte(buffer, (byte)'O');
102 | 			writeInt32(buffer, 96);					// record length
103 | 			crc_pos = buffer.Count;
104 | 			writeInt32(buffer, 0);					// CRC
105 | 
106 | 			writeInt32(buffer, (uint)info.mediaType);
107 | 			writeInt32(buffer, (uint)info.encoderType);
108 | 			writeInt32(buffer, info.encoderRev);
109 | 			writeInt32(buffer, info.fileKey);
110 | 			writeInt32(buffer, info.fileRev);
111 | 			writeInt32(buffer, info.origin);
112 | 			writeInt32(buffer, info.minTrack);
113 | 			writeInt32(buffer, info.maxTrack);
114 | 			writeInt32(buffer, info.minSide);
115 | 			writeInt32(buffer, info.maxSide);
116 | 			writeInt32(buffer, info.creationDate);
117 | 			writeInt32(buffer, info.creationTime);
118 | 			for (int i = 0; i < 4; i++)
119 | 				writeInt32(buffer, (uint)info.platforms[i]);
120 | 			writeInt32(buffer, info.diskNumber);
121 | 			writeInt32(buffer, info.creatorId);
122 | 			for (int i = 0; i < 3; i++)
123 | 				writeInt32(buffer, info.reserved[i]);
124 | 
125 | 			crc = Utilities.crc32Buffer(buffer, start, 96);
126 | 			writeInt32(buffer, crc_pos, crc);
127 | 
128 | 			// write IMGE record
129 | 			uint dataKey = 1;
130 | 			for (uint track = 0; track < 84; track++) {
131 | 				for (uint side = 0; side < 2; side++) {
132 | 					Track t = fd.tracks[track, side];
133 | 					if (t == null) continue;
134 | 
135 | 					ImageRecord image = new ImageRecord();
136 | 					image.track = track;
137 | 					image.side = side;
138 | 					image.density = t.density;
139 | 					image.signalType = SignalType.cell_2us;
140 | 					image.trackBytes = t.trackBytes;
141 | 					image.startBytePos = t.startBitPos / 8;
142 | 					image.startBitPos = t.startBitPos;
143 | 					image.dataBits = t.dataBits;
144 | 					image.gapBits = t.gapBits;
145 | 					image.trackBits = t.dataBits + t.gapBits;
146 | 					image.blockCount = t.blockCount;
147 | 					image.encoder = 0;
148 | 					image.trackFlags = t.trackFlags;
149 | 					image.dataKey = dataKey++;
150 | 					image.reserved = new uint[4];
151 | 
152 | 					// Write IMGE Record
153 | 					start = buffer.Count;
154 | 					writeByte(buffer, (byte)'I');			// File header
155 | 					writeByte(buffer, (byte)'M');
156 | 					writeByte(buffer, (byte)'G');
157 | 					writeByte(buffer, (byte)'E');
158 | 					writeInt32(buffer, 80);
159 | 					crc_pos = buffer.Count;
160 | 					writeInt32(buffer, 0);
161 | 
162 | 					writeInt32(buffer, image.track);
163 | 					writeInt32(buffer, image.side);
164 | 					writeInt32(buffer, (uint)image.density);
165 | 					writeInt32(buffer, (uint)image.signalType);
166 | 					writeInt32(buffer, image.trackBytes);
167 | 					writeInt32(buffer, image.startBytePos);
168 | 					writeInt32(buffer, image.startBitPos);
169 | 					writeInt32(buffer, image.dataBits);
170 | 					writeInt32(buffer, image.gapBits);
171 | 					writeInt32(buffer, image.trackBits);
172 | 					writeInt32(buffer, image.blockCount);
173 | 					writeInt32(buffer, image.encoder);
174 | 					writeInt32(buffer, (uint)image.trackFlags);
175 | 					writeInt32(buffer, image.dataKey);
176 | 					for (int i = 0; i < 3; i++)
177 | 						writeInt32(buffer, image.reserved[i]);
178 | 
179 | 					crc = Utilities.crc32Buffer(buffer, start, 80);
180 | 					writeInt32(buffer, crc_pos, crc);
181 | 				}
182 | 			}
183 | 
184 | 			dataKey = 1;
185 | 			for (uint track = 0; track < 84; track++) {
186 | 				for (uint side = 0; side < 2; side++) {
187 | 					Track t = fd.tracks[track, side];
188 | 					if (t == null) continue;
189 | 
190 | 					start = buffer.Count;
191 | 					writeByte(buffer, (byte)'D');			// File header
192 | 					writeByte(buffer, (byte)'A');
193 | 					writeByte(buffer, (byte)'T');
194 | 					writeByte(buffer, (byte)'A');
195 | 					writeInt32(buffer, 28);					// record length
196 | 					crc_pos = buffer.Count;
197 | 					writeInt32(buffer, 0);					// CRC
198 | 
199 | 					// here we build the Extra DATA Block buffer
200 | 					List<byte> extraDataBlock = new List<byte>();
201 | 					
202 | 					// we first write the block descriptors
203 | 					foreach (Sector sector in t.sectors) {
204 | 						BlockDescriptor bd = new BlockDescriptor();
205 | 						bd.dataBits = sector.dataBits;
206 | 						bd.gapBits = sector.gapBits;
207 | 						bd.gapOffset = 0;
208 | 						bd.cellType = SignalType.cell_2us;
209 | 						bd.encoderType = BlockEncoderType.MFM;
210 | 						bd.blockFlags = sector.flags;
211 | 						bd.gapDefaultValue = 0;
212 | 						bd.dataOffset = 0;
213 | 
214 | 						writeInt32(extraDataBlock, bd.dataBits);
215 | 						writeInt32(extraDataBlock, bd.gapBits);
216 | 						writeInt32(extraDataBlock, bd.gapOffset);
217 | 						writeInt32(extraDataBlock, (uint)bd.cellType);
218 | 						writeInt32(extraDataBlock, (uint)bd.encoderType);
219 | 						writeInt32(extraDataBlock, (uint)bd.blockFlags);
220 | 						writeInt32(extraDataBlock, bd.gapDefaultValue);
221 | 						writeInt32(extraDataBlock, bd.dataOffset);
222 | 					}
223 | 
224 | 					// then we write the set of Gap stream elements	
225 | 					int gapOffset = t.sectors.Count * 32;
226 | 					int secNum = 0;
227 | 					foreach (Sector sector in t.sectors) {
228 | 
229 | 						// correction of gapOffset in block descriptor
230 | 						if (!sector.flags.Equals(BlockFlags.None))
231 | 							writeInt32(extraDataBlock, (secNum * 32) + 8, (uint)gapOffset);
232 | 
233 | 						if (sector.flags.HasFlag(BlockFlags.FwGap)) {
234 | 							foreach (GapElement ge in sector.gapElems) {
235 | 								if (ge.type != GapType.Forward) continue;
236 | 								writeGapElem(extraDataBlock, ge.gapBytes, ge.value);
237 | 								gapOffset += (ge.gapBytes == 0) ? 3 : ((ge.gapBytes * 8) < 256) ? 5 : 6;
238 | 							}
239 | 							writeByte(extraDataBlock, 0);
240 | 							gapOffset++;
241 | 						}
242 | 
243 | 						if (sector.flags.HasFlag(BlockFlags.BwGap)) {
244 | 							foreach (GapElement ge in sector.gapElems) {
245 | 								if (ge.type != GapType.Backward) continue;
246 | 								writeGapElem(extraDataBlock, ge.gapBytes, ge.value);
247 | 								gapOffset += (ge.gapBytes == 0) ? 3 : ((ge.gapBytes * 8) < 256) ? 5 : 6;
248 | 							}
249 | 							writeByte(extraDataBlock, 0);
250 | 							gapOffset++;
251 | 						}
252 | 
253 | 						secNum++;
254 | 					}
255 | 
256 | 					// then we write the set of Data stream elements
257 | 					//uint dataOffset = (uint)(t.sectors.Count * 32) + gapOffset;
258 | 					int dataOffset = gapOffset;
259 | 					secNum = 0;
260 | 					foreach (Sector sector in t.sectors) {
261 | 						// correction of dataOffset in block descriptor
262 | 						writeInt32(extraDataBlock, (secNum * 32) + 28, (uint)dataOffset);
263 | 
264 | 						foreach (DataElem de in sector.dataElems) {
265 | 							writeDataElem(extraDataBlock, de.type, de.dataBytes, de.value);
266 | 							// if fuzzy segment dataBytes is null
267 | 							dataOffset += ((de.dataBytes < 255) ? 2 : 3) + ((de.type != DataType.Fuzzy) ? (int)de.dataBytes : 0);
268 | 						}
269 | 						writeByte(extraDataBlock, 0);
270 | 						dataOffset++;
271 | 						secNum++;
272 | 					}
273 | 
274 | 					// now we have the complete extra data segment 
275 | 					// we can write the end of the Data record
276 | 					DataRecord data = new DataRecord();
277 | 					data.length = (uint)extraDataBlock.Count;
278 | 					data.bitSize = data.length * 8;
279 | 					data.crc = Utilities.crc32Buffer(extraDataBlock, 0, (int)data.length);
280 | 					data.key = dataKey++;
281 | 
282 | 					writeInt32(buffer, data.length);
283 | 					writeInt32(buffer, data.bitSize);
284 | 					writeInt32(buffer, data.crc);
285 | 					writeInt32(buffer, data.key);
286 | 
287 | 					crc = Utilities.crc32Buffer(buffer, start, 28);
288 | 					writeInt32(buffer, crc_pos, crc);
289 | 
290 | 					// and now copy the extra segment to the buffer
291 | 					foreach (byte b in extraDataBlock)
292 | 						buffer.Add(b);
293 | 
294 | 				}	// all sides
295 | 			}	// all tracks
296 | 
297 | 			return true;
298 | 		}
299 | 
300 | 
301 | 		private void writeGapElem(List<byte> buffer, uint byteCount, byte value) {
302 | 			uint bitCount = byteCount * 8;
303 | 			// write GAP length
304 | 			if (bitCount > 0) {
305 | 				if (bitCount < 256) {
306 | 					writeByte(buffer, 0x21);	// size=1 & type=1
307 | 					writeByte(buffer, (byte)bitCount);
308 | 				}
309 | 				else {
310 | 					writeByte(buffer, 0x41);	// size=2 & type=1
311 | 					writeByte(buffer, (byte)(bitCount / 256));
312 | 					writeByte(buffer, (byte)(bitCount & 0xFF));
313 | 				}
314 | 			}
315 | 			// Write GAP sample value
316 | 			writeByte(buffer, 0x22);	// size=1 & type=2
317 | 			writeByte(buffer, 8);		// sample size
318 | 			writeByte(buffer, value);
319 | 		}
320 | 
321 | 
322 | 		private void writeDataElem(List<byte> buffer, DataType type, uint byteCount, List<byte> value) {
323 | 			byte dataHead = (byte)((int)type + ((byteCount < 256) ? 0x20 : 0x40));
324 | 			writeByte(buffer, dataHead);
325 | 			if (byteCount < 256) {
326 | 				writeByte(buffer, (byte)byteCount);
327 | 			}
328 | 			else {
329 | 				writeByte(buffer, (byte)(byteCount / 256));
330 | 				writeByte(buffer, (byte)(byteCount & 0xFF));
331 | 			}
332 | 			// Write value
333 | 			if (type != DataType.Fuzzy) {
334 | 				Debug.Assert(byteCount == value.Count, "Length error in dataElem");
335 | 				for (int i = 0; i < byteCount; i++) {
336 | 					writeByte(buffer, value[i]);
337 | 				}
338 | 			}
339 | 		}
340 | 
341 | 
342 | 		private static void writeInt32(List<byte> buffer, int buf_position, uint value) {
343 | 			buffer[buf_position] = (byte)((value >> 24) & 0xFF);
344 | 			buffer[buf_position + 1] = (byte)((value >> 16) & 0xFF);
345 | 			buffer[buf_position + 2] = (byte)((value >> 8) & 0xFF);
346 | 			buffer[buf_position + 3] = (byte)(value & 0xFF);
347 | 		}
348 | 
349 | 
350 | 		private static void writeInt32(List<byte> buffer, uint val) {
351 | 			buffer.Add((byte)((val >> 24) & 0xFF));
352 | 			buffer.Add((byte)((val >> 16) & 0xFF));
353 | 			buffer.Add((byte)((val >> 8) & 0xFF));
354 | 			buffer.Add((byte)(val & 0xFF));
355 | 		}
356 | 
357 | 
358 | 		private static void writeByte(List<byte> buffer, byte val) {
359 | 			buffer.Add(val);
360 | 		}
361 | 
362 | 	}
363 | }
364 | 


--------------------------------------------------------------------------------
/pasti/PastiRead.cs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | @file PastiRead.cs
  3 | <summary>This file provide a function to parse a Pasti file in structures</summary>	
  4 | 
  5 | <div class="jlg">Copyright (C) 2014 Jean Louis-Guerin\n\n
  6 | This file is part of the Atari Image Reader (AIR) project.\n
  7 | The Atari Image Reader project may be used and distributed without restriction provided
  8 | that this copyright statement is not removed from the file and that any
  9 | derivative work contains the original copyright notice and the associated
 10 | disclaimer.\n
 11 | The Atari Image Reader project is free software; you can redistribute it
 12 | and/or modify  it under the terms of the GNU General Public License
 13 | as published by the Free Software Foundation; either version 2
 14 | of the License, or (at your option) any later version.\n
 15 | The Atari Image Reader project is distributed in the hope that it will be useful,
 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 18 | See the GNU General Public License for more details.\n\n
 19 | You should have received a copy of the GNU General Public License
 20 | along with the Atari Universal FD Image Tool project; if not, write to the Free Software
 21 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n</div>
 22 | 
 23 | @author Jean Louis-Guerin
 24 | */
 25 | 
 26 | using System;
 27 | using System.Diagnostics;
 28 | using System.IO;
 29 | using System.Windows;
 30 | using System.Windows.Controls;
 31 | using System.Windows.Media;
 32 | 
 33 | namespace Pasti {
 34 | 	/// <summary>
 35 | 	/// The reader class
 36 | 	/// </summary>
 37 | 	public class PastiReader {
 38 | 		TextBox _infoBox;
 39 | 
 40 | 		/// <summary>
 41 | 		/// The Pasti reader constructor
 42 | 		/// </summary>
 43 | 		/// <param name="tb">The textbox used to display information</param>
 44 | 		public PastiReader(TextBox tb) {
 45 | 			_infoBox = tb;
 46 | 		}
 47 | 
 48 | 		/// <summary>
 49 | 		/// Status returned when reading Pasti file
 50 | 		/// </summary>
 51 | 		public enum PastiStatus {
 52 | 			/// <summary>File read correctly</summary>
 53 | 			Ok = 0,
 54 | 			/// <summary>Could not open file for reading or file not found</summary>
 55 | 			FileNotFound,
 56 | 			/// <summary>The header in the file is not RSY</summary>
 57 | 			NotPastiFile,
 58 | 			/// <summary>Not version 3</summary>
 59 | 			UnsupportedVersion
 60 | 		}
 61 | 
 62 | 
 63 | 		/// <summary>
 64 | 		/// Read a Pasti file and fills the Floppy structure
 65 | 		/// </summary>
 66 | 		/// <param name="fileName">Name of the Pasti file to read</param>
 67 | 		/// <param name="fd">the Floppy parameter</param>
 68 | 		/// <returns>The status</returns>
 69 | 		public PastiStatus readPasti(string fileName, Floppy fd) {
 70 | 			FileStream fs;
 71 | 			try {
 72 | 				fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
 73 | 			}
 74 | 			catch (Exception exc) {
 75 | 				Console.WriteLine("Error: {0}", exc.Message);
 76 | 				return PastiStatus.FileNotFound;
 77 | 			}
 78 | 
 79 | 			// read file into buffer
 80 | 			byte[] sbuf = new byte[fs.Length];
 81 | 			int bytes = fs.Read(sbuf, 0, (int)fs.Length);
 82 | 			Debug.Assert(bytes == fs.Length);	// should be same
 83 | 			fs.Close();
 84 | 			PastiStatus status = PastiStatus.Ok;
 85 |             try {
 86 | 				status = decodePasti(sbuf, fd);
 87 | 			} 
 88 | 			catch (IndexOutOfRangeException e) {
 89 | 				MessageBox.Show("End of File - Missing data", "Error in Pasti File");
 90 | 				return PastiStatus.NotPastiFile;
 91 | 
 92 | 			}
 93 | 			return status;
 94 | 		}
 95 | 
 96 | 
 97 | 		/// <summary>
 98 | 		/// Decode the information in a Pasti file and fill the Floppy structure accordingly
 99 | 		/// </summary>
100 | 		/// <param name="buffer">Contains the data read from Pasti file</param>
101 | 		/// <param name="fd">The Floppy structure to fill</param>
102 | 		/// <returns>The read status</returns>
103 | 		private PastiStatus decodePasti(byte[] buffer, Floppy fd) {
104 | 			uint bpos = 0;
105 | 			uint startPos = 0;
106 | 			uint maxBufPos = 0;
107 | 
108 | 			startPos = bpos;
109 | 			FileDesc file = new FileDesc();
110 | 			// Read File Descriptor
111 | 			file.pastiFileId += readChar(buffer, ref bpos);
112 | 			file.pastiFileId += readChar(buffer, ref bpos);
113 | 			file.pastiFileId += readChar(buffer, ref bpos);
114 | 			file.pastiFileId += readChar(buffer, ref bpos);
115 | 			file.version = readUInt16(buffer, ref bpos);
116 | 			file.tool = readUInt16(buffer, ref bpos);
117 | 			file.reserved_1 = readUInt16(buffer, ref bpos);
118 | 			file.trackCount = readByte(buffer, ref bpos);
119 | 			file.revision = readByte(buffer, ref bpos);
120 | 			file.reserved_2 = readUInt32(buffer, ref bpos);
121 | 
122 | 			if (file.pastiFileId != "RSY\0")
123 | 				return PastiStatus.NotPastiFile;
124 | 			if (file.version != 3)
125 | 				return PastiStatus.UnsupportedVersion;
126 | 
127 | 			_infoBox.Clear();
128 | 			_infoBox.FontFamily = new FontFamily("Consolas");
129 | 			_infoBox.FontSize = 14;
130 | 			_infoBox.AppendText(file.ToString());
131 | 			_infoBox.AppendText(String.Format(" - ({0}-{1})\n", startPos, bpos - 1));
132 | 			_infoBox.ScrollToHome();
133 | 
134 | 			//fd.tracks = new Track[file.trackCount];	// create an array of track
135 | 			fd.tracks = new Track[85, 2];
136 | 			//fd.trackCount = file.trackCount;		// store the number of tracks
137 | 			//fd.version = (byte)(file.version * 10 + file.revision);
138 | 			//fd.tool = file.tool;
139 | 
140 | 			TrackDesc td = new TrackDesc();
141 | 			for (int tnum = 0; tnum < file.trackCount; tnum++) {
142 | 				uint track_record_start = bpos;
143 | 				startPos = bpos;
144 | 				Debug.Assert((startPos % 2) == 0, "Track Descriptor not word aligned", String.Format("Address = {0}", startPos));
145 | 				// Read Track Descriptors
146 | 				td.recordSize = readUInt32(buffer, ref bpos);
147 | 				td.fuzzyCount = readUInt32(buffer, ref bpos);
148 | 				td.sectorCount = readUInt16(buffer, ref bpos);
149 | 				td.trackFlags = readUInt16(buffer, ref bpos);
150 | 				td.trackLength = readUInt16(buffer, ref bpos);
151 | 				td.trackNumber = readByte(buffer, ref bpos);
152 | 				td.trackType = readByte(buffer, ref bpos);
153 | 				maxBufPos = bpos;
154 | 				int track = td.trackNumber & 0x7F;
155 | 				int side = (td.trackNumber & 0x80) >> 7;
156 | 
157 | 				_infoBox.AppendText(td.ToString());
158 | 				_infoBox.AppendText(String.Format(" ({0}-{1})\n", startPos, bpos - 1));
159 | 
160 | 				fd.tracks[track, side] = new Track();
161 | 
162 | 				// create array of sector for this track
163 | 				fd.tracks[track, side].sectors = new Sector[td.sectorCount];
164 | 				fd.tracks[track, side].sectorCount = td.sectorCount;
165 | 				fd.tracks[track, side].byteCount = td.trackLength;
166 | 				fd.tracks[track, side].side = (uint)(td.trackNumber >> 7);
167 | 				fd.tracks[track, side].number = (uint)(td.trackNumber & 0x7F);
168 | 
169 | 				// read sector descriptors if specified
170 | 				if ((td.trackFlags & TrackDesc.TRK_SECT_DESC) != 0) {
171 | 					SectorDesc[] sectors = new SectorDesc[td.sectorCount];
172 | 					for (int snum = 0; snum < td.sectorCount; snum++) {
173 | 						sectors[snum] = new SectorDesc();
174 | 						startPos = bpos;
175 | 
176 | 						// read sector descriptor
177 | 						sectors[snum].dataOffset = readUInt32(buffer, ref bpos);
178 | 						sectors[snum].bitPosition = readUInt16(buffer, ref bpos);
179 | 						sectors[snum].readTime = readUInt16(buffer, ref bpos);
180 | 						sectors[snum].id.track = readByte(buffer, ref bpos);
181 | 						sectors[snum].id.side = readByte(buffer, ref bpos);
182 | 						sectors[snum].id.number = readByte(buffer, ref bpos);
183 | 						sectors[snum].id.size = readByte(buffer, ref bpos);
184 | 						sectors[snum].id.crc = readUInt16(buffer, ref bpos);
185 | 						sectors[snum].fdcFlags = readByte(buffer, ref bpos);
186 | 						sectors[snum].reserved = readByte(buffer, ref bpos);
187 | 
188 | 						_infoBox.AppendText(sectors[snum].ToString());
189 | 						_infoBox.AppendText(String.Format(" ({0}-{1})\n", startPos, bpos - 1));
190 | 
191 | 						fd.tracks[track, side].sectors[snum] = new Sector();
192 | 						fd.tracks[track, side].sectors[snum].fdcFlags = sectors[snum].fdcFlags;
193 | 						fd.tracks[track, side].sectors[snum].bitPosition = sectors[snum].bitPosition;
194 | 						fd.tracks[track, side].sectors[snum].readTime = sectors[snum].readTime;
195 | 						fd.tracks[track, side].sectors[snum].id = sectors[snum].id;
196 | 						fd.tracks[track, side].sectors[snum].fdcFlags = sectors[snum].fdcFlags;
197 | 					} // for all sectors
198 | 
199 | 					byte[] fuzzyMask = null;
200 | 					// if necessary read fuzzy bytes
201 | 					if (td.fuzzyCount != 0) {
202 | 						startPos = bpos;
203 | 						fuzzyMask = new byte[td.fuzzyCount];
204 | 						for (int i = 0; i < td.fuzzyCount; i++)
205 | 							fuzzyMask[i] = readByte(buffer, ref bpos);
206 | 						_infoBox.AppendText(String.Format("   Reading Fuzzy {0} bytes ({1}-{2})\n", td.fuzzyCount, startPos, bpos - 1));
207 | 					}
208 | 
209 | 					// the track data are located after the sector descriptor records & fuzzy record
210 | 					uint track_data_start = bpos;		// store the position of data in track record
211 | 					_infoBox.AppendText(String.Format("   Start of Track data {0}\n", track_data_start));
212 | 
213 | 					// read track data if specified
214 | 					if ((td.trackFlags & TrackDesc.TRK_IMAGE) != 0) {
215 | 						// track with sync offset
216 | 						startPos = bpos;
217 | 						// read sync if provided
218 | 						if ((td.trackFlags & TrackDesc.TRK_SYNC) != 0)
219 | 							fd.tracks[track, side].firstSyncOffset = readUInt16(buffer, ref bpos);
220 | 						else
221 | 							fd.tracks[track, side].firstSyncOffset = 0;
222 | 						// read track data size
223 | 						fd.tracks[track, side].byteCount = readUInt16(buffer, ref bpos);
224 | 						// read track data
225 | 						fd.tracks[track, side].trackData = new byte[fd.tracks[track, side].byteCount];
226 | 						for (int i = 0; i < fd.tracks[track, side].byteCount; i++)
227 | 							fd.tracks[track, side].trackData[i] = readByte(buffer, ref bpos);
228 | 						// seems like we are reading even number
229 | 						maxBufPos = Math.Max(maxBufPos, bpos + bpos % 2);
230 | 						fd.tracks[track, side].standardTrack = false;
231 | 						_infoBox.AppendText(String.Format("      Reading Track Image {0}{1} bytes (including {2} header bytes) SyncPos={3} ({4}-{5})\n",
232 | 							fd.tracks[track, side].byteCount + (((td.trackFlags & TrackDesc.TRK_SYNC) != 0) ? 4 : 2), (bpos % 2 != 0) ? "+1" : "",
233 | 							((td.trackFlags & TrackDesc.TRK_SYNC) != 0) ? 4 : 2, fd.tracks[track, side].firstSyncOffset, startPos, bpos + (bpos % 2) - 1));
234 | 					} // read track_data
235 | 
236 | 					// read all sectors data
237 | 					bool bitWidth = false;
238 | 					for (int snum = 0; snum < td.sectorCount; snum++) {
239 | 						if (((sectors[snum].fdcFlags & SectorDesc.BIT_WIDTH) != 0) && (file.revision == 2))
240 | 							bitWidth = true;
241 | 
242 | 						// create sector buffer and read data if necessary
243 | 						if ((sectors[snum].fdcFlags & SectorDesc.SECT_RNF) == 0) {
244 | 							fd.tracks[track, side].sectors[snum].sectorData = new byte[128 << sectors[snum].id.size];
245 | 							bpos = track_data_start + sectors[snum].dataOffset;
246 | 							startPos = bpos;
247 | 							for (int i = 0; i < 128 << sectors[snum].id.size; i++)
248 | 								fd.tracks[track, side].sectors[snum].sectorData[i] = readByte(buffer, ref bpos);
249 | 							maxBufPos = Math.Max(maxBufPos, bpos);
250 | 							_infoBox.AppendText(String.Format("      Reading Sector {0} {1} bytes ({2}-{3}) {4}\n",
251 | 								fd.tracks[track, side].sectors[snum].id.number, 128 << sectors[snum].id.size, startPos, bpos - 1,
252 | 								(((td.trackFlags & TrackDesc.TRK_IMAGE) != 0) && (sectors[snum].dataOffset < fd.tracks[track, side].byteCount)) ? " in Track Image" : ""));
253 | 						} // read sector data
254 | 					}	// for all sectors
255 | 
256 | 					// if we have timing record we read
257 | 					ushort[] timing = null;
258 | 					if (bitWidth) {
259 | 						bpos = maxBufPos;
260 | 						startPos = bpos;
261 | 						ushort timingFlags = readUInt16(buffer, ref bpos);
262 | 						ushort timingSize = readUInt16(buffer, ref bpos);
263 | 						int entries = (timingSize - 4) / 2;
264 | 						timing = new ushort[entries];
265 | 						for (int i = 0; i < entries; i++) {
266 | 							// Big Indian value
267 | 							timing[i] = (ushort)(readByte(buffer, ref bpos) << 8);
268 | 							timing[i] = readByte(buffer, ref bpos);
269 | 						}
270 | 						maxBufPos = Math.Max(maxBufPos, bpos);
271 | 						_infoBox.AppendText(String.Format("      Reading Timing {0} bytes Flag={1} ({2}-{3})\n", timingSize, timingFlags, startPos, bpos - 1));
272 | 					}	// sector has timing data
273 | 
274 | 					// now we transfer the fuzzy bytes and timing bytes if necessary
275 | 					int startFuzzy = 0;
276 | 					int startTiming = 0;
277 | 					for (int snum = 0; snum < td.sectorCount; snum++) {
278 | 						// fuzzy bytes
279 | 						if ((fd.tracks[track, side].sectors[snum].fdcFlags & SectorDesc.FUZZY_BITS) != 0) {
280 | 							int fsize = 128 << sectors[snum].id.size;
281 | 							fd.tracks[track, side].sectors[snum].fuzzyData = new byte[fsize];
282 | 							for (int i = 0; i < fsize; i++)
283 | 								fd.tracks[track, side].sectors[snum].fuzzyData[i] = fuzzyMask[i + startFuzzy];
284 | 							startFuzzy += fsize;
285 | 							_infoBox.AppendText(String.Format("      Transferring {0} Fuzzy bytes to sect {1}\n", fsize, fd.tracks[track, side].sectors[snum].id.number));
286 | 						}
287 | 						// timing bytes
288 | 						if ((sectors[snum].fdcFlags & SectorDesc.BIT_WIDTH) != 0) {
289 | 							int tsize = (128 << sectors[snum].id.size) / 16;
290 | 							fd.tracks[track, side].sectors[snum].timmingData = new ushort[tsize];
291 | 							if (file.revision == 2) {
292 | 								for (int i = 0; i < tsize; i++)
293 | 									fd.tracks[track, side].sectors[snum].timmingData[i] = timing[i + startTiming];
294 | 								startTiming += tsize;
295 | 								_infoBox.AppendText(String.Format("      Transferring {0} Timing values to sect {1}\n", tsize, fd.tracks[track, side].sectors[snum].id.number));
296 | 							}	// revision == 2 => read timing from file							
297 | 							else {
298 | 								for (int i = 0; i < tsize; i++) {
299 | 									if (i < (tsize / 4)) fd.tracks[track, side].sectors[snum].timmingData[i] = 127;
300 | 									else if (i < (tsize / 2)) fd.tracks[track, side].sectors[snum].timmingData[i] = 133;
301 | 									else if (i < ((3 * tsize) / 2)) fd.tracks[track, side].sectors[snum].timmingData[i] = 121;
302 | 									else fd.tracks[track, side].sectors[snum].timmingData[i] = 127;
303 | 								}
304 | 							}	// if revision != 2 => we simulate with a table
305 | 						}
306 | 					}
307 | 					if (timing != null)
308 | 						Debug.Assert(timing.Length == startTiming, "invalid timing size");
309 | 					if (fuzzyMask != null)
310 | 						Debug.Assert(fuzzyMask.Length == startFuzzy, "invalid fuzzy size");
311 | 				} // TRK_SECT provided
312 | 
313 | 				else {
314 | 					// read all standard sectors
315 | 					for (int snum = 0; snum < td.sectorCount; snum++) {
316 | 						startPos = bpos;
317 | 						fd.tracks[track, side].sectors[snum] = new Sector();
318 | 						fd.tracks[track, side].sectors[snum].sectorData = new byte[512];
319 | 						for (int i = 0; i < 512; i++)
320 | 							fd.tracks[track, side].sectors[snum].sectorData[i] = readByte(buffer, ref bpos);
321 | 
322 | 						fd.tracks[track, side].sectors[snum].fdcFlags = 0;
323 | 						fd.tracks[track, side].sectors[snum].bitPosition = 0;
324 | 						fd.tracks[track, side].sectors[snum].readTime = 0;
325 | 						fd.tracks[track, side].sectors[snum].fuzzyData = null;
326 | 						fd.tracks[track, side].sectors[snum].timmingData = null;
327 | 						fd.tracks[track, side].sectors[snum].id.track = (byte)(td.trackNumber & 0x7F);
328 | 						fd.tracks[track, side].sectors[snum].id.side = (byte)(((td.trackNumber & 0x80) == 0x80) ? 1 : 0);
329 | 						fd.tracks[track, side].sectors[snum].id.number = (byte)snum;
330 | 						fd.tracks[track, side].sectors[snum].id.crc = 0;
331 | 						_infoBox.AppendText(String.Format("      Standard Sector {0} {1} bytes ({2}-{3})\n", snum, 512, startPos, bpos));
332 | 						maxBufPos = Math.Max(maxBufPos, bpos);
333 | 					} // read all sector
334 | 				} // standard non protected sectors
335 | 
336 | 				// we set record size to even value
337 | 				maxBufPos += maxBufPos % 2;
338 | 
339 | 				Debug.Assert(maxBufPos == track_record_start + td.recordSize, "Invalid Track Size",
340 | 					String.Format("Track {0} Current pointer position = {1} next track = {2}", td.trackNumber, bpos, track_record_start + td.recordSize));
341 | 				bpos = track_record_start + td.recordSize;
342 | 			} // for all tracks
343 | 
344 | 			return PastiStatus.Ok;
345 | 
346 | 		} // pasti/pasti file
347 | 
348 | 
349 | 		private static uint readUInt32(byte[] buf, ref uint pos) {
350 | 			uint val = (uint)buf[pos] + (uint)(buf[pos + 1] << 8) + (uint)(buf[pos + 2] << 16) + (uint)(buf[pos + 3] << 24);
351 | 			pos += 4;
352 | 			return val;
353 | 		}
354 | 
355 | 
356 | 		private static ushort readUInt16(byte[] buf, ref uint pos) {
357 | 			ushort val = (ushort)buf[pos];
358 | 			val += (ushort)(buf[pos + 1] << 8);
359 | 			pos += 2;
360 | 			return val;
361 | 		}
362 | 
363 | 
364 | 		private static byte readByte(byte[] buf, ref uint pos) {
365 | 			return buf[pos++];
366 | 		}
367 | 
368 | 
369 | 		private static char readChar(byte[] buf, ref uint pos) {
370 | 			return (char)buf[pos++];
371 | 		}
372 | 
373 | 	}
374 | 
375 | }


--------------------------------------------------------------------------------
/pasti/PastiWrite.cs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | @file PastiWrite.cs
  3 | <summary>This file provide a function to write a Pasti file from structures</summary>	
  4 | 
  5 | <div class="jlg">Copyright (C) 2014 Jean Louis-Guerin\n\n
  6 | This file is part of the Atari Image Reader (AIR) project.\n
  7 | The Atari Image Reader project may be used and distributed without restriction provided
  8 | that this copyright statement is not removed from the file and that any
  9 | derivative work contains the original copyright notice and the associated
 10 | disclaimer.\n
 11 | The Atari Image Reader project is free software; you can redistribute it
 12 | and/or modify  it under the terms of the GNU General Public License
 13 | as published by the Free Software Foundation; either version 2
 14 | of the License, or (at your option) any later version.\n
 15 | The Atari Image Reader project is distributed in the hope that it will be useful,
 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 18 | See the GNU General Public License for more details.\n\n
 19 | You should have received a copy of the GNU General Public License
 20 | along with the Atari Universal FD Image Tool project; if not, write to the Free Software
 21 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n</div>
 22 | 
 23 | @author Jean Louis-Guerin
 24 | */
 25 | using System;
 26 | using System.Collections.Generic;
 27 | using System.Diagnostics;
 28 | using System.IO;
 29 | using System.Linq;
 30 | using System.Text;
 31 | using System.Threading.Tasks;
 32 | using System.Windows.Controls;
 33 | using System.Windows.Media;
 34 | 
 35 | namespace Pasti {
 36 | 	/// <summary>
 37 | 	/// The Pasti Writer Class
 38 | 	/// </summary>
 39 | 	class PastiWriter {
 40 | 		TextBox _infoBox;
 41 | 
 42 | 		/// <summary>
 43 | 		/// The Pasti Writer Constructor
 44 | 		/// </summary>
 45 | 		/// <param name="tb">The textbox used to display information</param>
 46 | 		public PastiWriter(TextBox tb) {
 47 | 			_infoBox = tb;
 48 | 		}
 49 | 
 50 | 		/// <summary>
 51 | 		/// Status returned when reading Pasti file
 52 | 		/// </summary>
 53 | 		public enum WriteStatus {
 54 | 			/// <summary>File read correctly</summary>
 55 | 			Ok = 0,
 56 | 			/// <summary>Could not open file for reading or file not found</summary>
 57 | 			FileNotFound,
 58 | 			/// <summary>The header in the file is not RSY</summary>
 59 | 			NotPastiFile,
 60 | 			/// <summary>Not version 3</summary>
 61 | 			UnsupportedVersion
 62 | 		}
 63 | 
 64 | 
 65 | 		/// <summary>
 66 | 		/// Read a Pasti file and fills the Floppy structure
 67 | 		/// </summary>
 68 | 		/// <param name="fileName">Name of the Pasti file to read</param>
 69 | 		/// <param name="fd">the Floppy parameter</param>
 70 | 		/// <returns>The status</returns>
 71 | 		public WriteStatus writePasti(string fileName, Floppy fd) {
 72 | 			FileStream fs;
 73 | 
 74 | 			// encode file into buffer
 75 | 			List<byte> sbuf = new List<byte>();
 76 | 			WriteStatus status = encodePasti(sbuf, fd);
 77 | 
 78 | 
 79 | 			try {
 80 | 				fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Read);
 81 | 			}
 82 | 			catch (Exception exc) {
 83 | 				Console.WriteLine("Error: {0}", exc.Message);
 84 | 				return WriteStatus.FileNotFound;
 85 | 			}
 86 | 			fs.Write(sbuf.ToArray(), 0 , sbuf.Count);
 87 | 			fs.Close();
 88 | 
 89 | 			return status;		
 90 | 		}
 91 | 
 92 | 
 93 | 		/// <summary>
 94 | 		/// Encode the information in a Floppy structure into a buffer using Pasti file structure
 95 | 		/// </summary>
 96 | 		/// <param name="buffer">Contains the data read from Pasti file</param>
 97 | 		/// <param name="floppy">The Floppy structure to fill</param>
 98 | 		/// <returns>The read status</returns>
 99 | 		private WriteStatus encodePasti(List<byte> buffer, Floppy floppy) {
100 | 			int start = 0;
101 | 
102 | 			// compute the number of tracks in file
103 | 			int trackCount = 0;
104 | 			for (int track = 0; track < 84; track++)
105 | 				for (int side = 0; side < 2; side++)
106 | 					if (floppy.tracks[track, side] != null) trackCount++;
107 | 
108 | 			FileDesc fd = new FileDesc();
109 | 			fd.version = 3;
110 | 			fd.revision = 2;			
111 | 			//fd.trackCount = floppy.trackCount;
112 | 			fd.tool = 0x0FF;
113 | 
114 | 			writeByte(buffer, (byte)'R');			// File header
115 | 			writeByte(buffer, (byte)'S');
116 | 			writeByte(buffer, (byte)'Y');
117 | 			writeByte(buffer, 0);
118 | 
119 | 			writeInt16(buffer, fd.version);			// version
120 | 			writeInt16(buffer, fd.tool);			// tool
121 | 			writeInt16(buffer, 0);					// reserved 1
122 | 			writeByte(buffer, fd.trackCount);		// trackCount
123 | 			writeByte(buffer, fd.revision);			// revision
124 | 			writeInt32(buffer, 0);					// reserved 2
125 | 
126 | 			_infoBox.Clear();
127 | 			_infoBox.ScrollToHome();
128 | 			_infoBox.FontFamily = new FontFamily("Consolas");
129 | 			_infoBox.FontSize = 14;
130 | 			_infoBox.AppendText(fd.ToString());
131 | 			_infoBox.AppendText(String.Format(" - ({0}-{1})\n", start, buffer.Count-1));
132 | 						
133 | 			// Write all track records
134 | 			//for (int tnum = 0; tnum < floppy.trackCount; tnum++) {
135 | 			for (int track = 0; track < 84; track++)
136 | 				for (int side = 0; side < 2; side++) {
137 | 					if (floppy.tracks[track, side] == null) continue;
138 | 					int startTrackRecord = buffer.Count;
139 | 					TrackDesc td = new TrackDesc();
140 | 
141 | 					td.recordSize = 16;		// initial value = size of TrackDesc
142 | 					//track.trackFlags = 0x0010;	// Only bit 5 set to 1 initially
143 | 					td.sectorCount = (ushort)floppy.tracks[track, side].sectors.Count();
144 | 					td.trackLength = (ushort)floppy.tracks[track, side].byteCount;
145 | 					td.trackNumber = (byte)floppy.tracks[track, side].number;
146 | 					if (floppy.tracks[track, side].side == 1) td.trackNumber |= 0x80;
147 | 					td.trackType = 0;
148 | 
149 | 					// do we have sector descriptors
150 | 					if (trackNeedSectorDesc(floppy.tracks[track, side])) {
151 | 						td.trackFlags |= TrackDesc.TRK_SECT_DESC;
152 | 						td.recordSize += (uint)(16 * td.sectorCount);
153 | 					}
154 | 
155 | 					// do we have fuzzy record
156 | 					for (int sect = 0; sect < floppy.tracks[track, side].sectors.Count(); sect++)
157 | 						if (floppy.tracks[track, side].sectors[sect].fuzzyData != null)
158 | 							td.fuzzyCount += (uint)floppy.tracks[track, side].sectors[sect].fuzzyData.Count();
159 | 					td.recordSize += td.fuzzyCount;
160 | 
161 | 					bool trkSync = false;
162 | 					// do we have track data
163 | 					if (trackNeedTrackData(floppy.tracks[track, side])) {
164 | 						if (trkSync) {
165 | 							td.trackFlags |= TrackDesc.TRK_IMAGE | TrackDesc.TRK_SYNC;
166 | 							td.recordSize += 4;	// header
167 | 						}
168 | 						else {
169 | 							td.trackFlags |= TrackDesc.TRK_IMAGE;
170 | 							td.recordSize += 2;	// header
171 | 						}
172 | 						td.recordSize += floppy.tracks[track, side].byteCount;
173 | 						// we write even number of bytes
174 | 						td.recordSize += floppy.tracks[track, side].byteCount % 2;
175 | 					}
176 | 
177 | 					// do we have timing record
178 | 					int timingEntries = 0;
179 | 					for (int sect = 0; sect < floppy.tracks[track, side].sectors.Count(); sect++)
180 | 						if (floppy.tracks[track, side].sectors[sect].timmingData != null)
181 | 							timingEntries += floppy.tracks[track, side].sectors[sect].timmingData.Count();
182 | 
183 | 					if (timingEntries > 0)
184 | 						td.recordSize += (uint)((2 * timingEntries) + 4);
185 | 
186 | 					// we had up the sector data - here we do not optimize (data shared with track data)
187 | 					for (int sect = 0; sect < floppy.tracks[track, side].sectors.Count(); sect++)
188 | 						if (floppy.tracks[track, side].sectors[sect].sectorData != null)
189 | 							td.recordSize += (uint)floppy.tracks[track, side].sectors[sect].sectorData.Count();
190 | 
191 | 					//// seems like track record size is always kept even
192 | 					//td.recordSize += td.recordSize % 2;
193 | 
194 | 					// Track Descriptor is ready => write it
195 | 					start = buffer.Count;
196 | 					writeInt32(buffer, td.recordSize);
197 | 					writeInt32(buffer, td.fuzzyCount);
198 | 					writeInt16(buffer, td.sectorCount);
199 | 					writeInt16(buffer, td.trackFlags);
200 | 					writeInt16(buffer, td.trackLength);
201 | 					writeByte(buffer, td.trackNumber);
202 | 					writeByte(buffer, td.trackType);
203 | 
204 | 					_infoBox.AppendText(td.ToString());
205 | 					_infoBox.AppendText(String.Format(" ({0}-{1})\n", start, buffer.Count - 1));
206 | 
207 | 					// write sector descriptor if needed
208 | 					if (trackNeedSectorDesc(floppy.tracks[track, side])) {
209 | 						uint offset = 0;
210 | 						if (trackNeedTrackData(floppy.tracks[track, side]))
211 | 							offset = (uint)(floppy.tracks[track, side].byteCount + (floppy.tracks[track, side].byteCount % 2) + (trkSync ? 4 : 2));
212 | 						for (int sect = 0; sect < floppy.tracks[track, side].sectorCount; sect++) {
213 | 							SectorDesc sd = new SectorDesc();
214 | 							sd.dataOffset = offset;
215 | 							sd.bitPosition = floppy.tracks[track, side].sectors[sect].bitPosition;
216 | 							sd.readTime = floppy.tracks[track, side].sectors[sect].readTime;
217 | 							sd.id = floppy.tracks[track, side].sectors[sect].id;	// TODO ?
218 | 							sd.fdcFlags = floppy.tracks[track, side].sectors[sect].fdcFlags;
219 | 							sd.reserved = 0;
220 | 							if ((floppy.tracks[track, side].sectors[sect].fdcFlags & SectorDesc.SECT_RNF) == 0)
221 | 								offset += (uint)(128 << floppy.tracks[track, side].sectors[sect].id.size);
222 | 
223 | 							start = buffer.Count;
224 | 							writeInt32(buffer, sd.dataOffset);
225 | 							writeInt16(buffer, sd.bitPosition);
226 | 							writeInt16(buffer, sd.readTime);
227 | 
228 | 							writeByte(buffer, sd.id.track);
229 | 							writeByte(buffer, sd.id.side);
230 | 							writeByte(buffer, sd.id.number);
231 | 							writeByte(buffer, sd.id.size);
232 | 							writeInt16(buffer, sd.id.crc);
233 | 
234 | 							writeByte(buffer, sd.fdcFlags);
235 | 							writeByte(buffer, sd.reserved);
236 | 
237 | 							_infoBox.AppendText(sd.ToString());
238 | 							_infoBox.AppendText(String.Format(" ({0}-{1})\n", start, buffer.Count - 1));
239 | 						}
240 | 					}
241 | 
242 | 					// write fuzzy mask if needed
243 | 					for (int sect = 0; sect < floppy.tracks[track, side].sectorCount; sect++) {
244 | 						if (floppy.tracks[track, side].sectors[sect].fuzzyData != null) {
245 | 							start = buffer.Count;
246 | 							for (int i = 0; i < floppy.tracks[track, side].sectors[sect].fuzzyData.Count(); i++)
247 | 								writeByte(buffer, floppy.tracks[track, side].sectors[sect].fuzzyData[i]);
248 | 							_infoBox.AppendText(String.Format("   Writing Fuzzy {0} bytes for sector {1} ({2}-{3})\n",
249 | 								floppy.tracks[track, side].sectors[sect].fuzzyData.Count(), floppy.tracks[track, side].sectors[sect].id.number, start, buffer.Count - 1));
250 | 						}	// fuzzy found
251 | 					}	// all sect
252 | 
253 | 
254 | 					// the track data are located after the sector descriptor records & fuzzy record
255 | 					int track_data_start = buffer.Count; // store the position of data in track record
256 | 					_infoBox.AppendText(String.Format("   Start of Track data {0}\n", track_data_start));
257 | 
258 | 					// write track data if needed
259 | 					if (trackNeedTrackData(floppy.tracks[track, side])) {
260 | 						start = buffer.Count;
261 | 						if (trkSync)
262 | 							writeInt16(buffer, floppy.tracks[track, side].firstSyncOffset);
263 | 						writeInt16(buffer, (ushort)floppy.tracks[track, side].byteCount);
264 | 						for (int i = 0; i < floppy.tracks[track, side].byteCount; i++)
265 | 							writeByte(buffer, floppy.tracks[track, side].trackData[i]);
266 | 						// we write even number
267 | 						if ((floppy.tracks[track, side].byteCount % 2) != 0)
268 | 							writeByte(buffer, 0xFF);
269 | 
270 | 						_infoBox.AppendText(String.Format("      Writing Track {0}{1} bytes SyncPos={2} ({3}-{4})\n",
271 | 							floppy.tracks[track, side].byteCount + ((trkSync) ? 4 : 2), ((floppy.tracks[track, side].byteCount % 2) != 0) ? "(+1)" : "",
272 | 							floppy.tracks[track, side].firstSyncOffset, start, buffer.Count - 1));
273 | 					}
274 | 
275 | 					// write all sectors data
276 | 					for (int sect = 0; sect < floppy.tracks[track, side].sectorCount; sect++) {
277 | 						start = buffer.Count;
278 | 						if ((floppy.tracks[track, side].sectors[sect].fdcFlags & SectorDesc.SECT_RNF) == 0) {
279 | 							for (int i = 0; i < floppy.tracks[track, side].sectors[sect].sectorData.Count(); i++)
280 | 								writeByte(buffer, floppy.tracks[track, side].sectors[sect].sectorData[i]);
281 | 							_infoBox.AppendText(String.Format("      Writing Sector {0} {1} bytes ({2}-{3})\n",
282 | 								floppy.tracks[track, side].sectors[sect].id.number, floppy.tracks[track, side].sectors[sect].sectorData.Count(), start, buffer.Count - 1));
283 | 						}
284 | 					}
285 | 
286 | 					// write timing if necessary
287 | 					if (timingEntries > 0) {
288 | 						// write header
289 | 						start = buffer.Count;
290 | 						writeInt16(buffer, 0x05);
291 | 						writeInt16(buffer, (ushort)(2 * timingEntries + 4));
292 | 						_infoBox.AppendText(String.Format("   Writing Timing header Flag=5 size={0} ({1}-{2})\n", 2 * timingEntries + 4, start, buffer.Count - 1));
293 | 						// write timing
294 | 						for (int sect = 0; sect < floppy.tracks[track, side].sectorCount; sect++) {
295 | 							if (floppy.tracks[track, side].sectors[sect].timmingData != null) {
296 | 								start = buffer.Count;
297 | 								for (int i = 0; i < floppy.tracks[track, side].sectors[sect].timmingData.Count(); i++) {
298 | 									// Big Indian value
299 | 									buffer.Add((byte)(floppy.tracks[track, side].sectors[sect].timmingData[i] << 8));
300 | 									buffer.Add((byte)floppy.tracks[track, side].sectors[sect].timmingData[i]);
301 | 								}
302 | 								_infoBox.AppendText(String.Format("   Writing Timing {0} values for sector {1} ({2}-{3})\n",
303 | 									floppy.tracks[track, side].sectors[sect].timmingData.Count(), floppy.tracks[track, side].sectors[sect].id.number, start, buffer.Count - 1));
304 | 							}	// timing found
305 | 						}	// all sect
306 | 					}
307 | 
308 | 					if (buffer.Count % 2 != 0) {
309 | 						writeByte(buffer, 0xFF);	// dummy extra byte
310 | 					}	// even
311 | 
312 | 					Debug.Assert(buffer.Count == startTrackRecord + td.recordSize, "Invalid Track Size",
313 | 						String.Format("Track {0} Current pointer position = {1} next track = {2}", td.trackNumber, buffer.Count, startTrackRecord + td.recordSize));
314 | 				} // for all tracks
315 | 
316 | 			return WriteStatus.Ok;
317 | 
318 | 		}	// encode pasti
319 | 
320 | 
321 | 		private static void writeInt32(List<byte> buffer, uint val) {
322 | 			buffer.Add((byte)(val & 0xFF));
323 | 			buffer.Add((byte)((val >> 8) & 0xFF));
324 | 			buffer.Add((byte)((val >> 16) & 0xFF));
325 | 			buffer.Add((byte)((val >> 24) & 0xFF));
326 | 		}
327 | 
328 | 
329 | 		private static void writeInt16(List<byte> buffer, ushort val) {
330 | 			buffer.Add((byte)(val & 0xFF));
331 | 			buffer.Add((byte)(val >> 8));
332 | 		}
333 | 
334 | 		private static void writeByte(List<byte> buffer, byte val) {
335 | 			buffer.Add(val);
336 | 		}
337 | 
338 | 
339 | 		private bool trackNeedSectorDesc(Track track) {
340 | 			// here we test for
341 | 			// - All the sectors of the track are numbered sequentially from 1 to n
342 | 			// - All the sectors use valid sector numbers from 0x00-0xF4
343 | 			// - All the sectors of the track have unique sector number
344 | 			// - All sectors in the track have standard timing values
345 | 			// - invalid track number
346 | 			// - Special Flags: No data, CRC, DDAM (cover sector no data)
347 | 
348 | 			int secnum = 1;
349 | 			for (int sect = 0; sect < track.sectorCount; sect++) {
350 | 				// sequential sector number 1..n
351 | 				if (track.sectors[sect].id.number != secnum++) 
352 | 					track.standardSectors = false;
353 | 
354 | 				// duplicate sector
355 | 				for (int j = sect + 1; j < track.sectorCount; j++)
356 | 					if (track.sectors[sect].id.number == track.sectors[j].id.number)
357 | 						track.standardSectors = false;
358 | 
359 | 				// sector with invalid sector number
360 | 				if ((track.sectors[sect].id.number >= 0xF5) && (track.sectors[sect].id.number <= 0xF7))
361 | 					track.standardSectors = false;
362 | 
363 | 				// sector with invalid track number
364 | 				if (track.sectors[sect].id.track != track.number)
365 | 					track.standardSectors = false;
366 | 
367 | 				// sector with invalid side/head
368 | 				if (track.sectors[sect].id.side != track.side)
369 | 					track.standardSectors = false;
370 | 
371 | 				// sector with invalid size
372 | 				if (track.sectors[sect].id.size > 3)
373 | 					track.standardSectors = false;
374 | 
375 | 				// short long sector time
376 | 				if (track.sectors[sect].readTime != 0)
377 | 					track.standardSectors = false;
378 | 
379 | 				// FDC Flags - Here we read the saved flags
380 | 
381 | 				// RNF = sector with no data
382 | 				//if ((track.sectors[sect].fdcFlags & SectorDesc.SECT_RNF) != 0)
383 | 				if (track.sectors[sect].sectorData == null)
384 | 					track.standardSectors = false;
385 | 
386 | 				// CRC error = ID / Data
387 | 				if ((track.sectors[sect].fdcFlags & SectorDesc.CRC_ERR) != 0)
388 | 					track.standardSectors = false;
389 | 
390 | 				// Record type = DDAM
391 | 				if ((track.sectors[sect].fdcFlags & SectorDesc.REC_TYPE) != 0)
392 | 					track.standardSectors = false;
393 | 				
394 | 				// FDC - Fuzzy
395 | 				if (track.sectors[sect].fuzzyData != null)
396 | 					track.standardSectors = false;
397 | 
398 | 				// FDC - Timing
399 | 				if (track.sectors[sect].timmingData != null)
400 | 					track.standardSectors = false;
401 | 			}
402 | 			if (trackNeedTrackData(track))
403 | 				return true;
404 | 			return !track.standardSectors;
405 | 		}
406 | 
407 | 
408 | 		private bool trackNeedTrackData(Track track) {
409 | 			// We need Optional Track Data when:
410 | 			// - Single Data Segment = ID found but no data
411 | 			// - Invalid Data in Gap ?
412 | 			// - Shifted Track: Data over Index + Data beyond Index + ID over index
413 | 			// - Invalid sync mark sequence
414 | 			// - Sector within Sector
415 | 			// - No Flux Area
416 | 			// - Short long track ??
417 | 			// - SWS
418 | 			// - no data
419 | 
420 | 			// for now we are cheating by using the TRK_IMAGE flag
421 | 			return !track.standardTrack;
422 | 		}
423 | 
424 | 	}
425 | 
426 | }
427 | 


--------------------------------------------------------------------------------