public void Test_DctMethod_OptimizeCoding_Quality_QuantizationTables_SamplingFactors()
{
JpegWriteDefines defines = new JpegWriteDefines()
{
DctMethod = DctMethod.Fast,
OptimizeCoding = false,
Quality = new MagickGeometry(80, 80),
QuantizationTables = @"C:\path\to\file.xml",
SamplingFactors = new MagickGeometry[]
{
new MagickGeometry(5, 10),
new MagickGeometry(15, 20)
}
};
using (IMagickImage image = new MagickImage(Files.Builtin.Logo))
{
image.Settings.SetDefines(defines);
Assert.AreEqual("Fast", image.Settings.GetDefine(MagickFormat.Jpeg, "dct-method"));
Assert.AreEqual("False", image.Settings.GetDefine(MagickFormat.Jpeg, "optimize-coding"));
Assert.AreEqual("80x80", image.Settings.GetDefine(MagickFormat.Jpeg, "quality"));
Assert.AreEqual(@"C:\path\to\file.xml", image.Settings.GetDefine(MagickFormat.Jpeg, "q-table"));
Assert.AreEqual("5x10,15x20", image.Settings.GetDefine(MagickFormat.Jpeg, "sampling-factor"));
}
}
public void ShouldWriteJpegWithTheCorrectSamplingFactor()
{
var defines = new JpegWriteDefines()
{
SamplingFactors = new MagickGeometry[]
{
new MagickGeometry(2, 2),
new MagickGeometry(1, 1),
new MagickGeometry(1, 1),
},
};
using (IMagickImage input = new MagickImage(Files.Builtin.Logo))
{
using (var memoryStream = new MemoryStream())
{
input.Write(memoryStream, defines);
memoryStream.Position = 0;
using (IMagickImage output = new MagickImage(memoryStream))
{
output.Read(memoryStream);
Assert.AreEqual("2x2,1x1,1x1", output.GetAttribute("jpeg:sampling-factor"));
}
}
}
}
public async Task ShouldUseTheSpecifiedFormat()
{
using (var input = new MagickImage(Files.CirclePNG))
{
using (var stream = new MemoryStream())
{
var defines = new JpegWriteDefines
{
DctMethod = JpegDctMethod.Fast,
};
await input.WriteAsync(stream, defines);
Assert.Equal(MagickFormat.Png, input.Format);
stream.Position = 0;
using (var output = new MagickImage())
{
await output.ReadAsync(stream);
Assert.Equal(MagickFormat.Jpeg, output.Format);
}
}
}
}
// ReSharper disable once UnusedMember.Global
public static async Task <IActionResult> Function(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "RetrieveImage/{*image}")]
HttpRequestMessage req,
[Blob("{image}", FileAccess.Read, Connection = "ImageStorageAccount")]
Stream s,
ILogger log)
{
// var ms = new MemoryStream();
// await s.CopyToAsync(ms);
// ms.Seek(0, SeekOrigin.Begin);
var magickNetNativeLibraryDirectory = Environment.GetEnvironmentVariable("MAGICK_NET_NATIVE", EnvironmentVariableTarget.Process);
MagickNET.SetNativeLibraryDirectory(magickNetNativeLibraryDirectory);
var defines = new JpegWriteDefines
{
Extent = 4 * 1024
};
var ms = new MemoryStream();
using (var image = new MagickImage(s))
{
image.Settings.SetDefines(defines);
image.Write(ms);
}
ms.Seek(0, SeekOrigin.Begin);
return(new FileStreamResult(ms, "image/jpg"));
}
public void ShouldThrowExceptionWhenBufferWriterIsNull()
{
using (var image = new MagickImage())
{
var defines = new JpegWriteDefines();
Assert.Throws <ArgumentNullException>("bufferWriter", () => image.Write((IBufferWriter <byte>)null, defines));
}
}
public async Task ShouldThrowExceptionWhenStreamIsNull()
{
using (var image = new MagickImage())
{
var defines = new JpegWriteDefines();
await Assert.ThrowsAsync <ArgumentNullException>("stream", () => image.WriteAsync((Stream)null, defines));
}
}
public void ShouldThrowExceptionWhenFileIsNull()
{
using (var image = new MagickImage())
{
var defines = new JpegWriteDefines();
Assert.Throws <ArgumentNullException>("file", () => image.Write((FileInfo)null, defines));
}
}
private static void AssertSetDefine(string expected, JpegSamplingFactor samplingFactor)
{
var defines = new JpegWriteDefines
{
SamplingFactor = samplingFactor,
};
using (var image = new MagickImage())
{
image.Settings.SetDefines(defines);
Assert.Equal(expected, image.Settings.GetDefine(MagickFormat.Jpeg, "sampling-factor"));
}
}
public void ShouldSetTheDefine()
{
var defines = new JpegWriteDefines()
{
DctMethod = DctMethod.Fast,
};
using (IMagickImage image = new MagickImage())
{
image.Settings.SetDefines(defines);
Assert.AreEqual("Fast", image.Settings.GetDefine(MagickFormat.Jpeg, "dct-method"));
}
}
public void ShouldSetTheDefine()
{
var defines = new JpegWriteDefines()
{
OptimizeCoding = false,
};
using (IMagickImage image = new MagickImage())
{
image.Settings.SetDefines(defines);
Assert.AreEqual("False", image.Settings.GetDefine(MagickFormat.Jpeg, "optimize-coding"));
}
}
public void ShouldSetTheDefine()
{
var defines = new JpegWriteDefines()
{
QuantizationTables = @"C:\path\to\file.xml",
};
using (IMagickImage image = new MagickImage())
{
image.Settings.SetDefines(defines);
Assert.AreEqual(@"C:\path\to\file.xml", image.Settings.GetDefine(MagickFormat.Jpeg, "q-table"));
}
}
public void ShouldSetTheDefine()
{
var defines = new JpegWriteDefines
{
ArithmeticCoding = false,
};
using (var image = new MagickImage())
{
image.Settings.SetDefines(defines);
Assert.Equal("false", image.Settings.GetDefine(MagickFormat.Jpeg, "arithmetic-coding"));
}
}
public void ShouldSetTheDefine()
{
var defines = new JpegWriteDefines()
{
Quality = new MagickGeometry(80, 80),
};
using (IMagickImage image = new MagickImage())
{
image.Settings.SetDefines(defines);
Assert.AreEqual("80x80", image.Settings.GetDefine(MagickFormat.Jpeg, "quality"));
}
}
public void ShouldSetTheDefine()
{
var defines = new JpegWriteDefines()
{
Extent = 5,
};
using (IMagickImage image = new MagickImage())
{
image.Settings.SetDefines(defines);
Assert.AreEqual("5KB", image.Settings.GetDefine(MagickFormat.Jpeg, "extent"));
}
}
public void ShouldSetTheDefine()
{
var defines = new JpegWriteDefines()
{
SamplingFactors = new MagickGeometry[]
{
new MagickGeometry(5, 10),
new MagickGeometry(15, 20),
},
};
using (IMagickImage image = new MagickImage())
{
image.Settings.SetDefines(defines);
Assert.AreEqual("5x10,15x20", image.Settings.GetDefine(MagickFormat.Jpeg, "sampling-factor"));
}
}
public void ShouldLimitTheSizeOfTheOutputFile()
{
JpegWriteDefines defines = new JpegWriteDefines()
{
Extent = 10,
};
using (var image = new MagickImage(Files.Builtin.Logo))
{
using (MemoryStream memStream = new MemoryStream())
{
image.Settings.SetDefines(defines);
image.Format = MagickFormat.Jpeg;
image.Write(memStream);
Assert.IsTrue(memStream.Length < 10000);
}
}
}
public void Test_Extent()
{
JpegWriteDefines defines = new JpegWriteDefines()
{
Extent = 10
};
using (IMagickImage image = new MagickImage(Files.Builtin.Logo))
{
using (MemoryStream memStream = new MemoryStream())
{
image.Settings.SetDefines(defines);
image.Format = MagickFormat.Jpeg;
image.Write(memStream);
Assert.IsTrue(memStream.Length < 10000);
}
}
}
public void ShouldUseTheFormatOfTheDefines()
{
using (var image = new MagickImage(Files.SnakewarePNG))
{
var defines = new JpegWriteDefines
{
OptimizeCoding = true,
};
var data = image.ToByteArray(defines);
Assert.NotNull(data);
Assert.Equal(853, data.Length);
image.Read(data);
Assert.Equal(MagickFormat.Jpeg, image.Format);
}
}
public void ShouldUseTheSpecifiedFormat()
{
using (var input = new MagickImage(Files.CirclePNG))
{
var bufferWriter = new ArrayBufferWriter <byte>();
var defines = new JpegWriteDefines
{
DctMethod = JpegDctMethod.Fast,
};
input.Write(bufferWriter, defines);
Assert.Equal(MagickFormat.Png, input.Format);
using (var output = new MagickImage(bufferWriter.WrittenSpan))
{
Assert.Equal(MagickFormat.Jpeg, output.Format);
}
}
}
public void ShouldUseTheSpecifiedFormat()
{
using (var input = new MagickImage(Files.CirclePNG))
{
using (var tempfile = new TemporaryFile("foobar"))
{
var defines = new JpegWriteDefines
{
DctMethod = JpegDctMethod.Fast,
};
input.Write(tempfile.FullName, defines);
Assert.Equal(MagickFormat.Png, input.Format);
using (var output = new MagickImage(tempfile.FullName))
{
Assert.Equal(MagickFormat.Jpeg, output.Format);
}
}
}
}
static async Task <MagickImage> SetJpegChromaSubsampling(MagickImage img)
{
JpegWriteDefines jpegDefines = new JpegWriteDefines();
int configVal = await Config.GetInt("jpegChromaSubsampling");
if (configVal == 0)
{
jpegDefines.SamplingFactor = JpegSamplingFactor.Ratio420;
}
if (configVal == 1)
{
jpegDefines.SamplingFactor = JpegSamplingFactor.Ratio422;
}
if (configVal == 2)
{
jpegDefines.SamplingFactor = JpegSamplingFactor.Ratio444;
}
img.Settings.SetDefines(jpegDefines);
return(img);
}
public void ShouldWriteJpegWithTheCorrectSamplingFactor()
{
var defines = new JpegWriteDefines
{
SamplingFactor = JpegSamplingFactor.Ratio420,
};
using (var input = new MagickImage(Files.Builtin.Logo))
{
using (var memoryStream = new MemoryStream())
{
input.Write(memoryStream, defines);
memoryStream.Position = 0;
using (var output = new MagickImage(memoryStream))
{
output.Read(memoryStream);
Assert.Equal("2x2,1x1,1x1", output.GetAttribute("jpeg:sampling-factor"));
}
}
}
}
public void ShouldEncodeTheImagArarithmetic()
{
var defines = new JpegWriteDefines
{
ArithmeticCoding = true,
};
using (var input = new MagickImage(Files.Builtin.Logo))
{
using (var memStream = new MemoryStream())
{
input.Write(memStream, defines);
Assert.Equal("true", input.Settings.GetDefine(MagickFormat.Jpeg, "arithmetic-coding"));
memStream.Position = 0;
using (var output = new MagickImage(memStream))
{
var coding = output.GetAttribute("jpeg:coding");
Assert.Equal("arithmetic", coding);
}
}
}
}
public async Task ShouldUseTheSpecifiedFormat()
{
using (var input = new MagickImage(Files.CirclePNG))
{
using (var tempfile = new TemporaryFile("foobar"))
{
var defines = new JpegWriteDefines
{
DctMethod = JpegDctMethod.Fast,
};
await input.WriteAsync(tempfile.FileInfo, defines);
Assert.Equal(MagickFormat.Png, input.Format);
using (var output = new MagickImage())
{
await output.ReadAsync(tempfile.FileInfo);
Assert.Equal(MagickFormat.Jpeg, output.Format);
}
}
}
}
static MagickImage SetJpegChromaSubsampling(MagickImage img, bool print = true)
{
JpegWriteDefines jpegDefines = new JpegWriteDefines();
int configVal = Config.GetInt("jpegChromaSubsampling");
if (configVal == 0)
{
jpegDefines.SamplingFactor = JpegSamplingFactor.Ratio420;
}
if (configVal == 1)
{
jpegDefines.SamplingFactor = JpegSamplingFactor.Ratio422;
}
if (configVal == 2)
{
jpegDefines.SamplingFactor = JpegSamplingFactor.Ratio444;
}
img.Settings.SetDefines(jpegDefines);
if (print)
{
Program.Print("-> Chroma Subsampling: " + jpegDefines.SamplingFactor.ToString().Replace("Ratio", ""));
}
return(img);
}
