public LimgState()
{
_limg = new Limg();
EncodingDefinition = LimgSupport.LimgPaletteFormats.ToPaletteDefinition();
EncodingDefinition.AddIndexEncodings(LimgSupport.LimgFormats);
}
public GxtState()
{
_gxt = new GXT();
EncodingDefinition = GxtSupport.GxtFormats.ToColorDefinition();
EncodingDefinition.AddIndexEncodings(GxtSupport.GxtIndexFormats);
}
/// <summary>
/// Defines the encoding method to use for the server.
/// </summary>
/// <param name="encoding"></param>
public void SetEncodingMode(EncodingDefinition encoding)
{
m_encodingMode = Library.CreateStreamEncoding <TKey, TValue>(encoding);
m_stream.Write((byte)ServerCommand.SetEncodingMethod);
encoding.Save(m_stream);
m_stream.Flush();
var command = (ServerResponse)m_stream.ReadUInt8();
switch (command)
{
case ServerResponse.UnhandledException:
string exception = m_stream.ReadString();
throw new Exception("Server UnhandledExcetion: \n" + exception);
case ServerResponse.UnknownEncodingMethod:
throw new Exception("Server does not recgonize encoding method");
case ServerResponse.EncodingMethodAccepted:
break;
default:
throw new Exception("Unknown server response: " + command.ToString());
}
}
private Bitmap DecodeImage(IProgressContext progress = null)
{
if (_decodedImage != null)
{
return(_decodedImage);
}
Func <Bitmap> decodeImageAction;
if (IsIndexed)
{
var transcoder = CreateImageConfiguration(ImageFormat, PaletteFormat)
.Transcode.With(EncodingDefinition.GetIndexEncoding(ImageFormat).IndexEncoding)
.TranscodePalette.With(EncodingDefinition.GetPaletteEncoding(PaletteFormat))
.Build();
decodeImageAction = () => transcoder.Decode(ImageInfo.ImageData, ImageInfo.PaletteData, ImageInfo.ImageSize, progress);
}
else
{
var transcoder = CreateImageConfiguration(ImageFormat, PaletteFormat)
.Transcode.With(EncodingDefinition.GetColorEncoding(ImageFormat))
.Build();
decodeImageAction = () => transcoder.Decode(ImageInfo.ImageData, ImageInfo.ImageSize, progress);
}
ExecuteActionWithProgress(() => _decodedImage = decodeImageAction(), progress);
_bestImage ??= _decodedImage;
return(_decodedImage);
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_directoryMethod = (ArchiveDirectoryMethod)stream.ReadInt32();
m_prefix = stream.ReadString();
m_pendingExtension = stream.ReadString();
m_finalExtension = stream.ReadString();
m_desiredRemainingSpace = stream.ReadInt64();
m_encodingMethod = new EncodingDefinition(stream);
int cnt = stream.ReadInt32();
m_writePath.Clear();
while (cnt > 0)
{
cnt--;
m_writePath.Add(stream.ReadString());
}
cnt = stream.ReadInt32();
m_flags.Clear();
while (cnt > 0)
{
cnt--;
m_flags.Add(stream.ReadGuid());
}
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
public static EncodingDefinition GetEncodingDefinition(MtTexPlatform platform)
{
var definition = new EncodingDefinition();
switch (platform)
{
case MtTexPlatform.N3DS:
definition.AddColorEncodings(CtrFormats);
break;
case MtTexPlatform.Switch:
definition.AddColorEncodings(SwitchFormats);
break;
case MtTexPlatform.PS3:
definition.AddColorEncodings(Ps3Formats);
definition.AddColorShaders(Shaders);
break;
case MtTexPlatform.Mobile:
definition.AddColorEncodings(MobileFormats);
break;
case MtTexPlatform.Wii:
throw new InvalidOperationException("Cannot obtain encoding definition for Wii MT Tex.");
}
return(definition);
}
private void CreateArchiveFile <TKey, TValue>(SubFileName fileName, EncodingDefinition storageMethod, int maxSortedTreeBlockSize)
where TKey : SnapTypeBase <TKey>, new()
where TValue : SnapTypeBase <TValue>, new()
{
if (maxSortedTreeBlockSize < 1024)
{
throw new ArgumentOutOfRangeException(nameof(maxSortedTreeBlockSize), "Must be greater than 1024");
}
if ((object)storageMethod == null)
{
throw new ArgumentNullException("storageMethod");
}
using (TransactionalEdit trans = m_fileStructure.BeginEdit())
{
using (SubFileStream fs = trans.CreateFile(fileName))
using (BinaryStream bs = new BinaryStream(fs))
{
int blockSize = m_fileStructure.Snapshot.Header.DataBlockSize;
while (blockSize > maxSortedTreeBlockSize)
{
blockSize >>= 2;
}
SortedTree <TKey, TValue> tree = SortedTree <TKey, TValue> .Create(bs, blockSize, storageMethod);
tree.Flush();
}
trans.ArchiveType = FileType;
trans.CommitAndDispose();
}
}
/// <summary>
/// Loads a <see cref="DatabaseInfo"/> from stream.
/// </summary>
/// <param name="stream"></param>
public DatabaseInfo(BinaryStreamBase stream)
{
byte version = stream.ReadUInt8();
switch (version)
{
case 1:
DatabaseName = stream.ReadString();
KeyTypeID = stream.ReadGuid();
ValueTypeID = stream.ReadGuid();
int count = stream.ReadInt32();
EncodingDefinition[] definitions = new EncodingDefinition[count];
for (int x = 0; x < count; x++)
{
definitions[x] = new EncodingDefinition(stream);
}
SupportedStreamingModes = new ReadOnlyCollection <EncodingDefinition>(definitions);
KeyType = Library.GetSortedTreeType(KeyTypeID);
ValueType = Library.GetSortedTreeType(ValueTypeID);
break;
default:
throw new VersionNotFoundException("Unknown version code.");
}
}
public GcBnrState()
{
_bnr = new GcBnr();
EncodingDefinition = new EncodingDefinition();
EncodingDefinition.AddColorEncoding(0, new Rgba(5, 5, 5, 1, "ABGR", ByteOrder.BigEndian));
}
internal void InitializeCreate(EncodingDefinition treeNodeType, int blockSize)
{
if (m_isInitialized)
{
throw new Exception("Duplicate calls to Initialize");
}
if ((object)treeNodeType == null)
{
throw new ArgumentNullException("treeNodeType");
}
m_isInitialized = true;
m_header.TreeNodeType = treeNodeType;
m_header.BlockSize = blockSize;
m_header.RootNodeLevel = 0;
m_header.RootNodeIndexAddress = 1;
m_header.LastAllocatedBlock = 1;
Initialize();
LeafStorage.CreateEmptyNode(m_header.RootNodeIndexAddress);
m_header.IsDirty = true;
m_header.SaveHeader(Stream);
}
private void AssertPaletteFormatExists(int paletteFormat)
{
if (EncodingDefinition.GetPaletteEncoding(paletteFormat) == null)
{
throw new InvalidOperationException($"The palette format '{paletteFormat}' is not supported by the plugin.");
}
}
public void TestArchiveWriter()
{
Random r = new Random(3);
_ = new EncodingDefinition(EncodingDefinition.FixedSizeIndividualGuid, EncodingDefinition.FixedSizeIndividualGuid);
AdvancedServerDatabaseConfig <AmiKey, AmiKey> config = new AdvancedServerDatabaseConfig <AmiKey, AmiKey>("KV2CPQ", "C:\\Temp\\AMI", true);
using (SnapServer server = new SnapServer(config))
{
using (SnapClient client = SnapClient.Connect(server))
using (ClientDatabaseBase <AmiKey, AmiKey> db = client.GetDatabase <AmiKey, AmiKey>("KV2CPQ"))
{
int count = 10000000;
Stopwatch sw = new Stopwatch();
sw.Start();
AmiKey key = new AmiKey();
AmiKey value = new AmiKey();
for (int x = count; x >= 0; x--)
{
key.Timestamp = (ulong)r.Next();
key.TableId = r.Next();
db.Write(key, value);
}
sw.Stop();
Console.WriteLine(count / sw.Elapsed.TotalSeconds / 1000000);
Console.WriteLine(count);
}
}
}
public static EncodingDefinition GetEncodingDefinition()
{
var definition = new EncodingDefinition();
definition.AddColorEncodings(CitraFormats);
return(definition);
}
public static EncodingDefinition GetCafeDefinition()
{
var definition = new EncodingDefinition();
definition.AddColorEncodings(Nw4cImageFormats.CafeFormats);
return(definition);
}
/// <summary>
/// Creates a <see cref="ArchiveInitializer{TKey,TValue}"/> that will reside in memory.
/// </summary>
/// <param name="encodingMethod">the encoding method to use for the archive file.</param>
/// <param name="flags">flags to include in the archive that is created.</param>
/// <returns></returns>
public void ConfigureInMemory(EncodingDefinition encodingMethod, params Guid[] flags)
{
TestForEditable();
Initialize();
IsMemoryArchive = true;
Flags.AddRange(flags);
EncodingMethod = encodingMethod;
}
public BnrState()
{
_bnr = new Bnr();
EncodingDefinition = new EncodingDefinition();
EncodingDefinition.AddPaletteEncoding(0, ImageFormats.Rgb555());
EncodingDefinition.AddIndexEncoding(0, ImageFormats.I4(BitOrder.LeastSignificantBitFirst), new[] { 0 });
}
private void AssertImageFormatExists(int imageFormat)
{
if (EncodingDefinition.GetColorEncoding(imageFormat) == null &&
EncodingDefinition.GetIndexEncoding(imageFormat) == null)
{
throw new InvalidOperationException($"The image format '{imageFormat}' is not supported by the plugin.");
}
}
/// <summary>
/// Decode given palette data without buffering.
/// </summary>
/// <param name="paletteData">Palette data to decode.</param>
/// <param name="context"></param>
/// <returns>Decoded palette.</returns>
private IList <Color> DecodePalette(byte[] paletteData, IProgressContext context = null)
{
var paletteEncoding = EncodingDefinition.GetPaletteEncoding(PaletteFormat);
return(paletteEncoding
.Load(paletteData, new EncodingLoadContext(new Size(1, paletteData.Length * 8 / paletteEncoding.BitsPerValue), TaskCount))
.ToArray());
}
public static EncodingDefinition GetEncodingDefinition()
{
var definition = new EncodingDefinition();
definition.AddColorEncodings(Formats.ToDictionary(x => (int)x.Key, y => y.Value));
return(definition);
}
public BtxState()
{
_btx = new BTX();
EncodingDefinition = BtxSupport.Encodings.ToColorDefinition();
EncodingDefinition.AddPaletteEncodings(BtxSupport.PaletteEncodings);
EncodingDefinition.AddIndexEncodings(BtxSupport.IndexEncodings);
}
public ECDPNcgrState()
{
_ncgr = new ECDPNcgr();
EncodingDefinition = new EncodingDefinition();
EncodingDefinition.AddPaletteEncoding(0, new Rgba(5, 5, 5, "BGR"));
EncodingDefinition.AddIndexEncoding(3, new Index(4), new[] { 0 });
EncodingDefinition.AddIndexEncoding(4, new Index(8), new[] { 0 });
}
public NcgrState()
{
_ncgr = new Ncgr();
EncodingDefinition = new EncodingDefinition();
EncodingDefinition.AddPaletteEncoding(0, new Rgba(5, 5, 5, "BGR"));
EncodingDefinition.AddIndexEncoding(3, ImageFormats.I4(BitOrder.LeastSignificantBitFirst), new[] { 0 });
EncodingDefinition.AddIndexEncoding(4, ImageFormats.I8(), new[] { 0 });
}
public static EncodingDefinition GetEncodingDefinition()
{
var definition = new EncodingDefinition();
definition.AddPaletteEncodings(PaletteFormats);
definition.AddIndexEncodings(IndexFormats.Select(x => (x.Key, new IndexEncodingDefinition(x.Value, new[] { 0 }))).ToArray());
return(definition);
}
public static EncodingDefinition GetEncodingDefinition()
{
var definition = new EncodingDefinition();
definition.AddColorEncodings(ColorFormats);
definition.AddPaletteEncodings(PaletteFormats);
definition.AddIndexEncodings(IndexFormats);
return(definition);
}
/// <summary>
/// Writes the supplied stream to the binary stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="blockSize"></param>
/// <param name="treeNodeType"></param>
/// <param name="treeStream"></param>
public static void Create(BinaryStreamPointerBase stream, int blockSize, EncodingDefinition treeNodeType, TreeStream <TKey, TValue> treeStream)
{
if (stream is null)
{
throw new ArgumentNullException("stream");
}
if (treeStream is null)
{
throw new ArgumentNullException("stream");
}
if (treeNodeType is null)
{
throw new ArgumentNullException("treeNodeType");
}
if (!(treeStream.IsAlwaysSequential && treeStream.NeverContainsDuplicates))
{
throw new ArgumentException("Stream must gaurentee sequential reads and that it never will contain a duplicate", "treeStream");
}
SortedTreeHeader header = new SortedTreeHeader();
header.TreeNodeType = treeNodeType;
header.BlockSize = blockSize;
header.RootNodeLevel = 0;
header.RootNodeIndexAddress = 1;
header.LastAllocatedBlock = 1;
Func <uint> getNextNewNodeIndex = () =>
{
header.LastAllocatedBlock++;
return(header.LastAllocatedBlock);
};
SparseIndexWriter <TKey> indexer = new SparseIndexWriter <TKey>();
NodeWriter <TKey, TValue> .Create(treeNodeType, stream, header.BlockSize, header.RootNodeLevel, header.RootNodeIndexAddress, getNextNewNodeIndex, indexer, treeStream);
while (indexer.Count > 0)
{
indexer.SwitchToReading();
header.RootNodeLevel++;
header.RootNodeIndexAddress = getNextNewNodeIndex();
SparseIndexWriter <TKey> indexer2 = new SparseIndexWriter <TKey>();
NodeWriter <TKey, SnapUInt32> .Create(EncodingDefinition.FixedSizeCombinedEncoding, stream, header.BlockSize, header.RootNodeLevel, header.RootNodeIndexAddress, getNextNewNodeIndex, indexer2, indexer);
indexer.Dispose();
indexer = indexer2;
}
indexer.Dispose();
header.IsDirty = true;
header.SaveHeader(stream);
}
public static EncodingDefinition GetEncodingDefinition()
{
var definition = new EncodingDefinition();
definition.AddColorEncodings(ColorFormats.Select(x => ((int)x.Key, x.Value)).ToArray());
definition.AddPaletteEncodings(PaletteFormats.Select(x => ((int)x.Key, x.Value)).ToArray());
definition.AddIndexEncodings(IndexFormats.Select(x => ((int)x.Key, new IndexEncodingDefinition(x.Value, PaletteFormats.Keys.Select(x => (int)x).ToArray()))).ToArray());
return(definition);
}
public BitmapKanvasImage(Bitmap image)
{
var encoding = GetImageEncoding(image);
EncodingDefinition = new EncodingDefinition();
EncodingDefinition.AddColorEncoding(0, encoding);
BitDepth = encoding.BitDepth;
_image = image;
}
public static EncodingDefinition GetEncodingDefinition()
{
var definition = new EncodingDefinition();
definition.AddPaletteEncodings(PaletteEncodings);
definition.AddIndexEncodings(IndexFormats.Select(x => (x.Key, new IndexEncodingDefinition(x.Value, new[] { 0x6C09, 0x6409 }))).ToArray());
definition.AddPaletteShader(0x6C09, new HtexColorShader());
return(definition);
}
/// <summary>
/// Creates a new instance of <see cref="KanvasImage"/>.
/// </summary>
/// <param name="encodingDefinition">The encoding definition for the image info.</param>
/// <param name="imageInfo">The image info to represent.</param>
public KanvasImage(EncodingDefinition encodingDefinition, ImageInfo imageInfo)
{
ContractAssertions.IsNotNull(encodingDefinition, nameof(encodingDefinition));
ContractAssertions.IsNotNull(imageInfo, nameof(imageInfo));
if (!encodingDefinition.Supports(imageInfo))
{
throw new InvalidOperationException("The encoding definition can not support the image info.");
}
_encodingDefinition = encodingDefinition;
ImageInfo = imageInfo;
}
/// <summary>
/// Opens the default table for this TKey and TValue. If it does not exists,
/// it will be created with the provided compression method.
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
/// <param name="storageMethod">The method of compression to utilize in this table.</param>
/// <param name="maxSortedTreeBlockSize">the maximum desired block size for a SortedTree. Must be at least 1024.</param>
/// <returns></returns>
public SortedTreeTable <TKey, TValue> OpenOrCreateTable <TKey, TValue>(EncodingDefinition storageMethod, int maxSortedTreeBlockSize = 4096)
where TKey : SnapTypeBase <TKey>, new()
where TValue : SnapTypeBase <TValue>, new()
{
if ((object)storageMethod == null)
{
throw new ArgumentNullException("storageMethod");
}
SubFileName fileName = GetFileName <TKey, TValue>();
return(OpenOrCreateTable <TKey, TValue>(storageMethod, fileName, maxSortedTreeBlockSize));
}
/// <summary>
/// Reads the header data.
/// </summary>
/// <param name="stream"></param>
/// <param name="treeNodeType"></param>
/// <param name="blockSize"></param>
internal static void ReadHeader(BinaryStreamBase stream, out EncodingDefinition treeNodeType, out int blockSize)
{
stream.Position = 0;
byte version = stream.ReadUInt8();
if (version == 109)
{
stream.Position = 0;
stream.ReadGuid();
treeNodeType = new EncodingDefinition(stream.ReadGuid());
blockSize = stream.ReadInt32();
}
else if (version == 1)
{
blockSize = stream.ReadInt32();
treeNodeType = new EncodingDefinition(stream);
}
else
{
throw new VersionNotFoundException();
}
}
/// <summary>
/// Loads a <see cref="DatabaseInfo"/> from stream.
/// </summary>
/// <param name="stream"></param>
public DatabaseInfo(BinaryStreamBase stream)
{
byte version = stream.ReadUInt8();
switch (version)
{
case 1:
DatabaseName = stream.ReadString();
KeyTypeID = stream.ReadGuid();
ValueTypeID = stream.ReadGuid();
var count = stream.ReadInt32();
EncodingDefinition[] definitions = new EncodingDefinition[count];
for (int x = 0; x < count; x++)
{
definitions[x] = new EncodingDefinition(stream);
}
SupportedStreamingModes = new ReadOnlyCollection<EncodingDefinition>(definitions);
KeyType = Library.GetSortedTreeType(KeyTypeID);
ValueType = Library.GetSortedTreeType(ValueTypeID);
break;
default:
throw new VersionNotFoundException("Unknown version code.");
}
}
