WebImage(string fileName, string cachePath)
{
string ext = Path.GetExtension(fileName);
FileName = fileName;
MimeType = MimeTypes.FromExtension(ext);
this.LogDebug("Loading Bitmap32 from file {0}", fileName);
Data = File.ReadAllBytes(fileName);
//read thumb if present
var ThumbFileName = FileSystem.Combine(cachePath, Path.GetFileNameWithoutExtension(fileName) + "-thumb" + ext);
if (File.Exists(ThumbFileName))
{
//but check if the image was changed first.
if (FileSystem.GetLastWriteTimeUtc(ThumbFileName) > FileSystem.GetLastWriteTimeUtc(fileName))
{
ThumbData = File.ReadAllBytes(ThumbFileName);
return;
}
}
//need to recreate thumb
using (var bmp = Bitmap32.Create(Data))
{
switch (MimeType)
{
case "image/jpeg": ThumbData = RenderThumb(bmp, ThumbFileName, ImageType.Jpeg); break;
case "image/png": ThumbData = RenderThumb(bmp, ThumbFileName, ImageType.Png); break;
default: throw new NotImplementedException();
}
}
}
/// <summary>
/// Gets the content-type from the response's headers. The default type
/// is derived from the file extension of the path, if any.
/// </summary>
/// <param name="response">The response to examine.</param>
/// <returns>The provided or default content-type.</returns>
public static MimeType GetContentType(this IResponse response)
{
var fileName = response.Address.Path;
var index = fileName.LastIndexOf('.');
var extension = index >= 0 ? fileName.Substring(index) : ".a";
var defaultType = MimeTypes.FromExtension(MimeTypes.Binary);
return(response.GetContentType(defaultType));
}
/// <summary>
/// Creates a new file entry from the given file properties.
/// </summary>
/// <param name="name">The name of the file (not the full path).</param>
/// <param name="body">The stream of bytes of the file's contents.</param>
/// <returns>The file entry.</returns>
public static FileEntry FromFile(String name, Stream body)
{
using (var ms = new MemoryStream())
{
body.CopyTo(ms);
return(new FileEntry {
FileName = name, Type = MimeTypes.FromExtension(Path.GetExtension(name)), Body = ms.ToArray()
});
}
}
bool TryGetThumb(WebData webData, MDBImage img, string fileName)
{
try
{
//try to load thumb
var hash = Base32.Safe.Encode(Hash.FromString(Hash.Type.SHA256, fileName));
string thumbFileName = FileSystem.Combine(mdb.CacheFolder, "Thumbs", hash + ".jpg");
var mime = MimeTypes.FromExtension(".jpg");
if (File.Exists(thumbFileName))
{
try
{
webData.Answer = WebAnswer.Raw(webData.Request, WebMessage.Create(webData.Method, thumbFileName), File.ReadAllBytes(thumbFileName), mime);
webData.Answer.SetCacheTime(TimeSpan.FromDays(1));
return(true);
}
catch { /*file access error, writing in progress ?, wait for lock and retry*/ }
}
//wait until last thumb generation is finished
byte[] data;
lock (ThumbCreateSyncRoot)
{
//do a second check after lock is released...
if (File.Exists(thumbFileName))
{
try
{
webData.Answer = WebAnswer.Raw(webData.Request, WebMessage.Create(webData.Method, thumbFileName), File.ReadAllBytes(thumbFileName), mime);
webData.Answer.SetCacheTime(TimeSpan.FromDays(1));
return(true);
}
catch { /*file access error, recreate thumb*/ }
}
//generate thumb
using (var bmp = Bitmap32.FromFile(fileName))
{
data = WebImage.RenderThumb(bmp, thumbFileName);
}
}
webData.Answer = WebAnswer.Raw(webData.Request, WebMessage.Create(webData.Method, thumbFileName), data, mime);
webData.Answer.AllowCompression = false;
webData.Answer.SetCacheTime(TimeSpan.FromDays(1));
return(true);
}
catch (Exception ex)
{
this.LogError(ex, "Could not load / create thumb for {0}", fileName);
}
return(false);
}
/// <summary>
/// Creates a new header.
/// </summary>
/// <param name="header">The tag header.</param>
/// <param name="flags">The flags.</param>
/// <param name="description">The description.</param>
/// <param name="type">The type.</param>
/// <param name="image">The image.</param>
/// <param name="imageFormat">The image format.</param>
/// <param name="quality">The quality.</param>
/// <returns></returns>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static ID3v2APICFrame Create(ID3v2Header header, ID3v2FrameFlags flags, string description, ID3v2PictureType type,
SkiaSharp.SKImage image, SkiaSharp.SKEncodedImageFormat imageFormat = SkiaSharp.SKEncodedImageFormat.Jpeg, int quality = 99)
{
var data = image.Encode(imageFormat, quality);
string mimeType;
switch (imageFormat)
{
case SkiaSharp.SKEncodedImageFormat.Jpeg: mimeType = MimeTypes.FromExtension(".jpg"); break;
case SkiaSharp.SKEncodedImageFormat.Png: mimeType = MimeTypes.FromExtension(".png"); break;
default: throw new ArgumentOutOfRangeException(string.Format("ImageFormat {0} not suppoerted!", imageFormat));
}
return(Create(header, flags, description, type, mimeType, data.ToArray()));
}