public void GetImage(WebData webData, long imageID, bool thumb = false)
{
try
{
MDBImage img = mdb.Images.TryGetStruct(imageID);
MDBFile file = mdb.Files.TryGetStruct(img.FileID);
if (file.ID > 0)
{
string fullPath = file.GetFullPath(mdb);
if (thumb)
{
if (TryGetThumb(webData, img, fullPath))
{
return;
}
}
webData.Answer = WebAnswer.Raw(webData.Request, WebMessage.Create(fullPath, "/mdb/image/get"), File.ReadAllBytes(fullPath), img.MimeType);
webData.Answer.AllowCompression = false;
webData.Answer.SetCacheTime(TimeSpan.FromHours(1));
return;
}
}
catch { }
webData.Result.AddMessage(webData.Method, WebError.NotFound, "Image {0} cannot be found!", imageID);
}
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>Saves the album image.</summary>
/// <param name="folder">The folder.</param>
/// <param name="name">The name.</param>
/// <param name="imageType">Type of the image.</param>
/// <param name="album">The album.</param>
/// <param name="data">The data.</param>
/// <exception cref="Exception">Invalid image type!</exception>
public void SaveAlbumImage(MDBFolder folder, string name, MDBImageType imageType, MDBAlbum album, byte[] data)
{
var image = new MDBImage()
{
MusicBrainzGuid = album.MusicBrainzReleaseGroupGuid,
Type = imageType,
};
if (!image.IsAlbumArt)
{
throw new Exception("Invalid image type!");
}
SaveImage(data, folder, name, ref image, album);
}
/// <summary>Saves the artist image.</summary>
/// <param name="folder">The folder.</param>
/// <param name="name">The name.</param>
/// <param name="imageType">Type of the image.</param>
/// <param name="artist">The artist.</param>
/// <param name="data">The data.</param>
/// <exception cref="Exception">Invalid image type!</exception>
public void SaveArtistImage(MDBFolder folder, string name, MDBImageType imageType, MDBArtist artist, byte[] data)
{
var image = new MDBImage()
{
MusicBrainzGuid = artist.MusicBrainzArtistGuid,
Type = imageType,
};
if (!image.IsArtistArt)
{
throw new Exception("Invalid image type!");
}
SaveImage(data, folder, name, ref image, artist);
WriteArtistIni(folder, artist);
}
bool SaveImage(byte[] data, MDBFolder mdbFolder, string name, ref MDBImage image, object obj)
{
string fullPath;
var file = new MDBFile()
{
FolderID = mdbFolder.ID,
Name = name,
};
ImageType imgType;
switch (image.Type)
{
case MDBImageType.ArtistMusicBanner:
case MDBImageType.ArtistMusicLogo:
case MDBImageType.ArtistMusicLogoHD:
case MDBImageType.AlbumCDArt:
fullPath = mdbFolder.GetFullPath(this, name + ".png");
file.Extension = ".png";
file.FileType = MDBFileType.png;
imgType = ImageType.Png;
image.MimeType = "image/png";
break;
default:
fullPath = mdbFolder.GetFullPath(this, name + ".jpg");
file.Extension = ".jpg";
imgType = ImageType.Jpeg;
file.FileType = MDBFileType.jpeg;
image.MimeType = "image/jpg";
break;
}
int width, height;
using (var img = Bitmap32.Create(data))
{
width = img.Width; height = img.Height;
//save if not present at disk
if (!File.Exists(fullPath))
{
using (var ms = new MemoryStream())
{
img.Save(ms, imgType, 99);
data = ms.ToArray();
}
}
}
bool writeFile = true;
//find old dataset (check for replace)
{
if (TryGetFile(fullPath, false, out MDBFile mdbFile))
{
file.ID = mdbFile.ID;
if (mdbFile.GetFullPath(this) == fullPath)
{
writeFile = false;
}
else
{
string oldPath = mdbFile.GetFullPath(this);
File.Delete(oldPath);
}
}
}
//save image data
if (writeFile)
{
foreach (string oldFile in Directory.GetFiles(Path.GetDirectoryName(fullPath), Path.GetFileNameWithoutExtension(fullPath) + ".*"))
{
File.Delete(oldFile);
if (TryGetFile(oldFile, false, out MDBFile mdbFile))
{
Files.Delete(mdbFile.ID);
}
this.LogInfo("Deleted old file {0}", oldFile);
}
File.WriteAllBytes(fullPath, data);
this.LogInfo("Saved new image {0}", fullPath);
}
//get fileinfo
var fileInfo = new FileInfo(fullPath);
//create file dataset
file.DateTime = fileInfo.LastWriteTimeUtc;
file.Size = fileInfo.Length;
if (file.ID > 0)
{
Files.Replace(file);
}
else
{
file.ID = Files.Insert(file);
}
//update image dataset
image.Width = width;
image.Height = height;
image.FileID = file.ID;
if (Images.Exist(file.ID))
{
Images.Replace(image);
this.LogNotice("<cyan>Update {0} image<default> dataset for <yellow>{1} <default>{2}", image, obj, mdbFolder);
return(false);
}
else
{
Images.Insert(image);
this.LogNotice("<green>New {0} image<default> dataset for <yellow>{1} <default>{2}", image, obj, mdbFolder);
return(true);
}
}
