public void Read(BinaryReaderWriter br)
{
MapID = br.Read4UInt();
ProductID = br.Read2AsUShort();
FamilyID = br.Read2AsUShort();
MapNumber = br.Read4UInt();
}
public void Write(BinaryReaderWriter wr)
{
wr.Write(MapID);
wr.Write(ProductID);
wr.Write(FamilyID);
wr.Write(MapNumber);
}
/// <summary>
/// Die Daten werden encodiert und in den entsprechenden Abschnitt geschrieben. Ex. der Abschnitt schon, erfolgt KEIN Schreiben!
/// </summary>
/// <param name="filesectiontype"></param>
/// <param name="overwrite">wenn true, werden ev. schon vorhandene Daten überschrieben</param>
/// <returns>false, wenn der Abschnitt nicht überschrieben werden kann oder keine Daten ex.</returns>
protected bool SetData2Filesection(int filesectiontype, bool overwrite)
{
if (!overwrite &&
Filesections.ContainsType(filesectiontype))
{
return(false);
}
BinaryReaderWriter bw = new BinaryReaderWriter();
Encode_Filesection(bw, filesectiontype); // Daten nur in den temp. Writer schreiben
if (bw.Length > 0)
{
if (!Filesections.ContainsType(filesectiontype))
{
Filesections.AddSection(filesectiontype);
}
bw.Seek(0);
Filesections.SetSectionDataFromWriter(filesectiontype, bw);
}
else
{
if (Filesections.ContainsType(filesectiontype))
{
Filesections.RemoveSection(filesectiontype);
}
return(false);
}
return(true);
}
/// <summary>
/// lese die Daten aus einer MDX-Datei ein
/// </summary>
/// <param name="br"></param>
public void Read(BinaryReaderWriter br)
{
br.Seek(0);
byte[] id = br.ReadBytes(6);
if (id[0] != 'M' ||
id[1] != 'i' ||
id[2] != 'd' ||
id[3] != 'x' ||
id[4] != 'd' ||
id[5] != 0)
{
throw new Exception("Keine MDX-Datei.");
}
Unknown1 = br.Read2AsUShort();
Unknown2 = br.Read2AsUShort();
Count = br.Read4UInt();
Maps.Clear();
for (int i = 0; i < Count; i++)
{
MapEntry entry = new MapEntry();
entry.Read(br);
Maps.Add(entry);
}
}
/// <summary>
/// liest den allgemeinen Header ab <see cref="HeaderOffset"/> ein
/// <para>Ist der eingelesene Typ nicht der erwartete Typ, wird eine Exception ausgelöst.</para>
/// </summary>
/// <param name="br"></param>
/// <param name="expectedtyp">Extension des erwarteten Typs z.B. 'LBL', sonst null</param>
protected void ReadCommonHeader(BinaryReaderWriter br, string expectedtyp = null)
{
br.Seek(HeaderOffset);
Headerlength = br.Read2AsUShort();
GarminTyp = br.ReadString(10); // z.B. "GARMIN RGN"
if (GarminTyp.Length != 10 ||
GarminTyp.Substring(0, 7) != "GARMIN ")
{
throw new Exception("Das ist kein Garmin-SUB-File.");
}
if (!string.IsNullOrEmpty(expectedtyp) &&
GarminTyp.Substring(7) != expectedtyp)
{
throw new Exception("Das ist nicht der erwartete Dateityp (" + expectedtyp + ").");
}
Unknown_0x0C = br.ReadByte();
Locked = br.ReadByte();
try {
CreationDate = new DateTime(br.Read2AsShort(),
br.ReadByte(), // "echter" Monat
br.ReadByte(),
br.ReadByte(),
br.ReadByte(),
br.ReadByte());
} catch { // Datum/Uhrzeit nicht erkannt
}
}
/// <summary>
/// muss i.A. überschrieben werden, um den spezifischen Header auch zu speichern
/// </summary>
/// <param name="bw"></param>
protected virtual void Encode_Header(BinaryReaderWriter bw)
{
if (bw != null)
{
WriteCommonHeader(bw, Type);
}
}
public override void Write(BinaryReaderWriter bw, uint headeroffset = 0, UInt16 headerlength = 0x5B, uint gapoffset = 0, uint dataoffset = 0, bool setsectiondata = true)
{
HeaderOffset = headeroffset;
if (headerlength > 0)
{
Headerlength = headerlength;
}
CreationDate = DateTime.Now;
GapOffset = gapoffset;
DataOffset = dataoffset;
bw.SetEncoding(Codepage);
bw.Seek(Headerlength);
Encode_PolygoneData(bw);
Encode_PolylineData(bw);
Encode_POIData(bw);
Encode_Draworder(bw);
SetSectionsAlign();
Encode_Header(bw); // Header mit den akt. Offsets neu erzeugen
Filesections.WriteSections(bw);
}
/// <summary>
/// schreibt das Bitmap als POI in den Stream (falls der Colormode stimmt, sonst Exception)
/// </summary>
/// <param name="bw"></param>
public void WriteAsPoi(BinaryReaderWriter bw)
{
switch (Colormode)
{
case BitmapColorMode.POI_SIMPLE:
case BitmapColorMode.POI_TR:
bw.Write((byte)Width);
bw.Write((byte)Height);
bw.Write((byte)colColorTable.Length);
bw.Write((byte)Colormode);
BinaryColor.WriteColorTable(bw, colColorTable, false);
data.Write(bw);
break;
case BitmapColorMode.POI_ALPHA:
bw.Write((byte)Width);
bw.Write((byte)Height);
bw.Write((byte)colColorTable.Length);
bw.Write((byte)Colormode);
BinaryColor.WriteColorTable(bw, colColorTable, true);
data.Write(bw);
break;
default:
throw new Exception(string.Format("Unerlaubter ColorMode für Bitmap ({0:x2}).", Colormode));
}
}
public void Write(BinaryReaderWriter bw, int codepage)
{
bw.Write((byte)Language);
byte[] txt = Encoding.Convert(Encoding.Unicode, Encoding.GetEncoding(codepage), Encoding.Unicode.GetBytes(Txt));
bw.Write(txt);
bw.Write((byte)0);
}
void Encode_POIData(BinaryReaderWriter bw)
{
List <TableItem> table = new List <TableItem>();
// ----- POI-Block schreiben
// sollte besser aus der max. notwendigen Offsetgröße bestimmt werden (5 --> Offset max. 3 Byte)
PointTableBlock.Recordsize = 5;
PointDatablock.Offset = (uint)bw.Position;
table.Clear();
foreach (POI p in poi.Keys)
{
TableItem tableitem = new TableItem {
Type = p.Type,
Subtype = p.Subtype,
Offset = (int)(bw.Position - PointDatablock.Offset)
};
table.Add(tableitem);
p.Write(bw, Codepage);
}
PointDatablock.Length = (uint)bw.Position - PointDatablock.Offset;
// ----- POI-Tabelle schreiben
PointTableBlock.Offset = (uint)bw.Position; // Standort der Tabelle
for (int i = 0; i < table.Count; i++)
{
table[i].Write(bw, PointTableBlock.Recordsize);
}
PointTableBlock.Length = (uint)bw.Position - PointTableBlock.Offset;
}
/// <summary>
/// liefert die aktuellen Dateidaten (über den <see cref="BinaryReaderWriter"/> des Dateisystems oder aus der Backup-Datei)
/// <para>Wegen der Funktion Stream.Read() darf die internen Datei nicht größer als 0x3FFFFFFF (2 GB) sein.</para>
/// <para>Wenn der IMG-BinaryReaderWriter geliefert wird, werden die Datei-Daten in einen neuen Speicherbereich kopiert und dieser geliefert.</para>
/// </summary>
/// <param name="file"></param>
/// <param name="br"></param>
/// <returns></returns>
protected byte[] getFiledata(FileProps file, BinaryReaderWriter br)
{
if (br == null ||
preblocks4read < 0 ||
File.Exists(file.Backgroundfile))
{
if (File.Exists(file.Backgroundfile))
{
return(File.ReadAllBytes(file.Backgroundfile));
}
// dann ex. noch keine Daten
return(new byte[0]);
}
else
{
if (br != null &&
preblocks4read > 0) // aus dem Originalstream Daten einlesen
{
byte[] data = new byte[file.Filesize]; // neuer Speicherbereich
UInt16[] blocks = file.PseudoFileBlocks();
for (int i = 0; i < blocks.Length; i++)
{
int offset = ImgHeader.FileBlockLength * i;
br.Seek(ImgHeader.FileBlockLength * (long)(preblocks4read + blocks[i]));
br.BaseStream.Read(data,
offset,
file.Filesize - offset >= ImgHeader.FileBlockLength ? ImgHeader.FileBlockLength : (int)file.Filesize - offset);
}
return(data);
}
}
return(null);
}
void Encode_Mdr10(BinaryReaderWriter bw)
{
if (bw != null)
{
throw new Exception("Encode_Mdr10() ist noch nicht implementiert.");
}
}
void Decode_Mdr10(BinaryReaderWriter br, DataBlock block)
{
if (br != null && block != null && block.Length > 0)
{
throw new Exception("Decode_Mdr10() ist noch nicht implementiert.");
}
}
protected override void ReadSections(BinaryReaderWriter br)
{
// --------- Dateiabschnitte für die Rohdaten bilden ---------
Filesections.AddSection((int)InternalFileSections.Mdr1, new DataBlockWithRecordsize(Mdr1));
Filesections.AddSection((int)InternalFileSections.Mdr2, new DataBlockWithRecordsize(Mdr2));
Filesections.AddSection((int)InternalFileSections.Mdr3, new DataBlockWithRecordsize(Mdr3));
Filesections.AddSection((int)InternalFileSections.Mdr4, new DataBlockWithRecordsize(Mdr4));
Filesections.AddSection((int)InternalFileSections.Mdr5, new DataBlockWithRecordsize(Mdr5));
Filesections.AddSection((int)InternalFileSections.Mdr6, new DataBlockWithRecordsize(Mdr6));
Filesections.AddSection((int)InternalFileSections.Mdr7, new DataBlockWithRecordsize(Mdr7));
Filesections.AddSection((int)InternalFileSections.Mdr8, new DataBlockWithRecordsize(Mdr8));
Filesections.AddSection((int)InternalFileSections.Mdr9, new DataBlockWithRecordsize(Mdr9));
Filesections.AddSection((int)InternalFileSections.Mdr10, new DataBlock(Mdr10));
Filesections.AddSection((int)InternalFileSections.Mdr11, new DataBlockWithRecordsize(Mdr11));
Filesections.AddSection((int)InternalFileSections.Mdr12, new DataBlockWithRecordsize(Mdr12));
Filesections.AddSection((int)InternalFileSections.Mdr13, new DataBlockWithRecordsize(Mdr13));
Filesections.AddSection((int)InternalFileSections.Mdr14, new DataBlockWithRecordsize(Mdr14));
Filesections.AddSection((int)InternalFileSections.Mdr15, new DataBlock(Mdr15));
Filesections.AddSection((int)InternalFileSections.Mdr16, new DataBlockWithRecordsize(Mdr16));
Filesections.AddSection((int)InternalFileSections.Mdr17, new DataBlock(Mdr17));
Filesections.AddSection((int)InternalFileSections.Mdr18, new DataBlockWithRecordsize(Mdr18));
// GapOffset und DataOffset setzen
SetSpecialOffsetsFromSections((int)InternalFileSections.PostHeaderData);
if (GapOffset > HeaderOffset + Headerlength) // nur möglich, wenn extern z.B. auf den nächsten Header gesetzt
{
PostHeaderDataBlock = new DataBlock(HeaderOffset + Headerlength, GapOffset - (HeaderOffset + Headerlength));
Filesections.AddSection((int)InternalFileSections.PostHeaderData, PostHeaderDataBlock);
}
// Datenblöcke einlesen
Filesections.ReadSections(br);
}
protected override void Encode_Header(BinaryReaderWriter bw)
{
if (bw != null)
{
base.Encode_Header(bw);
}
}
public void Write(BinaryReaderWriter bw, int iCodepage)
{
bw.Write(Options);
XBitmapDay.WriteAsPoi(bw);
if (WithNightXpm)
{
XBitmapNight.WriteAsPoi(bw);
}
if (WithString)
{
Text.Write(bw, iCodepage);
}
if (WithExtendedOptions)
{
bw.Write(ExtOptions);
switch (FontColType)
{
case FontColours.Day:
BinaryColor.WriteColor(bw, colFontColour[0]);
break;
case FontColours.Night:
BinaryColor.WriteColor(bw, colFontColour[1]);
break;
case FontColours.DayAndNight:
BinaryColor.WriteColorTable(bw, colFontColour);
break;
}
}
}
public void Read(BinaryReaderWriter br, UInt16 recordlen)
{
if (recordlen >= 0x3C)
{
SpecType = br.ReadByte();
No = br.ReadByte();
PointsHoriz = br.Read4Int();
PointsVert = br.Read4Int();
LastRowHeight = br.Read4Int();
LastColWidth = br.Read4Int();
Unknown12 = br.Read2AsShort();
MaxIdxHoriz = br.Read4Int();
MaxIdxVert = br.Read4Int();
Structure = br.Read2AsShort();
short tmp = br.Read2AsShort(); // SubtileTableitemSize: ergibt sich schon aus Structure
PtrSubtileTable = br.Read4UInt();
PtrHeightdata = br.Read4UInt();
west = br.Read4Int();
north = br.Read4Int();
pointDistanceVert = br.Read4Int();
pointDistanceHoriz = br.Read4Int();
MinHeight = br.Read2AsShort();
MaxHeight = br.Read2AsUShort();
}
}
public void Write(BinaryReaderWriter wr)
{
wr.Write((byte)CopyrightCode);
wr.Write((byte)WhereCode);
wr.Write(ExtraProperties);
wr.WriteString(Copyright);
}
protected override void Encode_Header(BinaryReaderWriter bw)
{
if (bw != null)
{
base.Encode_Header(bw);
// Header-Daten schreiben
Nod1Nodes.Write(bw);
bw.Write(Flags);
bw.Write(Unknown_0x1F);
bw.Write(Align);
bw.Write(Mult1);
bw.Write(TableARecordLen);
Nod2RoadData.Write(bw);
bw.Write(Unknown_0x2D);
Nod3BoundaryNodes.Write(bw);
bw.Write(Unknown_0x3B);
Nod4HighClassBoundary.Write(bw);
for (int i = 0; i < ClassBoundaries.Length; i++)
{
bw.Write(ClassBoundaries[i] - (i > 0 ? ClassBoundaries[i - 1] : 0));
}
bw.Write(Unknown_0x5B);
Nod5.Write(bw);
bw.Write(Unknown_0x6F);
Nod6.Write(bw);
bw.Write(Unknown_0x7B);
}
}
public byte[] GetFrameBytesFromData(WebSocketOpCode opCode, byte[] payload, bool isLastFrame)
{
using (MemoryStream memoryStream = new MemoryStream())
{
byte finBitSetAsByte = isLastFrame ? (byte)0x80 : (byte)0x00;
byte byte1 = (byte)(finBitSetAsByte | (byte)opCode);
memoryStream.WriteByte(byte1);
// NB, dont set the mask flag. No need to mask data from server to client
// depending on the size of the length we want to write it as a byte, ushort or ulong
if (payload.Length < 126)
{
byte byte2 = (byte)payload.Length;
memoryStream.WriteByte(byte2);
}
else if (payload.Length <= ushort.MaxValue)
{
byte byte2 = 126;
memoryStream.WriteByte(byte2);
BinaryReaderWriter.WriteUShort((ushort)payload.Length, memoryStream, false);
}
else
{
byte byte2 = 127;
memoryStream.WriteByte(byte2);
BinaryReaderWriter.WriteULong((ulong)payload.Length, memoryStream, false);
}
memoryStream.Write(payload, 0, payload.Length);
byte[] buffer = memoryStream.ToArray();
return(buffer);
}
}
public void Write(BinaryReaderWriter wr)
{
wr.Write(Used);
if (Used)
{
wr.WriteString(Name, null, false);
wr.WriteString(Typ, null, false);
wr.Write(Filesize);
wr.Write(Flag);
wr.Write(Part);
wr.Write(Unknown);
if (blocks.Count > 0)
{
for (int i = 0; i < (BlockSize - 32) / 2; i++)
{
if (i < blocks.Count)
{
wr.Write((UInt16)(blocks[i] < 0xffff ? blocks[i] : 0xffff));
}
else
{
wr.Write((UInt16)0xffff);
}
}
}
}
else
{
for (int i = 1; i < BlockSize; i++)
{
wr.Write((byte)0x00);
}
}
}
public override void ReadHeader(BinaryReaderWriter br)
{
base.ReadCommonHeader(br, Type);
Nod1Nodes.Read(br);
Flags = br.Read2AsUShort();
br.ReadBytes(Unknown_0x1F);
Align = br.ReadByte();
Mult1 = br.ReadByte();
TableARecordLen = br.Read2AsUShort();
Nod2RoadData.Read(br);
br.ReadBytes(Unknown_0x2D);
Nod3BoundaryNodes.Read(br);
br.ReadBytes(Unknown_0x3B);
if (Headerlength > 0x3F)
{
Nod4HighClassBoundary.Read(br); // 0x3F, 8Byte
for (int i = 0; i < ClassBoundaries.Length; i++) // 0x47, 5*4 Bytes
{
ClassBoundaries[i] = br.Read4Int();
if (i > 0)
{
ClassBoundaries[i] += ClassBoundaries[i - 1];
}
}
br.ReadBytes(Unknown_0x5B);
Nod5.Read(br);
br.ReadBytes(Unknown_0x6F);
Nod6.Read(br);
br.ReadBytes(Unknown_0x7B);
}
}
/// <summary>
/// schreibe die aktuellen Daten als MDX-Datei
/// </summary>
/// <param name="wr"></param>
public void Write(BinaryReaderWriter wr)
{
for (int i = 0; i < Maps.Count; i++)
{
Maps[i].Write(wr);
}
}
public void Read(BinaryReaderWriter br)
{
blocks.Clear();
// 0x0
Used = br.ReadByte() == 0x01;
// 0x01
Name = br.ReadString(8);
// 0x09
Typ = br.ReadString(3);
// 0x0c
Filesize = br.Read4UInt();
// 0x10
Flag = br.ReadByte();
// 0x11
Part = br.ReadByte();
// 0x12
Unknown = br.ReadBytes(14);
// 0x20
for (int i = 0; i < MaxBlockNumberCount; i++)
{
UInt16 no = br.Read2AsUShort();
if (no != 0xffff)
{
blocks.Add(no);
}
}
}
void Encode_CharacterLookupTableBlock(BinaryReaderWriter bw)
{
if (bw != null)
{
throw new Exception("Encode_CharacterLookupTableBlock() ist noch nicht implementiert.");
}
}
void Encode_DescriptionBlock(BinaryReaderWriter bw)
{
if (bw != null)
{
bw.WriteString(Description);
}
}
/// <summary>
/// schreibt eine Farbtabelle in den Stream
/// </summary>
/// <param name="bw"></param>
/// <param name="coltable"></param>
/// <param name="bWithAlpha"></param>
public static void WriteColorTable(BinaryReaderWriter bw, Color[] coltable, bool bWithAlpha = false)
{
if (!bWithAlpha)
{
for (int i = 0; i < coltable.Length; i++)
{
bw.Write(coltable[i].B);
bw.Write(coltable[i].G);
bw.Write(coltable[i].R);
}
}
else
{
// Länge der Farbtabelle ermitteln
int len = coltable.Length * 3 + coltable.Length / 2;
if (coltable.Length % 2 == 1)
{
len++;
}
// Farbtabelle erzeugen
byte[] colortable = new byte[len];
byte[] halfbytetable = new byte[2 * len];
for (int i = 0, j = 0; i < coltable.Length; i++)
{
halfbytetable[j++] = (byte)(coltable[i].B & 0xf);
halfbytetable[j++] = (byte)(coltable[i].B >> 4);
halfbytetable[j++] = (byte)(coltable[i].G & 0xf);
halfbytetable[j++] = (byte)(coltable[i].G >> 4);
halfbytetable[j++] = (byte)(coltable[i].R & 0xf);
halfbytetable[j++] = (byte)(coltable[i].R >> 4);
halfbytetable[j++] = (byte)(0xf - ((float)coltable[i].A / 0xff) * 0xf);
}
for (int i = 0; i < colortable.Length; i++)
{
colortable[i] = (byte)(halfbytetable[2 * i] | (halfbytetable[2 * i + 1] << 4));
}
//bool bMoveHalfbyte = false;
//for (int i = 0, dest = 0; i < coltable.Length; i++) {
// byte alpha = (byte)(~coltable[i].A / 255f * 15);
// if (bMoveHalfbyte) {
// colortable[dest++] |= (byte)(coltable[i].B << 4);
// colortable[dest] = (byte)(coltable[i].B >> 4);
// colortable[dest++] |= (byte)(coltable[i].G << 4);
// colortable[dest] = (byte)(coltable[i].G >> 4);
// colortable[dest++] |= (byte)(coltable[i].R << 4);
// colortable[dest] = (byte)(coltable[i].R >> 4);
// colortable[dest++] |= (byte)(alpha << 4);
// } else {
// colortable[dest++] = coltable[i].B;
// colortable[dest++] = coltable[i].G;
// colortable[dest++] = coltable[i].R;
// colortable[dest] = alpha;
// }
// bMoveHalfbyte = !bMoveHalfbyte;
//}
bw.Write(colortable);
}
}
public override void ReadHeader(BinaryReaderWriter br)
{
base.ReadCommonHeader(br, Type);
br.ReadBytes(Unknown_0x15);
// die Header- also Sub-Dateianfänge einlesen
for (int i = 0; i < SubHeaderOffsets.Length; i++)
{
SubHeaderOffsets[i] = br.Read4UInt();
}
if (Headerlength > 0x35)
{
Unknown_0x35 = br.ReadBytes(Headerlength - 0x35);
}
// echte Sub-Dateiheaderlängen aus dem jeweiligen Sub-Datei-Header einlesen
for (int i = 0; i < SubHeaderOffsets.Length; i++)
{
if (SubHeaderOffsets[i] != 0)
{
br.Seek(SubHeaderOffsets[i]);
SubHeaderLength[i] = br.Read2AsUShort();
}
else
{
SubHeaderLength[i] = 0;
}
}
// Subdateiheaderdistanzen berechnen
// - bei SubHeaderOffsets==0 ist auch SubHeaderDistance==0 weil der Header ungültig ist
// - beim letzten SubHeader ist SubHeaderDistance==uint.MaxValue, da es nicht anders geht
for (int i = 0; i < SubHeaderOffsets.Length; i++)
{
if (SubHeaderOffsets[i] > 0 &&
i < SubHeaderOffsets.Length - 1)
{
// nächsten gültigen Subheader suchen
int j = SubHeaderOffsets.Length;
for (j = i + 1; j < SubHeaderOffsets.Length; j++)
{
if (SubHeaderOffsets[j] >= SubHeaderOffsets[i] + SubHeaderLength[i])
{
break;
}
}
if (j < SubHeaderOffsets.Length)
{
SubHeaderDistance[i] = SubHeaderOffsets[j] - SubHeaderOffsets[i];
}
}
else
{
SubHeaderDistance[i] = uint.MaxValue;
}
}
}
void Encode_ContentsBlock(BinaryReaderWriter bw)
{
if (bw != null)
{
(Filesections.GetPosition((int)InternalFileSections.DescriptionBlock) as DataBlock).Write(bw);
(Filesections.GetPosition((int)InternalFileSections.CharacterLookupTableBlock) as DataBlock).Write(bw);
}
}
void Decode_DescriptionBlock(BinaryReaderWriter br, DataBlock block)
{
if (br != null && block != null && block.Length > 0)
{
br.Seek(block.Offset);
Description = br.ReadString((int)block.Length);
}
}
