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); } }