/// <summary>
/// Load a FreeImage bitmap specifying different flags according to the file extension
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
private FreeImageBitmap LoadBitmap(string fileName)
{
FREE_IMAGE_LOAD_FLAGS flags = FREE_IMAGE_LOAD_FLAGS.DEFAULT;
// Rotate Jpegs if possible
if (fileName.EndsWith("jpg", StringComparison.OrdinalIgnoreCase) || fileName.EndsWith("jpeg", StringComparison.OrdinalIgnoreCase))
{
flags = FREE_IMAGE_LOAD_FLAGS.JPEG_ACCURATE | FREE_IMAGE_LOAD_FLAGS.JPEG_EXIFROTATE;
}
// Load the image from disk
try
{
var bmp = new FreeImageBitmap(fileName, flags);
// Convert the image to bitmap
if (bmp.ImageType != FREE_IMAGE_TYPE.FIT_BITMAP)
{
bmp.ConvertType(FREE_IMAGE_TYPE.FIT_BITMAP, true);
}
return(bmp);
}
catch
{
throw;
// return null;
}
}
private static FIBITMAP complexedLoad(FileInfo inputFileInfo)
{
FIBITMAP fibitmap = FIBITMAP.Zero;
FREE_IMAGE_FORMAT freeImageFormat = getComplexedFormat(FileUtil.getSuffix(inputFileInfo.Name));
FREE_IMAGE_LOAD_FLAGS freeImageLoadFlags = FREE_IMAGE_LOAD_FLAGS.DEFAULT;
if (FREE_IMAGE_FORMAT.FIF_UNKNOWN != freeImageFormat)
{
fibitmap = FreeImage.Load(freeImageFormat, inputFileInfo.FullName, freeImageLoadFlags);
}
return(fibitmap);
}
public Base64Image(string dataURI, FREE_IMAGE_LOAD_FLAGS flags)
{
Match match = Regex.Match(dataURI, @"data:image/(?<type>.+?);base64,(?<data>.+)");
if (match.Groups["data"] != null)
{
byte[] byteArray = Convert.FromBase64String(match.Groups["data"].Value);
using (MemoryStream byteStream = new MemoryStream(byteArray))
{
dib.SetNull();
FREE_IMAGE_FORMAT format = FREE_IMAGE_FORMAT.FIF_PNG;
if (match.Groups["type"] != null)
{
switch (match.Groups["type"].Value.ToLower())
{
case "bmp":
{
format = FREE_IMAGE_FORMAT.FIF_BMP;
break;
}
case "png":
{
format = FREE_IMAGE_FORMAT.FIF_PNG;
break;
}
case "jpeg":
case "jpg":
{
format = FREE_IMAGE_FORMAT.FIF_JPEG;
break;
}
case "tga":
{
format = FREE_IMAGE_FORMAT.FIF_TARGA;
break;
}
}
}
dib = FreeImage.LoadFromStream(byteStream, flags, ref format);
}
}
}
public Base64Image(string dataURI, FREE_IMAGE_LOAD_FLAGS flags)
{
Match match = Regex.Match(dataURI, @"data:image/(?<type>.+?);base64,(?<data>.+)");
if (match.Groups["data"] != null)
{
byte[] byteArray = Convert.FromBase64String(match.Groups["data"].Value);
using (MemoryStream byteStream = new MemoryStream(byteArray))
{
dib.SetNull();
FREE_IMAGE_FORMAT format = FREE_IMAGE_FORMAT.FIF_PNG;
if (match.Groups["type"] != null)
{
switch (match.Groups["type"].Value.ToLower())
{
case "bmp":
{
format = FREE_IMAGE_FORMAT.FIF_BMP;
break;
}
case "png":
{
format = FREE_IMAGE_FORMAT.FIF_PNG;
break;
}
case "jpeg":
case "jpg":
{
format = FREE_IMAGE_FORMAT.FIF_JPEG;
break;
}
case "tga":
{
format = FREE_IMAGE_FORMAT.FIF_TARGA;
break;
}
}
}
dib = FreeImage.LoadFromStream(byteStream, flags, ref format);
}
}
}
/// <summary>
/// Loads a .NET <see cref="System.Drawing.Bitmap"/> from a file.
/// </summary>
/// <param name="filename">Name of the file to be loaded.</param>
/// <param name="format">Format of the image. If the format should be taken from the
/// filename use <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/>.</param>
/// <param name="flags">Flags to enable or disable plugin-features.</param>
/// <returns>The loaded .NET <see cref="System.Drawing.Bitmap"/>.</returns>
/// <exception cref="FileNotFoundException">
/// <paramref name="filename"/> does not exists.</exception>
/// <exception cref="ArgumentException">
/// The image type of the image is not <see cref="FREE_IMAGE_TYPE.FIT_BITMAP"/>.</exception>
public static Bitmap LoadBitmap(string filename, FREE_IMAGE_LOAD_FLAGS flags, ref FREE_IMAGE_FORMAT format)
{
FIBITMAP dib = LoadEx(filename, flags, ref format);
Bitmap result = GetBitmap(dib, true);
Unload(dib);
return result;
}
public RenderTexture LoadImage(string path, bool isLinear = false, bool isGrayscale = false, bool doMipMaps = false, bool forceGC = false, bool premultiplyAlpha = false)
{
// default bits per channel
//uint origBPP = outBPP = 0;
bool successfullyLoadedRaw = false;
int width = 0, height = 0;
TextureFormat formatToLoad = TextureFormat.ARGB32;
RenderTextureFormat rtFormat = RenderTextureFormat.ARGB32;
bool forceGrayscaleAfterTexture2D = false;
//System.Threading.Thread newThread = new System.Threading.Thread(() =>
{
var loadType = System.IO.Path.GetExtension(path);
FREE_IMAGE_LOAD_FLAGS loadFlags = FREE_IMAGE_LOAD_FLAGS.DEFAULT;
switch (loadType)
{
case ".png":
loadFlags = FREE_IMAGE_LOAD_FLAGS.PNG_IGNOREGAMMA;
break;
case ".jpg":
case ".jpeg":
loadFlags = FREE_IMAGE_LOAD_FLAGS.JPEG_ACCURATE;
break;
}
// Format is stored in 'format' on successfull load.
FREE_IMAGE_FORMAT format = FREE_IMAGE_FORMAT.FIF_UNKNOWN;
FIBITMAP dib;
bool isModifiedEXR = false;
char yChar = 'Y';
byte yByte = Convert.ToByte(yChar);
char rChar = 'R';
byte rByte = Convert.ToByte(rChar);
//byte[] byteArray = File.ReadAllBytes(path);
FileStream stream = null;
if (Path.GetExtension(path).ToLower() == ".exr")
{
stream = new FileStream(path, FileMode.Open);
stream.Position = 66;
isModifiedEXR = (stream.ReadByte() == rByte);
if (isModifiedEXR)
{
Debug.Log("<color=blue>*** This is a modified EXR </color>");
//byteArray[66] = yByte;
stream.Position = 66;
stream.WriteByte(yByte);
stream.Position = 0;
}
}
#if UNITY_STANDALONE_OSX
if (stream == null)
{
stream = new FileStream(path, FileMode.Open);
}
dib = FreeImage.LoadFromStream(stream, loadFlags, ref format);
#else
dib = FreeImage.LoadEx(path, loadFlags, ref format);
Debug.Log("Used Heap Size After FreeImage.LoadEx: " + Profiler.GetMonoUsedSizeLong() / 1024 / 1024);
#endif
if (stream != null)
{
stream.Dispose();
GC.Collect();
Debug.Log("Used Heap Size After stream.Dispose: " + Profiler.GetMonoUsedSizeLong() / 1024 / 1024);
}
if (isModifiedEXR)
{
using (FileStream fs = new FileStream(path, FileMode.Open))
{
fs.Position = 66;
fs.WriteByte(rByte);
fs.Position = 0;
}
}
rtFormat = RenderTextureFormat.ARGB32;
try
{
// Error handling
if (dib.IsNull)
{
return(null);
}
FREE_IMAGE_TYPE origInputType = FreeImage.GetImageType(dib);
//Debug.Log("DIB for :" + path);
// read bits per channel of loaded image
uint origBPP = FreeImage.GetBPP(dib);
var header = FreeImage.GetInfoHeaderEx(dib);
//Debug.Log("original BPP:" + origBPP);
//Debug.Log("origInputType:" + origInputType);
// check here if we need to convert single channel textures to RGB or vice versa based on source input texture type and destination type expected
FREE_IMAGE_TYPE destType = FREE_IMAGE_TYPE.FIT_UNKNOWN;
switch (origInputType)
{
case FREE_IMAGE_TYPE.FIT_UINT16:
if (!isGrayscale)
{
destType = FREE_IMAGE_TYPE.FIT_RGBAF;
}
else
{
destType = FREE_IMAGE_TYPE.FIT_FLOAT;
}
break;
case FREE_IMAGE_TYPE.FIT_RGBF:
case FREE_IMAGE_TYPE.FIT_RGBAF:
destType = isGrayscale ? FREE_IMAGE_TYPE.FIT_FLOAT : FREE_IMAGE_TYPE.FIT_RGBAF;
break;
case FREE_IMAGE_TYPE.FIT_RGB16:
case FREE_IMAGE_TYPE.FIT_RGBA16:
destType = isGrayscale ? FREE_IMAGE_TYPE.FIT_FLOAT : FREE_IMAGE_TYPE.FIT_RGBAF;
break;
case FREE_IMAGE_TYPE.FIT_BITMAP:
if (isGrayscale)
{
if (Mathf.IsPowerOfTwo(header.biWidth) && Mathf.IsPowerOfTwo(header.biHeight))
{
if (!premultiplyAlpha)
{
dib = FreeImage.ConvertToGreyscale(dib);
}
}
else
{
//int w = Mathf.NextPowerOfTwo(header.biWidth);
//int h = Mathf.NextPowerOfTwo(header.biHeight);
//FIBITMAP bitmap2 = FreeImage.Allocate(w, h, 8);
//FreeImage.Paste(bitmap2, dib, 0, 0, 255);
//FreeImage.UnloadEx(ref dib);
//dib = bitmap2;
forceGrayscaleAfterTexture2D = true;
dib = FreeImage.ConvertTo32Bits(dib);
}
}
else
{
dib = FreeImage.ConvertTo32Bits(dib);
}
destType = FREE_IMAGE_TYPE.FIT_BITMAP;
break;
}
//// premultiply if need be
//if (premultiplyAlpha)
// FreeImage.PreMultiplyWithAlpha(dib);
// convert to destination expected type
if (destType != FREE_IMAGE_TYPE.FIT_UNKNOWN && origInputType != destType)
{
Debug.Log("Trying to convert from:" + origInputType + ", to:" + destType);
dib = FreeImage.ConvertToType(dib, destType, false);
}
//GC.Collect();
Debug.Log("Used Heap Size After FreeImage.ConvertToType: " + Profiler.GetMonoUsedSizeLong() / 1024 / 1024);
//if (isModifiedEXR && origInputType == FREE_IMAGE_TYPE.FIT_FLOAT)
width = (int)FreeImageAPI.FreeImage.GetWidth(dib);
height = (int)FreeImageAPI.FreeImage.GetHeight(dib);
uint bpp = FreeImage.GetBPP(dib);
int pitch = (int)FreeImage.GetPitch(dib);
long byteSize = pitch * height;
Debug.Log("byteSize: " + byteSize);
FREE_IMAGE_TYPE inputType = FreeImage.GetImageType(dib);
if (doMipMaps)
{
byteSize = (long)(byteSize * 1.6666f);
}
//bytes = new byte[byteSize];
FreeImage.ConvertToRawBits(bytes, dib, pitch, bpp, 0, 0, 0, false);
Debug.Log("Used Heap Size After FreeImage.ConvertToRawBits: " + Profiler.GetMonoUsedSizeLong() / 1024 / 1024);
FreeImage.UnloadEx(ref dib);
//GC.Collect();
//Debug.Log("Used Heap Size After FreeImage.UnloadEx: " + Profiler.GetMonoUsedSizeLong() / 1024 / 1024);
// choose texture format
formatToLoad = TextureFormat.ARGB32;
Debug.Log("inputType:" + inputType);
switch (inputType)
{
case FREE_IMAGE_TYPE.FIT_FLOAT:
formatToLoad = TextureFormat.RFloat;
if (origInputType == FREE_IMAGE_TYPE.FIT_UINT16)
{
rtFormat = RenderTextureFormat.RHalf;
}
else
{
rtFormat = RenderTextureFormat.RFloat;
}
break;
case FREE_IMAGE_TYPE.FIT_UINT16:
formatToLoad = TextureFormat.RHalf;
rtFormat = RenderTextureFormat.RHalf;
break;
case FREE_IMAGE_TYPE.FIT_RGBA16:
formatToLoad = TextureFormat.RGBAHalf;
rtFormat = RenderTextureFormat.ARGBHalf;
isLinear = true;
break;
case FREE_IMAGE_TYPE.FIT_RGBAF:
formatToLoad = TextureFormat.RGBAFloat;
if (origInputType == FREE_IMAGE_TYPE.FIT_RGBA16 || origInputType == FREE_IMAGE_TYPE.FIT_RGB16)
{
rtFormat = RenderTextureFormat.ARGBHalf;
}
else
{
rtFormat = RenderTextureFormat.ARGBFloat;
}
isLinear = true;
break;
case FREE_IMAGE_TYPE.FIT_BITMAP:
//Iterate over all scanlines
switch (bpp)
{
case 8:
{
formatToLoad = TextureFormat.Alpha8;
rtFormat = RenderTextureFormat.R8;
}
break;
case 16:
formatToLoad = TextureFormat.RGBA4444;
rtFormat = RenderTextureFormat.ARGB4444;
break;
case 24:
if (FreeImage.IsLittleEndian())
{
int length = bytes.Length;
// make sure it's a multiple of 3
int factor = length / 3;
int adjustedLength = factor * 3;
// convert back to RGB
for (int i = 0; i < adjustedLength; i += 3)
{
// convert BGR to RGB
var r = bytes[i];
bytes[i] = bytes[i + 2];
bytes[i + 2] = r;
}
}
formatToLoad = TextureFormat.RGB24;
rtFormat = RenderTextureFormat.ARGB32;
break;
case 32:
if (forceGrayscaleAfterTexture2D)
{
formatToLoad = TextureFormat.ARGB32;
rtFormat = RenderTextureFormat.R8;
}
else
{
if (FreeImage.IsLittleEndian())
{
int length = bytes.Length;
// make sure it's a multiple of 4
int factor = length / 4;
int adjustedLength = factor * 4;
for (int j = 0; j < adjustedLength; j += 4)
{
// convert BGRA to ARGB
var a = bytes[j];
var r = bytes[j + 1];
bytes[j] = bytes[j + 3];
bytes[j + 1] = bytes[j + 2];
bytes[j + 2] = r;
bytes[j + 3] = a;
}
}
formatToLoad = TextureFormat.ARGB32;
rtFormat = RenderTextureFormat.ARGB32;
}
break;
}
break;
}
successfullyLoadedRaw = true;
}
catch (System.Exception ex)
{
Debug.LogError("Exception: " + ex.Message);
}
}
//);
//newThread.IsBackground = true;
//newThread.Start();
//newThread.Join();
//outBPP = origBPP;
if (successfullyLoadedRaw)
{
RenderTexture temp = LoadRawToTexture2D(bytes, width, height, formatToLoad, rtFormat, doMipMaps, isLinear, forceGC, premultiplyAlpha);
//GC.Collect();
Debug.Log("Used Heap Size After LoadRawToTexture2D: " + Profiler.GetMonoUsedSizeLong() / 1024 / 1024);
return(temp);
}
return(null);
}
public static extern FIMULTIBITMAP OpenMultiBitmapFromHandle(FREE_IMAGE_FORMAT fif, ref FreeImageIO io, fi_handle handle, FREE_IMAGE_LOAD_FLAGS flags);
public static extern FIMULTIBITMAP LoadMultiBitmapFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY stream, FREE_IMAGE_LOAD_FLAGS flags);
private static extern FIBITMAP LoadFromMemoryLinux(FREE_IMAGE_FORMAT fif, FIMEMORY stream, FREE_IMAGE_LOAD_FLAGS flags);
/// <summary>
/// Loads a FreeImage multi-paged bitmap.
/// In case the loading format is <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/> the files
/// real format is being analysed. If no plugin can read the file, format remains
/// <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/> and 0 is returned.
/// Load flags can be provided by the flags parameter.
/// </summary>
/// <param name="filename">The complete name of the file to load.</param>
/// <param name="format">Format of the image. If the format is unknown use
/// <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/>.
/// In case a suitable format was found by LoadEx it will be returned in format.</param>
/// <param name="flags">Flags to enable or disable plugin-features.</param>
/// <param name="create_new">When true a new bitmap is created.</param>
/// <param name="read_only">When true the bitmap will be loaded read only.</param>
/// <param name="keep_cache_in_memory">When true performance is increased at the cost of memory.</param>
/// <returns>Handle to a FreeImage multi-paged bitmap.</returns>
/// <exception cref="FileNotFoundException">
/// <paramref name="filename"/> does not exists while opening.</exception>
public static FIMULTIBITMAP OpenMultiBitmapEx(
string filename,
ref FREE_IMAGE_FORMAT format,
FREE_IMAGE_LOAD_FLAGS flags,
bool create_new,
bool read_only,
bool keep_cache_in_memory)
{
if (!File.Exists(filename) && !create_new)
{
throw new FileNotFoundException(filename + " could not be found.");
}
if (format == FREE_IMAGE_FORMAT.FIF_UNKNOWN)
{
// Check if a plugin can read the data
format = GetFileType(filename, 0);
}
FIMULTIBITMAP dib = 0;
if (FIFSupportsReading(format))
{
dib = OpenMultiBitmap(format, filename, create_new, read_only, keep_cache_in_memory, flags);
}
return dib;
}
/// <summary>
/// Loads a FreeImage multi-paged bitmap from a stream and returns the
/// FreeImage memory stream used as temporary buffer.
/// The bitmap can not be modified by calling
/// <see cref="FreeImage.AppendPage(FIMULTIBITMAP,FIBITMAP)"/>,
/// <see cref="FreeImage.InsertPage(FIMULTIBITMAP,Int32,FIBITMAP)"/>,
/// <see cref="FreeImage.MovePage(FIMULTIBITMAP,Int32,Int32)"/> or
/// <see cref="FreeImage.DeletePage(FIMULTIBITMAP,Int32)"/>.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="format">Format of the image.</param>
/// <param name="flags">Flags to enable or disable plugin-features.</param>
/// <param name="memory">The temporary memory buffer used to load the bitmap.</param>
/// <returns>Handle to a FreeImage multi-paged bitmap.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="stream"/> is null.</exception>
/// <exception cref="ArgumentException">
/// <paramref name="stream"/> can not read.</exception>
public static FIMULTIBITMAP LoadMultiBitmapFromStream(
Stream stream,
FREE_IMAGE_FORMAT format,
FREE_IMAGE_LOAD_FLAGS flags,
out FIMEMORY memory)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (!stream.CanRead)
{
throw new ArgumentException("stream");
}
const int blockSize = 1024;
int bytesRead;
byte[] buffer = new byte[blockSize];
stream = stream.CanSeek ? stream : new StreamWrapper(stream, true);
memory = OpenMemory(IntPtr.Zero, 0);
do
{
bytesRead = stream.Read(buffer, 0, blockSize);
WriteMemory(buffer, (uint)blockSize, (uint)1, memory);
}
while (bytesRead == blockSize);
return LoadMultiBitmapFromMemory(format, memory, flags);
}
/// <summary>
/// Loads a FreeImage bitmap.
/// In case the loading format is <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/>
/// the bitmaps real format is being analysed.
/// The stream must be set to the correct position before calling LoadFromStream.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="flags">Flags to enable or disable plugin-features.</param>
/// <param name="format">Format of the image. If the format is unknown use
/// <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/>.
/// In case a suitable format was found by LoadFromStream it will be returned in format.</param>
/// <returns>Handle to a FreeImage bitmap.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="stream"/> is null.</exception>
/// <exception cref="ArgumentException">
/// <paramref name="stream"/> is not capable of reading.</exception>
public static FIBITMAP LoadFromStream(
Stream stream,
FREE_IMAGE_LOAD_FLAGS flags,
ref FREE_IMAGE_FORMAT format)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (!stream.CanRead)
{
throw new ArgumentException("stream is not capable of reading.");
}
// Wrap the source stream if it is unable to seek (which is required by FreeImage)
stream = (stream.CanSeek) ? stream : new StreamWrapper(stream, true);
// Save the streams position
if (format == FREE_IMAGE_FORMAT.FIF_UNKNOWN)
{
long position = stream.Position;
// Get the format of the bitmap
format = GetFileTypeFromStream(stream);
// Restore the streams position
stream.Position = position;
}
if (!FIFSupportsReading(format))
{
return 0;
}
// Create a 'FreeImageIO' structure for calling 'LoadFromHandle'
// using the internal structure 'FreeImageStreamIO'.
FreeImageIO io = FreeImageStreamIO.io;
using (fi_handle handle = new fi_handle(stream))
{
return LoadFromHandle(format, ref io, handle, flags);
}
}
/// <summary>
/// Loads a FreeImage bitmap.
/// The stream must be set to the correct position before calling LoadFromStream.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="flags">Flags to enable or disable plugin-features.</param>
/// <returns>Handle to a FreeImage bitmap.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="stream"/> is null.</exception>
/// <exception cref="ArgumentException">
/// <paramref name="stream"/> is not capable of reading.</exception>
public static FIBITMAP LoadFromStream(
Stream stream,
FREE_IMAGE_LOAD_FLAGS flags)
{
FREE_IMAGE_FORMAT format = FREE_IMAGE_FORMAT.FIF_UNKNOWN;
return LoadFromStream(stream, flags, ref format);
}
/// <summary>
/// Loads a FreeImage bitmap.
/// In case the loading format is <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/> the files
/// real format is being analysed. If no plugin can read the file, format remains
/// <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/> and 0 is returned.
/// Load flags can be provided by the flags parameter.
/// </summary>
/// <param name="filename">The complete name of the file to load.</param>
/// <param name="flags">Flags to enable or disable plugin-features.</param>
/// <param name="format">Format of the image. If the format is unknown use
/// <see cref="FREE_IMAGE_FORMAT.FIF_UNKNOWN"/>.
/// In case a suitable format was found by LoadEx it will be returned in format.
/// </param>
/// <returns>Handle to a FreeImage bitmap.</returns>
/// <exception cref="FileNotFoundException">
/// <paramref name="filename"/> does not exists.</exception>
public static FIBITMAP LoadEx(string filename, FREE_IMAGE_LOAD_FLAGS flags, ref FREE_IMAGE_FORMAT format)
{
// check if file exists
if (!File.Exists(filename))
{
throw new FileNotFoundException(filename + " could not be found.");
}
FIBITMAP dib = 0;
if (format == FREE_IMAGE_FORMAT.FIF_UNKNOWN)
{
// query all plugins to see if one can read the file
format = GetFileType(filename, 0);
}
// check if the plugin is capable of loading files
if (FIFSupportsReading(format))
{
dib = Load(format, filename, flags);
}
return dib;
}
/// <summary>
/// Loads a FreeImage bitmap.
/// Load flags can be provided by the flags parameter.
/// </summary>
/// <param name="filename">The complete name of the file to load.</param>
/// <param name="flags">Flags to enable or disable plugin-features.</param>
/// <returns>Handle to a FreeImage bitmap.</returns>
/// <exception cref="FileNotFoundException">
/// <paramref name="filename"/> does not exists.</exception>
public static FIBITMAP LoadEx(string filename, FREE_IMAGE_LOAD_FLAGS flags)
{
FREE_IMAGE_FORMAT format = FREE_IMAGE_FORMAT.FIF_UNKNOWN;
return LoadEx(filename, flags, ref format);
}
/// <summary>
/// Decodes the given stream, selects the correct page or frame, rotates it correctly (if autorotate=true), then executes the callback, then cleans up.
/// </summary>
/// <param name="s"></param>
/// <param name="settings"></param>
/// <param name="callback"></param>
/// <returns></returns>
public static object DecodeAndCall(Stream s, ResizeSettings settings, DecodeCallback callback)
{
if (!FreeImageAPI.FreeImage.IsAvailable())
{
return(null);
}
FREE_IMAGE_LOAD_FLAGS flags = FREE_IMAGE_LOAD_FLAGS.DEFAULT;
//If we're not tone-mapping the raw file, convert it for display
if (!HasToneMappingCommands(settings))
{
flags |= FREE_IMAGE_LOAD_FLAGS.RAW_DISPLAY;
}
bool usethumb = ("true".Equals(settings["usepreview"], StringComparison.OrdinalIgnoreCase));
if (usethumb)
{
flags |= FREE_IMAGE_LOAD_FLAGS.RAW_PREVIEW;
}
bool autorotate = ("true".Equals(settings["autorotate"], StringComparison.OrdinalIgnoreCase));
if (autorotate)
{
flags |= FREE_IMAGE_LOAD_FLAGS.JPEG_EXIFROTATE;
}
int page = 0;
if (!string.IsNullOrEmpty(settings["page"]) && !int.TryParse(settings["page"], NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out page))
{
page = 0;
}
int frame = 0;
if (!string.IsNullOrEmpty(settings["frame"]) && !int.TryParse(settings["frame"], NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out frame))
{
frame = 0;
}
if (page == 0 && frame != 0)
{
page = frame;
}
Stopwatch sw = new Stopwatch();
sw.Start();
if (page > 1)
{
FREE_IMAGE_FORMAT fmt = FREE_IMAGE_FORMAT.FIF_UNKNOWN;
FIMULTIBITMAP mb = FreeImage.OpenMultiBitmapFromStream(s, ref fmt, flags);
//Prevent asking for a non-existent page
int pages = FreeImage.GetPageCount(mb);
if (page > pages)
{
page = pages;
}
try {
if (mb.IsNull)
{
return(null);
}
FIBITMAP bPage = FreeImage.LockPage(mb, page - 1);
if (bPage.IsNull)
{
return(null);
}
try {
sw.Stop();
return(ToneMap(ref bPage, false, settings, callback));
} finally {
FreeImage.UnlockPage(mb, bPage, false);
}
} finally {
if (!mb.IsNull)
{
FreeImage.CloseMultiBitmapEx(ref mb, FREE_IMAGE_SAVE_FLAGS.DEFAULT);
}
}
}
else
{
FIBITMAP original = FIBITMAP.Zero;
try {
original = FreeImage.LoadFromStream(s, flags);
sw.Stop();
if (original.IsNull)
{
return(null);
}
return(ToneMap(ref original, true, settings, callback));
} finally {
if (!original.IsNull)
{
FreeImage.UnloadEx(ref original);
}
}
}
}
public static extern FIBITMAP LoadFromHandle(FREE_IMAGE_FORMAT fif, ref FreeImageIO io, fi_handle handle, FREE_IMAGE_LOAD_FLAGS flags);
private static extern FIMULTIBITMAP OpenMultiBitmapWindows(FREE_IMAGE_FORMAT fif, string filename, bool create_new, bool read_only, bool keep_cache_in_memory, FREE_IMAGE_LOAD_FLAGS flags);
public static extern FIMULTIBITMAP OpenMultiBitmap(FREE_IMAGE_FORMAT fif, string filename, bool create_new, bool read_only, bool keep_cache_in_memory, FREE_IMAGE_LOAD_FLAGS flags);
private static extern FIBITMAP LoadWindows(FREE_IMAGE_FORMAT fif, [MarshalAs(UnmanagedType.LPStr)] string filename, FREE_IMAGE_LOAD_FLAGS flags);
private static extern FIBITMAP LoadU(FREE_IMAGE_FORMAT fif, string filename, FREE_IMAGE_LOAD_FLAGS flags);
private static extern FIBITMAP LoadUWindows(FREE_IMAGE_FORMAT fif, string filename, FREE_IMAGE_LOAD_FLAGS flags);
//public Texture2D tex;
public byte[] LoadImageBytes(string path, bool isLinear = false, bool isGrayscale = false, bool doMipMaps = false, bool forceGC = false, bool premultiplyAlpha = false)
{
// default bits per channel
//uint origBPP = outBPP = 0;
bool successfullyLoadedRaw = false;
int width = 0, height = 0;
TextureFormat formatToLoad = TextureFormat.ARGB32;
RenderTextureFormat rtFormat = RenderTextureFormat.ARGB32;
bool forceGrayscaleAfterTexture2D = false;
var loadType = System.IO.Path.GetExtension(path);
FREE_IMAGE_LOAD_FLAGS loadFlags = FREE_IMAGE_LOAD_FLAGS.DEFAULT;
switch (loadType)
{
case ".png":
loadFlags = FREE_IMAGE_LOAD_FLAGS.PNG_IGNOREGAMMA;
break;
case ".jpg":
case ".jpeg":
loadFlags = FREE_IMAGE_LOAD_FLAGS.JPEG_ACCURATE;
break;
}
// Format is stored in 'format' on successfull load.
FREE_IMAGE_FORMAT format = FREE_IMAGE_FORMAT.FIF_UNKNOWN;
FIBITMAP dib;
bool isModifiedEXR = false;
char yChar = 'Y';
byte yByte = Convert.ToByte(yChar);
char rChar = 'R';
byte rByte = Convert.ToByte(rChar);
//byte[] byteArray = File.ReadAllBytes(path);
FileStream stream = null;
if (Path.GetExtension(path).ToLower() == ".exr")
{
stream = new FileStream(path, FileMode.Open);
stream.Position = 66;
isModifiedEXR = (stream.ReadByte() == rByte);
if (isModifiedEXR)
{
Debug.Log("<color=blue>*** This is a modified EXR </color>");
//byteArray[66] = yByte;
stream.Position = 66;
stream.WriteByte(yByte);
stream.Position = 0;
}
}
#if UNITY_STANDALONE_OSX
if (stream == null)
{
stream = new FileStream(path, FileMode.Open);
}
dib = FreeImage.LoadFromStream(stream, loadFlags, ref format);
#else
dib = FreeImage.LoadEx(path, loadFlags, ref format);
Debug.Log("Used Heap Size After FreeImage.LoadEx: " + Profiler.GetMonoUsedSizeLong() / 1024 / 1024);
#endif
if (stream != null)
{
stream.Dispose();
GC.Collect();
Debug.Log("Used Heap Size After stream.Dispose: " + Profiler.GetMonoUsedSizeLong() / 1024 / 1024);
}
width = (int)FreeImageAPI.FreeImage.GetWidth(dib);
height = (int)FreeImageAPI.FreeImage.GetHeight(dib);
uint bpp = FreeImage.GetBPP(dib);
int pitch = (int)FreeImage.GetPitch(dib);
long byteSize = pitch * height;
Debug.Log("width: " + width + ", height: " + height + ", bpp: " + bpp + ", pitch: " + pitch + "byteSize: " + byteSize);
if (doMipMaps)
{
byteSize = (long)(byteSize * 1.6666f);
}
FreeImage.ConvertToRawBits(bytes, dib, pitch, bpp, 0, 0, 0, false);
FreeImage.UnloadEx(ref dib);
return(bytes);
}
private static extern FIMULTIBITMAP LoadMultiBitmapFromMemoryWindows(FREE_IMAGE_FORMAT fif, FIMEMORY stream, FREE_IMAGE_LOAD_FLAGS flags);
