public void Add(string internalFileName, int position, int length)
{
if (isDisposed)
{
throw new InvalidOperationException();
}
headerLookup.Add(internalFileName, new MyArchiveFileHeaderElement(position, length));
HeaderOrder.Add(position, internalFileName);
using (MemoryStream tempStream = new MemoryStream(TEMP_STREAM_BUFFER))
{
using (BinaryWriter writer = new BinaryWriter(tempStream))
{
writer.Write(internalFileName.Length);
foreach (char c in internalFileName)
{
writer.Write(c);
}
writer.Write(position);
writer.Write(length);
writer.Flush();
var buffer = tempStream.ToArray();
RawHeader.Write(buffer, 0, buffer.Length);
}
}
}
public unsafe int Int32(RawHeader size)
{
int result;
fixed(byte *buf = Data)
{
if (size == RawHeader.Size1)
{
result = (int)(*(sbyte *)(buf + Pos));
Pos++;
}
else if (size == RawHeader.Size2)
{
result = (int)(*(short *)(buf + Pos));
Pos += 2;
}
else if (size == RawHeader.Size3)
{
result = *(ushort *)(buf + Pos) | ((sbyte *)(buf + Pos))[2] << 16;
Pos += 3;
}
else
{
result = (*(int *)(buf + Pos));
Pos += 4;
}
}
return(result);
}
public RawJTEX(Stream input)
{
using (var br = new BinaryReaderX(input))
{
Stream stream;
if (br.ReadByte() == 0x11)
{
br.BaseStream.Position = 0;
uint size = br.ReadUInt32() >> 8;
br.BaseStream.Position = 0;
lz11_compressed = true;
byte[] decomp = LZ11.Decompress(br.BaseStream);
stream = new MemoryStream(decomp);
}
else
{
br.BaseStream.Position = 0;
stream = br.BaseStream;
}
//File.OpenWrite("test.decomp").Write(new BinaryReaderX(stream).ReadBytes((int)stream.Length), 0, (int)stream.Length);
using (BinaryReaderX br2 = new BinaryReaderX(stream))
{
JTEXRawHeader = br2.ReadStruct <RawHeader>();
br2.BaseStream.Position = JTEXRawHeader.dataStart;
Settings = new ImageSettings {
Width = JTEXRawHeader.width, Height = JTEXRawHeader.height, Format = JTEXRawHeader.format
};
Image = Common.Load(br2.ReadBytes((int)(br2.BaseStream.Length - br2.BaseStream.Position)), Settings);
}
}
}
public unsafe long Int64(RawHeader size)
{
long result;
fixed(byte *buf = Data)
{
if (size == RawHeader.Size1)
{
result = (long)(*(sbyte *)(buf + Pos));
Pos++;
}
else if (size == RawHeader.Size2)
{
var num2 = (long)(*(short *)(buf + Pos));
result = num2;
Pos += 2;
}
else if (size == RawHeader.Size3)
{
result = (long)
(*(ushort *)(buf + Pos) |
(ulong)((sbyte *)(buf + Pos))[2] << 16);
Pos += 3;
}
else if (size == RawHeader.Size4)
{
result = (long)(*(int *)(buf + Pos));
Pos += 4;
}
else if (size == RawHeader.Size5)
{
result = (long)
(*(uint *)(buf + Pos) |
(ulong)((sbyte *)(buf + Pos))[4] << 32);
Pos += 5;
}
else if (size == RawHeader.Size6)
{
result = (long)
(*(uint *)(buf + Pos) |
(ulong)((short *)(buf + Pos))[2] << 32);
Pos += 6;
}
else if (size == RawHeader.Size7)
{
result = (long)
(*(uint *)(buf + Pos) | (ulong)((ushort *)(buf + Pos))[2] << 32 |
(ulong)((sbyte *)(buf + Pos))[6] << 48);
Pos += 7;
}
else
{
result = (*(long *)(buf + Pos));
Pos += 8;
}
}
return(result);
}
public RawHeader?TrySimple(RawHeader found, RawHeader expected)
{
if ((found & RawHeader.TypeMask) == expected)
{
MoveNext();
return(found & RawHeader.SizeMask);
}
return(null);
}
private RawHeader Expect(RawHeader expected)
{
var found = buffer.NextType();
var rawHeader = buffer.TrySimple(found, expected);
if (rawHeader.HasValue)
{
return(rawHeader.Value);
}
throw Fail(found, expected);
}
private void ReadFromRawHeader(RawHeader rawHeader)
{
TcpPayloadLengthOrUdpSequenceNumber = rawHeader.TcpPayloadLengthOrUdpSequenceNumber;
Reserved = rawHeader.Reserved;
SynchronizationSourceIdentifier = (int)(rawHeader.Packed & SsrcMask);
PayloadType = (PayloadType)((rawHeader.Packed & PayloadTypeMask) >> PayloadTypeOffset);
ContributorSourceCount = (int)((rawHeader.Packed & CsrcCountMask) >> CsrcCountOffset);
ImportantEvent = Convert.ToBoolean((rawHeader.Packed & EventMask) >> EventOffset);
Padding = Convert.ToBoolean((rawHeader.Packed & PaddingMask) >> PaddingOffset);
VersionNumber = (int)((rawHeader.Packed & VersionNumberMask) >> VersionNumberOffset);
}
void WriteRawFile(String filePath, RawHeader rawHeader, byte[] rawHeaderSerialized, byte[] data)
{
using (var stream = new FileStream(filePath, FileMode.OpenOrCreate))
{
//byte[] rawHeaderSerialized = rawHeader.ToByteArray();
stream.Write(rawHeaderSerialized, 0, rawHeaderSerialized.Length);
int dataSize = rawHeader.numImages * rawHeader.imageWidth * rawHeader.imageHeight * rawHeader.bytesPerPixel;
stream.Write(data, 0, dataSize);
stream.Close();
}
//System.IO.File.WriteAllBytes(filePath, data);
}
public unsafe ulong UInt64(RawHeader size)
{
ulong result;
fixed(byte *buf = Data)
{
if (size == RawHeader.Size1)
{
result = (ulong)(*(buf + Pos));
Pos++;
}
else if (size == RawHeader.Size2)
{
result = (ulong)(*(ushort *)(buf + Pos));
Pos += 2;
}
else if (size == RawHeader.Size3)
{
result = *(ushort *)(buf + Pos) | (ulong)(buf + Pos)[2] << 16;
Pos += 3;
}
else if (size == RawHeader.Size4)
{
result = (ulong)(*(uint *)(buf + Pos));
Pos += 4;
}
else if (size == RawHeader.Size5)
{
result = *(uint *)(buf + Pos) | (ulong)(buf + Pos)[4] << 32;
Pos += 5;
}
else if (size == RawHeader.Size6)
{
result = *(uint *)(buf + Pos) |
(ulong)((ushort *)(buf + Pos))[2] << 32;
Pos += 6;
}
else if (size == RawHeader.SizeMask)
{
result = *(uint *)(buf + Pos) |
(ulong)((ushort *)(buf + Pos))[2] << 32 |
(ulong)(buf + Pos)[6] << 48;
Pos += 7;
}
else
{
result = (ulong)(*(long *)(buf + Pos));
Pos += 8;
}
}
return(result);
}
private unsafe void WriteShortU16(ushort source, RawHeader type)
{
if (source <= Byte.MaxValue)
{
Type(type | RawHeader.Size1);
WriteRawBytes(&source, 1);
}
else
{
Type(type);
WriteRawBytes(&source, 2);
}
}
//public int CompressedHeaderLength { get; set; }
public void Dispose()
{
if (isDisposed)
{
return;
}
headerLookup.Clear();
HeaderOrder.Clear();
RawHeader.Close();
RawHeader.Dispose();
isDisposed = true;
}
private RawHeader WriteToRawHeader()
{
var rawHeader = new RawHeader();
rawHeader.TcpPayloadLengthOrUdpSequenceNumber = TcpPayloadLengthOrUdpSequenceNumber;
rawHeader.Reserved = Reserved;
rawHeader.Packed = (uint)SynchronizationSourceIdentifier;
rawHeader.Packed |= ((uint)PayloadType << PayloadTypeOffset);
rawHeader.Packed |= ((uint)ContributorSourceCount << CsrcCountOffset);
rawHeader.Packed |= (Convert.ToUInt32(ImportantEvent) << EventOffset);
rawHeader.Packed |= (Convert.ToUInt32(Padding) << PaddingOffset);
rawHeader.Packed |= ((uint)VersionNumber << VersionNumberOffset);
return(rawHeader);
}
private RawHeader?ExpectNull(RawHeader expected)
{
var found = buffer.NextType();
var rawHeader = buffer.TrySimple(found, expected);
if (rawHeader.HasValue)
{
return(rawHeader);
}
if (buffer.TrySimple(found, RawHeader.Null).HasValue)
{
return(null);
}
throw Fail(found, expected, RawHeader.Null);
}
public void Start()
{
// HACK(KARAN): This is temporary for saving car controls
if (this.name == "Front" && sw == null)
{
sw = new StreamWriter(Application.dataPath + "\\CapturedImages~\\carControls.csv", false);
}
if (settings.useDefault)
{
settings.imageWidth = 256;
settings.imageHeight = 256;
settings.bytesPerPixel = 3;
settings.numFramesToBuffer = 100;
settings.captureFPS = 15;
}
secondsPerImage = (1.0f / settings.captureFPS);
imageRect = new Rect(0, 0, settings.imageWidth, settings.imageHeight);
/* Texture Formats: RGBA32, RGB24*/
TextureFormat format = settings.bytesPerPixel == 3 ? TextureFormat.RGB24 : TextureFormat.RGBA32;
image = new Texture2D(settings.imageWidth, settings.imageHeight, format, false);
cameraComponent = GetComponent <Camera>();
cameraComponent.targetTexture = new RenderTexture(settings.imageWidth, settings.imageHeight, 0, RenderTextureFormat.ARGB32);
cameraComponent.enabled = false;
// NOTE(KARAN): Setting up of double buffer for the async version.
rawHeader = new RawHeader();
rawHeader.imageHeight = settings.imageHeight;
rawHeader.imageWidth = settings.imageWidth;
rawHeader.bytesPerPixel = settings.bytesPerPixel;
rawHeader.numImages = settings.numFramesToBuffer;
rawHeaderSerialized = rawHeader.ToByteArray();
int fileSize = rawHeader.imageWidth * rawHeader.imageHeight * rawHeader.bytesPerPixel * rawHeader.numImages;
doubleBuffer = new DoubleBuffer(fileSize);
capturedImagesDirectory = Application.dataPath + "\\CapturedImages~\\" + this.name;
if (!Directory.Exists(capturedImagesDirectory))
{
Directory.CreateDirectory(capturedImagesDirectory);
}
}
private unsafe void WriteShortU64(ulong source, RawHeader type)
{
if (source <= Byte.MaxValue)
{
Type(type | RawHeader.Size1);
WriteRawBytes(&source, 1);
}
else if (source <= UInt16.MaxValue)
{
Type(type | RawHeader.Size2);
WriteRawBytes(&source, 2);
}
else if (source <= UInt24_MaxValue)
{
Type(type | RawHeader.Size3);
WriteRawBytes(&source, 3);
}
else if (source <= UInt32.MaxValue)
{
Type(type | RawHeader.Size4);
WriteRawBytes(&source, 4);
}
else if (source <= UInt40_MaxValue)
{
Type(type | RawHeader.Size5);
WriteRawBytes(&source, 5);
}
else if (source <= UInt48_MaxValue)
{
Type(type | RawHeader.Size6);
WriteRawBytes(&source, 6);
}
else if (source <= UInt56_MaxValue)
{
Type(type | RawHeader.Size7);
WriteRawBytes(&source, 7);
}
else
{
Type(type);
WriteRawBytes(&source, 8);
}
}
public unsafe short Int16(RawHeader size)
{
short result;
fixed(byte *buf = Data)
{
if (size == RawHeader.Size1)
{
result = (short)(*(sbyte *)(buf + Pos));
Pos++;
}
else
{
result = (*(short *)(buf + Pos));
Pos += 2;
}
}
return(result);
}
public unsafe char Char(RawHeader size)
{
char result;
fixed(byte *buf = Data)
{
if (size == RawHeader.Size1)
{
result = (char)*(buf + Pos);
Pos++;
}
else
{
result = (char)*(ushort *)(buf + Pos);
Pos += 2;
}
}
return(result);
}
private unsafe void WriteShortU32(uint source, RawHeader type)
{
if (source <= Byte.MaxValue)
{
Type(type | RawHeader.Size1);
WriteRawBytes(&source, 1);
}
else if (source <= UInt16.MaxValue)
{
Type(type | RawHeader.Size2);
WriteRawBytes(&source, 2);
}
else if (source <= UInt24_MaxValue)
{
Type(type | RawHeader.Size3);
WriteRawBytes(&source, 3);
}
else
{
Type(type);
WriteRawBytes(&source, 4);
}
}
/// <summary>
/// Main writer that initiates header writing
/// </summary>
public void Write(Stream headerStream)
{
try
{
if (RawHeader != null)
{
headerStream.WriteByte((Byte)PropertyID.kHeader);
RawHeader.Write(headerStream);
}
else if (EncodedHeader != null)
{
headerStream.WriteByte((Byte)PropertyID.kEncodedHeader);
EncodedHeader.Write(headerStream);
}
else
{
throw new SevenZipException("No header to write.");
}
}
catch (Exception ex)
{
Trace.TraceWarning(ex.GetType().Name + ": " + ex.Message + Environment.NewLine + ex.StackTrace);
}
}
public RawHeader? TrySimple(RawHeader found, RawHeader expected)
{
if ((found & RawHeader.TypeMask) == expected)
{
MoveNext();
return found & RawHeader.SizeMask;
}
return null;
}
private void Type(RawHeader type)
{
data.Add((byte)type);
}
public byte[] Bytes(RawHeader size)
{
return Bytes(Int32(size));
}
public unsafe char Char(RawHeader size)
{
char result;
fixed (byte* buf = Data)
{
if (size == RawHeader.Size1)
{
result = (char)*(buf + Pos);
Pos++;
}
else
{
result = (char)*(ushort*)(buf + Pos);
Pos += 2;
}
}
return result;
}
public TimeSpan Time(RawHeader size)
{
return(new TimeSpan(0, 0, 0, 0, Int32(size)));
}
public byte[] Bytes(RawHeader size)
{
return(Bytes(Int32(size)));
}
public unsafe int Int32(RawHeader size)
{
int result;
fixed (byte* buf = Data)
{
if (size == RawHeader.Size1)
{
result = (int)(*(sbyte*)(buf + Pos));
Pos++;
}
else if (size == RawHeader.Size2)
{
result = (int) (*(short*) (buf + Pos));
Pos += 2;
}
else if (size == RawHeader.Size3)
{
result = *(ushort*) (buf + Pos) | ((sbyte*) (buf + Pos))[2] << 16;
Pos += 3;
}
else
{
result = (*(int*) (buf + Pos));
Pos += 4;
}
}
return result;
}
private SerializationException Fail(RawHeader found, params RawHeader[] expected)
{
return
new SerializationException(
$"Incorrect field type header. expected ({string.Join("|", expected)}) but found ({found}) at position {buffer.Pos}, field {fields_read}");
}
public TimeSpan Time(RawHeader size)
{
return new TimeSpan(0, 0, 0, 0, Int32(size));
}
public unsafe long Int64(RawHeader size)
{
long result;
fixed (byte* buf = Data)
{
if (size == RawHeader.Size1)
{
result = (long)(*(sbyte*)(buf + Pos));
Pos++;
}
else if (size == RawHeader.Size2)
{
var num2 = (long) (*(short*) (buf + Pos));
result = num2;
Pos += 2;
}
else if (size == RawHeader.Size3)
{
result = (long)
(*(ushort*)(buf + Pos) |
(ulong)((sbyte*)(buf + Pos))[2] << 16);
Pos += 3;
}
else if (size == RawHeader.Size4)
{
result = (long)(*(int*)(buf + Pos));
Pos += 4;
}
else if (size == RawHeader.Size5)
{
result = (long)
(*(uint*)(buf + Pos) |
(ulong)((sbyte*)(buf + Pos))[4] << 32);
Pos += 5;
}
else if (size == RawHeader.Size6)
{
result = (long)
(*(uint*)(buf + Pos) |
(ulong)((short*)(buf + Pos))[2] << 32);
Pos += 6;
}
else if (size == RawHeader.Size7)
{
result = (long)
(*(uint*)(buf + Pos) | (ulong)((ushort*)(buf + Pos))[2] << 32 |
(ulong)((sbyte*)(buf + Pos))[6] << 48);
Pos += 7;
}
else
{
result = (*(long*)(buf + Pos));
Pos += 8;
}
}
return result;
}
public string String(RawHeader size)
{
return Encoding.UTF8.GetString(Bytes(Int16(size)));
}
public MP3Header()
{
Header = new RawHeader();
}
private unsafe void WriteShortU32(uint source, RawHeader type)
{
if (source <= Byte.MaxValue)
{
Type(type | RawHeader.Size1);
WriteRawBytes(&source, 1);
}
else if (source <= UInt16.MaxValue)
{
Type(type | RawHeader.Size2);
WriteRawBytes(&source, 2);
}
else if (source <= UInt24_MaxValue)
{
Type(type | RawHeader.Size3);
WriteRawBytes(&source, 3);
}
else
{
Type(type);
WriteRawBytes(&source, 4);
}
}
private RawHeader? ExpectNull(RawHeader expected)
{
var found = buffer.NextType();
var rawHeader = buffer.TrySimple(found, expected);
if (rawHeader.HasValue) return rawHeader;
if (buffer.TrySimple(found, RawHeader.Null).HasValue) return null;
throw Fail(found, expected, RawHeader.Null);
}
public unsafe short Int16(RawHeader size)
{
short result;
fixed (byte* buf = Data)
{
if (size == RawHeader.Size1)
{
result = (short)(*(sbyte*)(buf + Pos));
Pos++;
}
else
{
result = (*(short*)(buf + Pos));
Pos += 2;
}
}
return result;
}
private RawHeader Expect(RawHeader expected)
{
var found = buffer.NextType();
var rawHeader = buffer.TrySimple(found, expected);
if (rawHeader.HasValue) return rawHeader.Value;
throw Fail(found, expected);
}
private SerializationException Fail(RawHeader found, params RawHeader[] expected)
{
return
(new SerializationException(
$"Incorrect field type header. expected ({string.Join("|", expected)}) but found ({found}) at position {buffer.Pos}, field {fields_read}"));
}
private unsafe void WriteShortU64(ulong source, RawHeader type)
{
if (source <= Byte.MaxValue)
{
Type(type | RawHeader.Size1);
WriteRawBytes(&source, 1);
}
else if (source <= UInt16.MaxValue)
{
Type(type | RawHeader.Size2);
WriteRawBytes(&source, 2);
}
else if (source <= UInt24_MaxValue)
{
Type(type | RawHeader.Size3);
WriteRawBytes(&source, 3);
}
else if (source <= UInt32.MaxValue)
{
Type(type | RawHeader.Size4);
WriteRawBytes(&source, 4);
}
else if (source <= UInt40_MaxValue)
{
Type(type | RawHeader.Size5);
WriteRawBytes(&source, 5);
}
else if (source <= UInt48_MaxValue)
{
Type(type | RawHeader.Size6);
WriteRawBytes(&source, 6);
}
else if (source <= UInt56_MaxValue)
{
Type(type | RawHeader.Size7);
WriteRawBytes(&source, 7);
}
else
{
Type(type);
WriteRawBytes(&source, 8);
}
}
public unsafe ulong UInt64(RawHeader size)
{
ulong result;
fixed (byte* buf = Data)
{
if (size == RawHeader.Size1)
{
result = (ulong) (*(buf + Pos));
Pos++;
}
else if (size == RawHeader.Size2)
{
result = (ulong) (*(ushort*) (buf + Pos));
Pos += 2;
}
else if (size == RawHeader.Size3)
{
result = *(ushort*) (buf + Pos) | (ulong) (buf + Pos)[2] << 16;
Pos += 3;
}
else if (size == RawHeader.Size4)
{
result = (ulong) (*(uint*) (buf + Pos));
Pos += 4;
}
else if (size == RawHeader.Size5)
{
result = *(uint*) (buf + Pos) | (ulong) (buf + Pos)[4] << 32;
Pos += 5;
}
else if (size == RawHeader.Size6)
{
result = *(uint*) (buf + Pos) |
(ulong) ((ushort*) (buf + Pos))[2] << 32;
Pos += 6;
}
else if (size == RawHeader.SizeMask)
{
result = *(uint*) (buf + Pos) |
(ulong) ((ushort*) (buf + Pos))[2] << 32 |
(ulong) (buf + Pos)[6] << 48;
Pos += 7;
}
else
{
result = (ulong) (*(long*) (buf + Pos));
Pos += 8;
}
}
return result;
}
public string String(RawHeader size)
{
return(Encoding.UTF8.GetString(Bytes(Int16(size))));
}
private void Type(RawHeader type)
{
data.Add((byte)type);
}
private unsafe void WriteShortU16(ushort source, RawHeader type)
{
if (source <= Byte.MaxValue)
{
Type(type | RawHeader.Size1);
WriteRawBytes(&source, 1);
}
else
{
Type(type);
WriteRawBytes(&source, 2);
}
}
internal DataCoreBinary(byte[] data)
{
Reader = new BinaryBlobReader(data, 0);
header = Reader.Read <RawHeader>();
structureDefinitions = Reader.Read <RawStructure>(header.structDefinitionCount);
propertyDefinitions = Reader.Read <RawProperty>(header.propertyDefinitionCount);
enumDefinitions = Reader.Read <RawEnum>(header.enumDefinitionCount);
datamappingDefinitions = Reader.Read <RawDataMapping>(header.dataMappingCount);
records = Reader.Read <RawRecord>(header.recordDefinitionCount);
int8Values = Reader.Read <sbyte>(header.int8ValueCount);
int16Values = Reader.Read <Int16>(header.int16ValueCount);
int32Values = Reader.Read <Int32>(header.int32ValueCount);
int64Values = Reader.Read <Int64>(header.int64ValueCount);
UInt8Values = Reader.Read <byte>(header.uInt8ValueCount);
UInt16Values = Reader.Read <UInt16>(header.uInt16ValueCount);
UInt32Values = Reader.Read <UInt32>(header.uInt32ValueCount);
UInt64Values = Reader.Read <UInt64>(header.uInt64ValueCount);
booleanValues = Reader.Read <bool>(header.booleanValueCount);
singleValues = Reader.Read <float>(header.singleValueCount);
doubleValues = Reader.Read <double>(header.doubleValueCount);
guidValues = Reader.Read <Guid>(header.guidValueCount);
stringValues = Reader.Read <RawStringReference>(header.stringValueCount);
localeValues = Reader.Read <RawLocaleReference>(header.localeValueCount);
enumValues = Reader.Read <Int32>(header.enumValueCount);
strongValues = Reader.Read <RawStrongPointer>(header.strongValueCount);
weakValues = Reader.Read <RawWeakPointer>(header.weakValueCount);
referenceValues = Reader.Read <RawReference>(header.referenceValueCount);
enumValueNameTable = Reader.Read <RawStringReference>(header.enumOptionCount);
textBlock = new TextBlock(Reader, header.textLength);
var start = Reader.Position;
DataChunk = Reader.Read <byte>(Reader.Length - start);
Reader.Position = start;
#if DEBUG
Console.WriteLine("--------------------------- READ DCB ---------------------------");
Console.WriteLine($"structureDefinitions: {structureDefinitions.Length}");
Console.WriteLine($"propertyDefinitions: {propertyDefinitions.Length}");
Console.WriteLine($"enumDefinitions: {enumDefinitions.Length}");
Console.WriteLine($"datamappingDefinitions: {datamappingDefinitions.Length}");
Console.WriteLine($"records: {records.Length}");
Console.WriteLine();
Console.WriteLine($"int8Values: {int8Values.Length}");
Console.WriteLine($"int16Values: {int16Values.Length}");
Console.WriteLine($"int32Values: {int32Values.Length}");
Console.WriteLine($"int64Values: {int64Values.Length}");
Console.WriteLine($"UInt8Values: {UInt8Values.Length}");
Console.WriteLine($"UInt16Values: {UInt16Values.Length}");
Console.WriteLine($"UInt32Values: {UInt32Values.Length}");
Console.WriteLine($"UInt64Values: {UInt64Values.Length}");
Console.WriteLine($"booleanValues: {booleanValues.Length}");
Console.WriteLine();
Console.WriteLine($"singleValues: {singleValues.Length}");
Console.WriteLine($"doubleValues: {doubleValues.Length}");
Console.WriteLine();
Console.WriteLine($"stringValues: {stringValues.Length}");
Console.WriteLine($"localeValues: {localeValues.Length}");
Console.WriteLine();
Console.WriteLine($"enumValues: {enumValues.Length}");
Console.WriteLine($"strongValues: {strongValues.Length}");
Console.WriteLine($"weakValues: {weakValues.Length}");
Console.WriteLine($"referenceValues: {referenceValues.Length}");
Console.WriteLine($"enumValueNameTable: {enumValueNameTable.Length}");
Console.WriteLine();
Console.WriteLine($"textBlock: {textBlock.Size}");
Console.WriteLine("------------------------- END READ DCB -------------------------");
#endif
}
