private static void WriteOutputImage(string outputFile, OutputType outputType, int width, int height, byte[] bitmap)
{
Console.WriteLine("Writing {0}", outputFile);
using (var stream = File.Create(outputFile))
{
var imageWriter = new ImageWriter();
switch (outputType)
{
case OutputType.Jpg:
imageWriter.WriteJpg(bitmap, width, height, StbImageWriteSharp.ColorComponents.RedGreenBlueAlpha, stream, 90);
break;
case OutputType.Png:
imageWriter.WritePng(bitmap, width, height, StbImageWriteSharp.ColorComponents.RedGreenBlueAlpha, stream);
break;
case OutputType.Tga:
imageWriter.WriteTga(bitmap, width, height, StbImageWriteSharp.ColorComponents.RedGreenBlueAlpha, stream);
break;
case OutputType.Bmp:
imageWriter.WriteBmp(bitmap, width, height, StbImageWriteSharp.ColorComponents.RedGreenBlueAlpha, stream);
break;
case OutputType.Hdr:
imageWriter.WriteHdr(bitmap, width, height, StbImageWriteSharp.ColorComponents.RedGreenBlueAlpha, stream);
break;
}
}
}
private unsafe void SaveAsImage(Stream stream, int width, int height, ImageWriterFormat format)
{
if (stream == null)
{
throw new ArgumentNullException("stream", "'stream' cannot be null (Nothing in Visual Basic)");
}
if (width <= 0)
{
throw new ArgumentOutOfRangeException("width", width, "'width' cannot be less than or equal to zero");
}
if (height <= 0)
{
throw new ArgumentOutOfRangeException("height", height, "'height' cannot be less than or equal to zero");
}
Color[] data = null;
try
{
data = GetColorData();
// Write
fixed(Color *ptr = &data[0])
{
var writer = new ImageWriter();
switch (format)
{
case ImageWriterFormat.Jpg:
writer.WriteJpg(ptr, width, height, StbImageWriteSharp.ColorComponents.RedGreenBlueAlpha, stream, 90);
break;
case ImageWriterFormat.Png:
writer.WritePng(ptr, width, height, StbImageWriteSharp.ColorComponents.RedGreenBlueAlpha, stream);
break;
}
}
}
finally
{
if (data != null)
{
data = null;
}
}
}
private static void ThreadProc(string f)
{
try
{
var sw = new Stopwatch();
if (!f.EndsWith(".bmp") && !f.EndsWith(".jpg") && !f.EndsWith(".png") &&
!f.EndsWith(".jpg") && !f.EndsWith(".psd") && !f.EndsWith(".pic") &&
!f.EndsWith(".tga"))
{
return;
}
Log(string.Empty);
Log("{0} -- #{1}: Loading {2} into memory", DateTime.Now.ToLongTimeString(), filesProcessed, f);
var data = File.ReadAllBytes(f);
Log("----------------------------");
var image = ImageResult.FromMemory(data);
for (var k = 0; k <= 4; ++k)
{
Log("Saving as {0} with StbSharp", FormatNames[k]);
if (k < 4)
{
var writer = new ImageWriter();
WriteDelegate wd = null;
switch (k)
{
case 0:
wd = writer.WriteBmp;
break;
case 1:
wd = writer.WriteTga;
break;
case 2:
wd = writer.WriteHdr;
break;
case 3:
wd = writer.WritePng;
break;
}
byte[] save;
BeginWatch(sw);
using (var stream = new MemoryStream())
{
wd(image.Data, image.Width, image.Height, (StbImageWriteSharp.ColorComponents)image.Comp, stream);
save = stream.ToArray();
}
var passed = EndWatch(sw);
stbSharpWrite += passed;
Log("Span: {0} ms", passed);
Log("StbSharp Size: {0}", save.Length);
Log("Saving as {0} with Stb.Native", FormatNames[k]);
BeginWatch(sw);
byte[] save2;
using (var stream = new MemoryStream())
{
Native.save_to_stream(image.Data, image.Width, image.Height, (int)image.Comp, k, stream);
save2 = stream.ToArray();
}
passed = EndWatch(sw);
stbNativeWrite += passed;
Log("Span: {0} ms", passed);
Log("Stb.Native Size: {0}", save2.Length);
if (save.Length != save2.Length)
{
throw new Exception(string.Format("Inconsistent output size: StbSharp={0}, Stb.Native={1}",
save.Length, save2.Length));
}
for (var i = 0; i < save.Length; ++i)
{
if (save[i] != save2[i])
{
throw new Exception(string.Format("Inconsistent data: index={0}, StbSharp={1}, Stb.Native={2}",
i,
(int)save[i],
(int)save2[i]));
}
}
}
else
{
for (var qi = 0; qi < JpgQualities.Length; ++qi)
{
var quality = JpgQualities[qi];
Log("Saving as JPG with StbSharp with quality={0}", quality);
byte[] save;
BeginWatch(sw);
using (var stream = new MemoryStream())
{
var writer = new ImageWriter();
writer.WriteJpg(image.Data, image.Width, image.Height, (StbImageWriteSharp.ColorComponents)image.Comp, stream, quality);
save = stream.ToArray();
}
var passed = EndWatch(sw);
stbSharpWrite += passed;
Log("Span: {0} ms", passed);
Log("StbSharp Size: {0}", save.Length);
Log("Saving as JPG with Stb.Native with quality={0}", quality);
BeginWatch(sw);
byte[] save2;
using (var stream = new MemoryStream())
{
Native.save_to_jpg(image.Data, image.Width, image.Height, (int)image.Comp, stream, quality);
save2 = stream.ToArray();
}
passed = EndWatch(sw);
stbNativeWrite += passed;
Log("Span: {0} ms", passed);
Log("Stb.Native Size: {0}", save2.Length);
if (save.Length != save2.Length)
{
throw new Exception(string.Format("Inconsistent output size: StbSharp={0}, Stb.Native={1}",
save.Length, save2.Length));
}
for (var i = 0; i < save.Length; ++i)
{
if (save[i] != save2[i])
{
throw new Exception(string.Format("Inconsistent data: index={0}, StbSharp={1}, Stb.Native={2}",
i,
(int)save[i],
(int)save2[i]));
}
}
}
}
}
Log("Total StbSharp Write Time: {0} ms", stbSharpWrite);
Log("Total Stb.Native Write Time: {0} ms", stbNativeWrite);
Log("GC Memory: {0}", GC.GetTotalMemory(true));
Log("Native Allocations: {0}", StbImageWriteSharp.MemoryStats.Allocations);
++filesProcessed;
Log(DateTime.Now.ToLongTimeString() + " -- " + " Files processed: " + filesProcessed);
}
catch (Exception ex)
{
Log("Error: " + ex.Message);
}
finally
{
--tasksStarted;
}
}
private static void ThreadProc(string f)
{
try
{
var sw = new Stopwatch();
if (!f.EndsWith(".bmp") && !f.EndsWith(".jpg") && !f.EndsWith(".png") &&
!f.EndsWith(".jpg") && !f.EndsWith(".psd") && !f.EndsWith(".pic") &&
!f.EndsWith(".tga"))
{
return;
}
Log(string.Empty);
Log("{0} -- #{1}: Loading {2} into memory", DateTime.Now.ToLongTimeString(), filesProcessed, f);
var data = File.ReadAllBytes(f);
Log("----------------------------");
Log("Loading From Stream");
int x = 0, y = 0, comp = 0;
int stbSharpPassed, stbNativePassed;
byte[] parsed = new byte[0];
ParseTest(
sw,
(out int xx, out int yy, out int ccomp) =>
{
using (var ms = new MemoryStream(data))
{
var loader = new ImageReader();
var img = loader.Read(ms);
parsed = img.Data;
xx = img.Width;
yy = img.Height;
ccomp = img.SourceComp;
x = xx;
y = yy;
comp = ccomp;
return(parsed);
}
},
(out int xx, out int yy, out int ccomp) =>
{
using (var ms = new MemoryStream(data))
{
return(Native.load_from_stream(ms, out xx, out yy, out ccomp, StbImage.STBI_default));
}
},
out stbSharpPassed, out stbNativePassed
);
stbSharpLoadingFromStream += stbSharpPassed;
stbNativeLoadingFromStream += stbNativePassed;
Log("Loading from memory");
ParseTest(
sw,
(out int xx, out int yy, out int ccomp) =>
{
var img = StbImage.LoadFromMemory(data);
var res = img.Data;
xx = img.Width;
yy = img.Height;
ccomp = img.SourceComp;
x = xx;
y = yy;
comp = ccomp;
return(res);
},
(out int xx, out int yy, out int ccomp) =>
Native.load_from_memory(data, out xx, out yy, out ccomp, StbImage.STBI_default),
out stbSharpPassed, out stbNativePassed
);
stbSharpLoadingFromMemory += stbSharpPassed;
stbNativeLoadingFromMemory += stbNativePassed;
var image = new Image
{
Comp = comp,
Data = parsed,
Width = x,
Height = y
};
for (var k = 0; k <= 4; ++k)
{
Log("Saving as {0} with StbSharp", FormatNames[k]);
if (k < 4)
{
var writer = new ImageWriter();
WriteDelegate wd = null;
switch (k)
{
case 0:
wd = writer.WriteBmp;
break;
case 1:
wd = writer.WriteTga;
break;
case 2:
wd = writer.WriteHdr;
break;
case 3:
wd = writer.WritePng;
break;
}
byte[] save;
BeginWatch(sw);
using (var stream = new MemoryStream())
{
wd(image, stream);
save = stream.ToArray();
}
var passed = EndWatch(sw);
stbSharpWrite += passed;
Log("Span: {0} ms", passed);
Log("StbSharp Size: {0}", save.Length);
Log("Saving as {0} with Stb.Native", FormatNames[k]);
BeginWatch(sw);
byte[] save2;
using (var stream = new MemoryStream())
{
Native.save_to_stream(parsed, x, y, comp, k, stream);
save2 = stream.ToArray();
}
passed = EndWatch(sw);
stbNativeWrite += passed;
Log("Span: {0} ms", passed);
Log("Stb.Native Size: {0}", save2.Length);
if (save.Length != save2.Length)
{
throw new Exception(string.Format("Inconsistent output size: StbSharp={0}, Stb.Native={1}",
save.Length, save2.Length));
}
for (var i = 0; i < save.Length; ++i)
{
if (save[i] != save2[i])
{
throw new Exception(string.Format("Inconsistent data: index={0}, StbSharp={1}, Stb.Native={2}",
i,
(int)save[i],
(int)save2[i]));
}
}
}
else
{
for (var qi = 0; qi < JpgQualities.Length; ++qi)
{
var quality = JpgQualities[qi];
Log("Saving as JPG with StbSharp with quality={0}", quality);
byte[] save;
BeginWatch(sw);
using (var stream = new MemoryStream())
{
var writer = new ImageWriter();
writer.WriteJpg(image, stream, quality);
save = stream.ToArray();
}
var passed = EndWatch(sw);
stbSharpWrite += passed;
Log("Span: {0} ms", passed);
Log("StbSharp Size: {0}", save.Length);
Log("Saving as JPG with Stb.Native with quality={0}", quality);
BeginWatch(sw);
byte[] save2;
using (var stream = new MemoryStream())
{
Native.save_to_jpg(parsed, x, y, comp, stream, quality);
save2 = stream.ToArray();
}
passed = EndWatch(sw);
stbNativeWrite += passed;
Log("Span: {0} ms", passed);
Log("Stb.Native Size: {0}", save2.Length);
if (save.Length != save2.Length)
{
throw new Exception(string.Format("Inconsistent output size: StbSharp={0}, Stb.Native={1}",
save.Length, save2.Length));
}
for (var i = 0; i < save.Length; ++i)
{
if (save[i] != save2[i])
{
throw new Exception(string.Format("Inconsistent data: index={0}, StbSharp={1}, Stb.Native={2}",
i,
(int)save[i],
(int)save2[i]));
}
}
}
}
}
// Compressing
Log("Performing DXT compression with StbSharp");
image = StbImage.LoadFromMemory(data, StbImage.STBI_rgb_alpha);
BeginWatch(sw);
var compressed = StbDxt.stb_compress_dxt(image);
stbSharpCompression += EndWatch(sw);
Log("Performing DXT compression with Stb.Native");
BeginWatch(sw);
var compressed2 = Native.compress_dxt(image.Data, image.Width, image.Height, true);
stbNativeCompression += EndWatch(sw);
if (compressed.Length != compressed2.Length)
{
throw new Exception(string.Format("Inconsistent output size: StbSharp={0}, Stb.Native={1}",
compressed.Length, compressed2.Length));
}
for (var i = 0; i < compressed.Length; ++i)
{
if (compressed[i] != compressed2[i])
{
throw new Exception(string.Format("Inconsistent data: index={0}, StbSharp={1}, Stb.Native={2}",
i,
(int)compressed[i],
(int)compressed2[i]));
}
}
Log("Total StbSharp Loading From Stream Time: {0} ms", stbSharpLoadingFromStream);
Log("Total Stb.Native Loading From Stream Time: {0} ms", stbNativeLoadingFromStream);
Log("Total StbSharp Loading From memory Time: {0} ms", stbSharpLoadingFromMemory);
Log("Total Stb.Native Loading From memory Time: {0} ms", stbNativeLoadingFromMemory);
Log("Total StbSharp Write Time: {0} ms", stbSharpWrite);
Log("Total Stb.Native Write Time: {0} ms", stbNativeWrite);
Log("Total StbSharp Compression Time: {0} ms", stbSharpCompression);
Log("Total Stb.Native Compression Time: {0} ms", stbNativeCompression);
Log("GC Memory: {0}", GC.GetTotalMemory(true));
++filesProcessed;
Log(DateTime.Now.ToLongTimeString() + " -- " + " Files processed: " + filesProcessed);
}
catch (Exception ex)
{
Log("Error: " + ex.Message);
}
finally
{
--tasksStarted;
}
}
static void Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Usage: StbImageResizeSharp.Converter.exe <input_image_file> <output_image_file> [new_width] [new_height]");
Console.WriteLine("Example: StbImageResizeSharp.Converter.exe image.jpg image.png 400 400");
return;
}
try
{
OutputType outputType = OutputType.Png;
var ext = Path.GetExtension(args[1]);
if (string.IsNullOrEmpty(ext))
{
throw new Exception("Output file lacks extension. Hence it is not possible to determine output file type");
}
if (ext.StartsWith("."))
{
ext = ext.Substring(1);
}
ext = ext.ToLower();
switch (ext)
{
case "jpg":
case "jpeg":
outputType = OutputType.Jpg;
break;
case "png":
outputType = OutputType.Png;
break;
case "tga":
outputType = OutputType.Tga;
break;
case "bmp":
outputType = OutputType.Bmp;
break;
case "hdr":
outputType = OutputType.Hdr;
break;
default:
throw new Exception("Output format '" + ext + "' is not supported.");
}
// Load image
ImageResult image;
using (var stream = File.OpenRead(args[0]))
{
image = ImageResult.FromStream(stream);
}
// Parse new size
var newWidth = image.Width;
var newHeight = image.Height;
if (args.Length >= 3)
{
newWidth = int.Parse(args[2]);
}
if (args.Length >= 4)
{
newHeight = int.Parse(args[3]);
}
var newData = image.Data;
var channels = (int)image.Comp;
// Resize if needed
if (newWidth != image.Width && newHeight != image.Height)
{
newData = new byte[newWidth * newHeight * channels];
StbImageResize.stbir_resize_uint8(image.Data, image.Width, image.Height, image.Width * channels,
newData, newWidth, newHeight, newWidth * channels, channels);
}
// Save
using (var stream = File.Create(args[1]))
{
var imageWriter = new ImageWriter();
switch (outputType)
{
case OutputType.Jpg:
imageWriter.WriteJpg(newData, newWidth, newHeight, (StbImageWriteSharp.ColorComponents)channels, stream, 90);
break;
case OutputType.Png:
imageWriter.WritePng(newData, newWidth, newHeight, (StbImageWriteSharp.ColorComponents)channels, stream);
break;
case OutputType.Tga:
imageWriter.WriteTga(newData, newWidth, newHeight, (StbImageWriteSharp.ColorComponents)channels, stream);
break;
case OutputType.Bmp:
imageWriter.WriteBmp(newData, newWidth, newHeight, (StbImageWriteSharp.ColorComponents)channels, stream);
break;
case OutputType.Hdr:
imageWriter.WriteHdr(newData, newWidth, newHeight, (StbImageWriteSharp.ColorComponents)channels, stream);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private void buttonSave_Click(object sender, EventArgs e)
{
try
{
string fileName;
using (var dlg = new SaveFileDialog())
{
dlg.Filter =
"BMP Files (*.bmp)|*.bmp|TGA Files (*.tga)|*.tga|PNG Files (*.png)|*.png|HDR Files (*.hdr)|*.hdr|JPG Files (*.jpg)|*.jpg";
if (dlg.ShowDialog() != DialogResult.OK)
{
return;
}
fileName = dlg.FileName;
}
// Get bitmap bytes
var bmp = (Bitmap)pictureBox1.Image;
var x = bmp.Width;
var y = bmp.Height;
var bmpData = bmp.LockBits(new Rectangle(0, 0, x, y), ImageLockMode.ReadOnly, bmp.PixelFormat);
var data = new byte[y * bmpData.Stride];
Marshal.Copy(bmpData.Scan0, data, 0, bmpData.Stride * bmp.Height);
bmp.UnlockBits(bmpData);
// Convert bgra to rgba
for (var i = 0; i < x * y; ++i)
{
var b = data[i * 4];
var g = data[i * 4 + 1];
var r = data[i * 4 + 2];
var a = data[i * 4 + 3];
data[i * 4] = r;
data[i * 4 + 1] = g;
data[i * 4 + 2] = b;
data[i * 4 + 3] = a;
}
// Call StbSharp
using (var stream = File.Create(fileName))
{
var writer = new ImageWriter();
var image = new Image
{
Data = data,
Width = x,
Height = y,
Comp = 4
};
if (fileName.EndsWith(".bmp"))
{
writer.WriteBmp(image, stream);
}
else if (fileName.EndsWith(".tga"))
{
writer.WriteTga(image, stream);
}
else if (fileName.EndsWith("png"))
{
writer.WritePng(image, stream);
}
else if (fileName.EndsWith("hdr"))
{
writer.WriteHdr(image, stream);
}
else if (fileName.EndsWith("jpg") || fileName.EndsWith("jpeg"))
{
writer.WriteJpg(image, stream, 75);
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error", ex.Message);
}
}
