// Main Constructor
public Fridge
(int Price, int OverallVolume, int Weight, int Height, int Width, int Depth,
string Name, string Manufacturer, string Color, string ProducingCountry,
bool Display, bool DefrostSystem, bool RehangingDoors, byte[] DeviceImage,
InstallationMethodType InstallationMethod, ControlType ControlType,
int NoiseLevel, string Refrigerant, EnergyClassType EnergyClass,
int CompressorsAmount, int FridgeUsefulVolume, int FreezerUsefulVolume,
bool FreshnessZone, bool MiniBar,
FreezerLocationType FreezerLocation, CompressorType CompressorType, FridgeType DeviceType) : base
(Price, OverallVolume, Weight, Height, Width, Depth,
Name, Manufacturer, Color, ProducingCountry,
Display, DefrostSystem, RehangingDoors, DeviceImage,
InstallationMethod, ControlType,
NoiseLevel, Refrigerant, EnergyClass)
{
// Int
this.CompressorsAmount = CompressorsAmount;
this.FridgeUsefulVolume = FridgeUsefulVolume;
this.FreezerUsefulVolume = FreezerUsefulVolume;
// Bool
this.FreshnessZone = FreshnessZone;
this.MiniBar = MiniBar;
// Enums
this.DeviceType = DeviceType;
this.CompressorType = CompressorType;
this.FreezerLocation = FreezerLocation;
}
public static ICompressor New(CompressorType typeId)
{
ICompressor compressor = null;
switch (typeId)
{
case CompressorType.None: compressor = new NoneCompressor(); break;
case CompressorType.Zip: try { compressor = new ZipNativeCompressor(); }
catch { compressor = new ZipManagedCompressor(); } break;
case CompressorType.BZip2: try { compressor = new BZ2NativeCompressor(); }
catch { compressor = new BZ2ManagedCompressor(); } break;
case CompressorType.NativeZip: compressor = new ZipNativeCompressor(); break;
case CompressorType.ManagedZip: compressor = new ZipManagedCompressor(); break;
case CompressorType.NativeBZip2: compressor = new BZ2NativeCompressor(); break;
case CompressorType.ManagedBZip2: compressor = new BZ2ManagedCompressor(); break;
default: throw new ArgumentOutOfRangeException("Unknown compressor typeId.");
}
return(compressor);
}
private void Initialize(WaveFormat waveFormat)
{
_channelCount = waveFormat.Channels;
_sampleRate = waveFormat.SampleRate;
_samplePosition = 0;
_chunkSize = _channelCount * ChannelChunkSize;
_slope = 1.0f / _module.Ratio;
var attackSamples = _sampleRate * _module.Attack;
_alphaAttack = (float)Math.Exp(-1f / attackSamples);
var releaseSamples = _sampleRate * _module.Release;
_alphaRelease = (float)Math.Exp(-1f / releaseSamples);
_type = _module.Type;
_attack = _module.Attack;
_release = _module.Release;
_ratio = _module.Ratio;
_threshold = _module.Threshold;
_knee = _module.Knee;
_amount = _module.Amount;
_makeUpGain = _module.MakeUpGain;
}
public void Encoder_should_read_the_previously_written_message(
CompressorType compressorType,
object compressionOption)
{
var message = CreateMessage(1, 2);
var compressedMessage = GetCompressedMessage(message, compressorType);
using (compressedMessage.OriginalMessageStream)
{
CompressorConfiguration compressionProperty = new CompressorConfiguration(compressorType);
if (compressionOption != null)
{
compressionProperty.Properties.Add("Level", compressionOption);
}
using (var memoryStream = new MemoryStream())
{
var subject = CreateSubject(memoryStream, compressionProperty);
subject.WriteMessage(compressedMessage);
memoryStream.Position = 0;
var result = subject.ReadMessage();
result.ShouldBeEquivalentTo(
compressedMessage,
options =>
options
.Excluding(p => p.OriginalMessageStream));
}
}
}
public void Zlib_should_read_the_previously_written_message(CompressorType compressorType, int compressionOption)
{
var bytes = Encoding.ASCII.GetBytes(__testMessage);
int zlibHeaderSize = 21;
Assert(
bytes,
(input, output) =>
{
var compressor = GetCompressor(compressorType, compressionOption);
compressor.Compress(input, output);
if (compressionOption != 0)
{
input.Length.Should().BeGreaterThan(output.Length);
}
else
{
output.Length.Should().Be(input.Length + zlibHeaderSize);
}
input.Position = 0;
input.SetLength(0);
output.Position = 0;
compressor.Decompress(output, input);
},
(input, output) =>
{
input.Position = 0;
var result = Encoding.ASCII.GetString(input.ReadBytes((int)input.Length));
result.Should().Be(__testMessage);
});
}
public void Encoder_should_read_the_previously_written_message_or_throw_the_exception_if_the_current_platform_is_not_supported(
CompressorType compressorType)
{
var message = CreateMessage(1, 2);
var compressedMessage = GetCompressedMessage(message, compressorType);
using (compressedMessage.OriginalMessageStream)
{
CompressorConfiguration compressionProperty = new CompressorConfiguration(compressorType);
using (var memoryStream = new MemoryStream())
{
var subject = CreateSubject(memoryStream, compressionProperty);
#if NET452 || NETSTANDARD2_0
subject.WriteMessage(compressedMessage);
memoryStream.Position = 0;
var result = subject.ReadMessage();
result.ShouldBeEquivalentTo(
compressedMessage,
options =>
options
.Excluding(p => p.OriginalMessageStream));
#else
var exception = Record.Exception(() => { subject.WriteMessage(compressedMessage); });
exception.Should().BeOfType <NotSupportedException>();
#endif
}
}
}
public Compressor(int threshold = -10, double gain = 0.60, int gatedB = -25, CompressorType type = CompressorType.Upward)
{
this.compType = type;
this.VolThresh = (float)Math.Pow(10.0f, threshold * 0.05f);
this.VolGate = (float)Math.Pow(10.0f, gatedB * 0.05f);
this.Gain = gain;
this.previous = 1.0f;
}
public void constructor_should_initialize_instance(CompressorType type)
{
var subject = new CompressorConfiguration(type);
subject.Type.Should().Be(type);
subject.Properties.Should().NotBeNull();
subject.Properties.Count.Should().Be(0);
}
public void Get_should_return_expected_result(CompressorType compressorType)
{
var subject = CreateSubject(compressorType);
var compressor = subject.Get(compressorType);
compressor.Type.Should().Be(compressor.Type);
}
private readonly BsonStream _originalMessageStream; // not owned by this class
/// <summary>
/// Initializes a new instance of the <see cref="CompressedMessage"/> class.
/// </summary>
/// <param name="originalMessage">The original message.</param>
/// <param name="originalMessageStream">The original message stream.</param>
/// <param name="compressorType">The compressor type.</param>
public CompressedMessage(
MongoDBMessage originalMessage,
BsonStream originalMessageStream,
CompressorType compressorType)
{
_originalMessage = Ensure.IsNotNull(originalMessage, nameof(originalMessage));
_originalMessageStream = originalMessageStream;
_compressorType = compressorType;
}
/// <summary>
/// Decompresses the byte array that is sent in
/// </summary>
/// <param name="data">Data to decompress</param>
/// <param name="compressorType">The compression type used</param>
/// <returns>The data decompressed</returns>
public static byte[] Decompress(this byte[] data, CompressorType compressorType = null)
{
if (data == null)
{
return(data);
}
compressorType = compressorType ?? CompressorType.Deflate;
return(Canister.Builder.Bootstrapper.Resolve <Corset>().Decompress(data, compressorType));
}
/// <summary>
/// Decompresses the data
/// </summary>
/// <param name="data">Data to decompress</param>
/// <param name="compressor">Compressor name</param>
/// <returns>The decompressed data</returns>
public byte[] Decompress(byte[] data, CompressorType compressor)
{
if (data == null)
{
return(data);
}
compressor = compressor ?? CompressorType.Deflate;
return(Compressors.ContainsKey(compressor) ? Compressors[compressor].Decompress(data) : data);
}
public Compressor(string destinationFolder, string zipFileLocationPath)
{
InitializeComponent();
// This is for extracting
this.Text = "ZipMagikLITE: Extracting Files...";
this._encrypt = null;
this._type = CompressorType.Extract;
this._file = zipFileLocationPath;
this._destinationFolder = destinationFolder;
}
public Compressor(string destinationFolder, bool encrypt, params string[] files)
{
InitializeComponent();
// This is for compressing/zipping
this.Text = "ZipMagikLITE: Compressing Files...";
this._encrypt = encrypt;
this._type = CompressorType.Archive;
this._file = files;
this._destinationFolder = destinationFolder;
}
public CompressorConfig(CompressorType t = CompressorType.Compressor)
{
Threshold = -20;
Ratio = 100;
Attack = 0.01; // 10ms
Release = 0.01; // 10ms
SoftKnee = false;
Bypassed = true;
Type = t;
}
public CompressorConfig(double th, double rat, double a, double rel, bool sk, bool bypassed, CompressorType t = CompressorType.Compressor)
{
Threshold = th;
Ratio = rat;
Attack = a;
Release = rel;
SoftKnee = sk;
Bypassed = bypassed;
Type = t;
}
public ICompressor CreateCompressor(CompressorType compressorType)
{
switch (compressorType)
{
case CompressorType.GZip:
return(new GzipCompressor());
default:
throw new NotImplementedException($"CompressorType {compressorType} has not been implemented.");
}
}
private ICompressor CreateCompressor(CompressorType compressorType)
{
var compressorConfiguration = _allowedCompressors.FirstOrDefault(c => c.Type == compressorType);
if (compressorConfiguration == null)
{
throw new NotSupportedException($"The compressor {compressorType} is not one of the allowed compressors.");
}
return(CreateCompressor(compressorConfiguration));
}
public bool Minimize()
{
if (String.IsNullOrEmpty(Input))
{
throw new Exception("Input must be specified.:");
}
if (CompressorType == 0)
{
throw new Exception("No compressor type specified.");
}
string compressedYui = String.Empty;
string compressedPacker = String.Empty;
string header = String.Empty;
string javascript = Input;
//string javascript = File.ReadAllText(path);
if (KeepHeader)
{
int pos = javascript.IndexOf("/*");
int endPos = -1;
string leadin = String.Empty;
if (pos >= 0)
{
leadin = javascript.Substring(0, pos);
if (leadin.Trim() == string.Empty)
{
endPos = javascript.IndexOf("*/", pos + 1);
header = javascript.Substring(pos, endPos + 2) + Environment.NewLine;
javascript = javascript.Substring(endPos + 2);
}
}
}
if (CompressorType == CompressorType.yui || CompressorType == CompressorType.best)
{
if (!compressYUI(javascript, out compressedYui))
{
throw new Exception("The YUI compressor reported errors, which is strange because we already did a dry run to determine the best compressor.");
}
}
if (CompressorType == CompressorType.packer || CompressorType == CompressorType.best)
{
JavascriptPacker jsPacker = new JavascriptPacker(JavascriptPacker.PackerEncoding.None, false, false);
compressedPacker = jsPacker.Pack(javascript);
}
CompressorType finalPacker = CompressorType != CompressorType.best ? CompressorType :
(compressedYui.Length < compressedPacker.Length ? CompressorType.yui : CompressorType.packer);
Output = header + (finalPacker == CompressorType.yui ? compressedYui : compressedPacker);
Statistics = finalPacker.ToString() + ": " + javascript.Length + "/" + Output.Length + ", "
+ Math.Round(100 * ((decimal)Output.Length / (decimal)javascript.Length), 0) + "%";
return(Success);
}
/// <summary>
/// Decompresses the data
/// </summary>
/// <param name="data">Data to decompress</param>
/// <param name="compressor">Compressor name</param>
/// <returns>The decompressed data</returns>
public byte[]? Decompress(byte[] data, CompressorType compressor)
{
if (data is null)
{
return(data);
}
compressor ??= CompressorType.Deflate;
var Key = compressor ?? "";
return(Compressors.ContainsKey(Key) ? Compressors[Key].Decompress(data) : data);
}
public static bool IsCompressorSupported(CompressorType compressorType)
{
switch (compressorType)
{
case CompressorType.Snappy:
case CompressorType.Zlib:
case CompressorType.ZStandard:
case CompressorType.Noop: // This is realistically only used for testing
return(true);
default:
return(false);
}
}
public virtual ICompressor CreateCompressor(CompressorType compressorType = CompressorType.JPEG)
{
switch (compressorType)
{
case CompressorType.JPEG:
return(new JPEGCompressor());
case CompressorType.PNG:
return(new PNGCompressor());
default:
throw new ArgumentOutOfRangeException(nameof(compressorType));
}
}
private ICompressor GetCompressor(CompressorType compressorType, object option = null)
{
switch (compressorType)
{
case CompressorType.Snappy:
return(new SnappyCompressor());
case CompressorType.Zlib:
return(new ZlibCompressor((int)option));
default:
throw new NotSupportedException();
}
}
public void Equals_should_return_true_if_all_fields_are_equal(CompressorType type)
{
var subject1 = new CompressorConfiguration(type);
var subject2 = new CompressorConfiguration(type);
subject1.Properties.Add("x", 1);
subject2.Properties.Add("x", 1);
var result = subject1.Equals(subject2);
var hashCode1 = subject1.GetHashCode();
var hashCode2 = subject2.GetHashCode();
result.Should().BeTrue();
hashCode2.Should().Be(hashCode1);
}
public static ICompressor New(CompressorType typeId)
{
ICompressor compressor = null;
switch (typeId) {
case CompressorType.None : compressor = new NoneCompressor(); break;
case CompressorType.Zip : try { compressor = new ZipNativeCompressor(); }
catch { compressor = new ZipManagedCompressor(); } break;
case CompressorType.BZip2 : try { compressor = new BZ2NativeCompressor(); }
catch { compressor = new BZ2ManagedCompressor(); } break;
case CompressorType.NativeZip : compressor = new ZipNativeCompressor(); break;
case CompressorType.ManagedZip : compressor = new ZipManagedCompressor(); break;
case CompressorType.NativeBZip2 : compressor = new BZ2NativeCompressor(); break;
case CompressorType.ManagedBZip2: compressor = new BZ2ManagedCompressor(); break;
default: throw new ArgumentOutOfRangeException("Unknown compressor typeId.");
} return compressor;
}
public static bool TryFromServerName(string serverName, out CompressorType compressorType)
{
compressorType = default;
switch (serverName.ToLowerInvariant())
{
case "noop": compressorType = CompressorType.Noop; break;
case "zlib": compressorType = CompressorType.Zlib; break;
case "snappy": compressorType = CompressorType.Snappy; break;
case "zstd": compressorType = CompressorType.ZStandard; break;
default: return(false);
}
return(true);
}
public static bool IsCompressorSupported(CompressorType compressorType)
{
switch (compressorType)
{
#if NET452 || NETSTANDARD2_0
case CompressorType.Snappy:
return(true);
#endif
case CompressorType.Zlib:
return(true);
case CompressorType.Noop: // This is realistically only used for testing
return(true);
default:
return(false);
}
}
public static string ToServerName(CompressorType compressorType)
{
switch (compressorType)
{
case CompressorType.Noop:
return("noop");
case CompressorType.Zlib:
return("zlib");
case CompressorType.Snappy:
return("snappy");
case CompressorType.ZStandard:
return("zstd");
default:
throw new ArgumentOutOfRangeException(nameof(compressorType));
}
}
private void ProcessImage(string fileName, CompressorType compressorType, FilterType filterType)
{
if (compressorType == CompressorType.JPEG)
{
Console.WriteLine($"{fileName} compressed using JPEG compressor");
}
else if (compressorType == CompressorType.PNG)
{
Console.WriteLine($"{fileName} compressed using PNG compressor");
}
if (filterType == FilterType.BlackAndWhite)
{
Console.WriteLine($"{fileName} filtered using B&W filter");
}
else if (filterType == FilterType.HighContrast)
{
Console.WriteLine($"{fileName} filtered using high contrast filter");
}
}
/// <summary>
/// Method reads setting as set by the user and assigns them to proper private fields.
/// </summary>
private void ReadSettings()
{
string algorythmValue = algorythmDropDownList.Value;
if (algorythmValue == _plainText)
{
_compressor = null;
}
else
{
CompressorType compressorType = (CompressorType)Enum.Parse(typeof(CompressorType), algorythmValue, true);
_compressor = CompressorFactory.GetCompressor(compressorType);
if (compressorType == CompressorType.Zip)
{
_zipCompressor = (ZipCompressor)_compressor;
}
}
_compressionLevel = int.Parse(compressionLevelDropDownList.Items[compressionLevelDropDownList.SelectedIndex].Value);
_conversionType = (ConversionType)Enum.Parse(typeof(ConversionType), dataTypeDropDownList.Value, true);
_inputText = inputArea.Value;
_password = passwordTextBox.Value;
}
public void Compressor_should_read_the_previously_written_message(CompressorType compressorType)
{
var bytes = Encoding.ASCII.GetBytes(__testMessage);
var compressor = GetCompressor(compressorType);
Assert(
bytes,
(input, output) =>
{
compressor.Compress(input, output);
input.Length.Should().BeGreaterThan(output.Length);
input.Position = 0;
input.SetLength(0);
output.Position = 0;
compressor.Decompress(output, input);
},
(input, output) =>
{
input.Position = 0;
var result = Encoding.ASCII.GetString(input.ReadBytes((int)input.Length));
result.Should().Be(__testMessage);
});
}
internal Compressor(CompressorType typeId)
{
_Compressor = Compressor.New(typeId);
}
public CompressorForm(MainForm_Template _parentForm, int channel, int _settings_offset, CompressorType compType = CompressorType.Compressor)
{
InitializeComponent();
ADDR_THRESHOLD = _settings_offset;
ADDR_KNEE = _settings_offset+1;
ADDR_RATIO = _settings_offset+2;
ADDR_ATTACK = _settings_offset+3;
ADDR_RELEASE = _settings_offset+4;
ADDR_BYPASS = _settings_offset+5;
dropAction.SelectedIndex = 0;
dropAction.Invalidate();
PARENT_FORM = _parentForm;
CH_NUMBER = channel;
if (compType == CompressorType.Compressor)
{
is_limiter = false;
COMP_INDEX = 0;
}
else
{
is_limiter = true;
COMP_INDEX = 1;
}
try
{
FixedLine = dynChart.Series[0];
MarkerLine = dynChart.Series[1];
StraightResponseLine = dynChart.Series[2];
KneedResponseLine = dynChart.Series[3];
nudCompThreshold.Value = (decimal)PARENT_FORM.PROGRAMS[PARENT_FORM.CURRENT_PROGRAM].compressors[CH_NUMBER - 1][COMP_INDEX].Threshold;
nudCompRatio.Value = (decimal)(Math.Min(100.0, PARENT_FORM.PROGRAMS[PARENT_FORM.CURRENT_PROGRAM].compressors[CH_NUMBER - 1][COMP_INDEX].Ratio));
if (compType == CompressorType.Limiter)
{
lblRatio.Visible = false;
lblRatioSuffix.Visible = false;
nudCompRatio.Visible = false;
MarkerLine.Points[2].MarkerSize = 0;
dynChart.Invalidate();
this.Text = "Limiter - CH" + channel.ToString();
}
else
{
MarkerLine.Points[2].MarkerSize = 12;
this.Text = "Compressor - CH" + channel.ToString();
}
AttackDial = new Dial(TextCompAttack, DialCompAttack, new double[] {0.001, 0.003, 0.01, 0.03, 0.08, 0.3, 1.0},
DialHelpers.Format_String_Comp_Attack, Images.knob_blue_bg, Images.knob_blue_line);
AttackDial.Value = PARENT_FORM.PROGRAMS[PARENT_FORM.CURRENT_PROGRAM].compressors[CH_NUMBER - 1][COMP_INDEX].Attack;
AttackDial.OnChange += new DialEventHandler(this.AttackDial_OnChange);
ReleaseDial = new Dial(TextCompRelease, DialCompRelease, new double[] {0.010, 0.038, 0.150, 0.530, 1.250, 7.0, 30.0},
DialHelpers.Format_String_Comp_Release, Images.knob_orange_bg, Images.knob_orange_line);
ReleaseDial.Value = PARENT_FORM.PROGRAMS[PARENT_FORM.CURRENT_PROGRAM].compressors[CH_NUMBER - 1][COMP_INDEX].Release;
ReleaseDial.OnChange += new DialEventHandler(this.ReleaseDial_OnChange);
var backImage = new NamedImage("DynamicsBackground", GlobalResources.DynamicsGraph_BG_Blue);
dynChart.Images.Add(backImage);
dynChart.ChartAreas[0].BackImage = "DynamicsBackground";
/* Load Image Resources */
update_soft_knee();
chkSoftKnee.Checked = PARENT_FORM.PROGRAMS[PARENT_FORM.CURRENT_PROGRAM].compressors[CH_NUMBER - 1][COMP_INDEX].SoftKnee;
if (chkSoftKnee.Checked)
{
KneedResponseLine.Enabled = true;
StraightResponseLine.Enabled = false;
}
else
{
KneedResponseLine.Enabled = false;
StraightResponseLine.Enabled = true;
}
chkBypass.Checked = PARENT_FORM.PROGRAMS[PARENT_FORM.CURRENT_PROGRAM].compressors[CH_NUMBER - 1][COMP_INDEX].Bypassed;
if (_parentForm.LIVE_MODE && _parentForm._PIC_Conn.isOpen)
{
signalTimer.Enabled = true;
gainMeterIn.Visible = true;
gainMeterOut.Visible = true;
lblIn.Visible = true;
lblOut.Visible = true;
panel1.Location = new Point(35, 366);
} else
{
signalTimer.Enabled = false;
gainMeterIn.Visible = false;
gainMeterOut.Visible = false;
lblIn.Visible = false;
lblOut.Visible = false;
panel1.Location = new Point(78, 366);
}
} catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void Store(string fileName, CompressorType compressor, FilterType filter)
{
ProcessImage(fileName, compressor, filter);
SaveImage(fileName);
}
public ImageStorage(CompressorType compressor, FilterType filter)
{
_compressor = compressor;
_filter = filter;
}