ImageCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using SkiaSharp;
using Waher.Runtime.Inventory;
using System.Threading.Tasks;
 
namespace Waher.Content.Images
{
    public class ImageCodec : IContentDecoder, IContentEncoder
    {
        public ImageCodec()
        {
        }
 
        public const string ContentTypeWebP = "image/webp";
 
        public const string ContentTypePng = "image/png";
 
        public const string ContentTypeJpg = "image/jpeg";
 
        public const string ContentTypeIcon = "image/x-icon";
 
        public const string ContentTypeSvg = "image/svg+xml";
 
        public const string ContentTypeBmp = "image/bmp";
 
        public const string ContentTypeGif = "image/gif";
 
        public const string ContentTypeTiff = "image/tiff";
 
        public const string ContentTypeWmf = "image/x-wmf";
 
        public const string ContentTypeEmf = "image/x-emf";
 
        public const string FileExtensionPng = "png";
 
        public const string FileExtensionBmp = "bmp";
 
        public const string FileExtensionGif = "gif";
 
        public const string FileExtensionJpg = "jpg";
 
        public const string FileExtensionWebP = "webp";
 
        public const string FileExtensionTiff = "tif";
 
        public const string FileExtensionWmf = "wmf";
 
        public const string FileExtensionEmf = "emf";
 
        public const string FileExtensionIcon = "ico";
 
        public const string FileExtensionSvg = "svg";
 
 
        public static readonly string[] ImageContentTypes = new string[] 
        {
            ContentTypeWebP, 
            ContentTypePng,
            ContentTypeJpg,
            ContentTypeIcon,
            ContentTypeBmp,
            ContentTypeGif, 
            ContentTypeTiff, 
            ContentTypeWmf, 
            ContentTypeEmf
        };
 
        public static readonly string[] ImageFileExtensions = new string[] 
        {
            FileExtensionWebP, 
            FileExtensionPng, 
            FileExtensionBmp,
            FileExtensionGif, 
            FileExtensionJpg, 
            "jpeg", 
            FileExtensionTiff, 
            "tiff",
            FileExtensionWmf, 
            FileExtensionEmf, 
            FileExtensionIcon
        };
 
        public string[] ContentTypes => ImageContentTypes;
 
        public string[] FileExtensions => ImageFileExtensions;
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(ImageContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Excellent;
                return true;
            }
            else if (ContentType.StartsWith("image/"))
            {
                Grade = Grade.Barely;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<object> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair<string, string>[] Fields, Uri BaseUri)
        {
            SKBitmap Bitmap = SKBitmap.Decode(Data);
            return Task.FromResult<object>(SKImage.FromBitmap(Bitmap));
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if ((Object is SKImage || Object is SKBitmap) && InternetContent.IsAccepted(this.ContentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<KeyValuePair<byte[], string>> EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
        {
            SKData Data;
            bool Dispose = false;
            string ContentType;
            byte[] Bin;
 
            if (!(Object is SKImage Image))
            {
                if (Object is SKBitmap Bitmap)
                {
                    Image = SKImage.FromBitmap(Bitmap);
                    Dispose = true;
                }
                else
                    throw new ArgumentException("Object not an image derived from SkiaSharp.SKImage or SkiaSharp.SKBitmap.", nameof(Object));
            }
 
            if (InternetContent.IsAccepted(ContentTypeWebP, AcceptedContentTypes))
            {
                Data = Image.Encode(SKEncodedImageFormat.Webp, 100);
                ContentType = ContentTypeWebP;
            }
            else if (InternetContent.IsAccepted(ContentTypePng, AcceptedContentTypes))
            {
                Data = Image.Encode(SKEncodedImageFormat.Png, 100);
                ContentType = ContentTypePng;
            }
            else if (InternetContent.IsAccepted(ContentTypeBmp, AcceptedContentTypes))
            {
                Data = Image.Encode(SKEncodedImageFormat.Bmp, 100);
                ContentType = ContentTypeBmp;
            }
            else if (InternetContent.IsAccepted(ContentTypeJpg, AcceptedContentTypes))
            {
                Data = Image.Encode(SKEncodedImageFormat.Jpeg, 90);
                ContentType = ContentTypeJpg;
            }
            else if (InternetContent.IsAccepted(ContentTypeGif, AcceptedContentTypes))
            {
                Data = Image.Encode(SKEncodedImageFormat.Gif, 100);
                ContentType = ContentTypeGif;
            }
            else if (InternetContent.IsAccepted(ContentTypeIcon, AcceptedContentTypes))
            {
                Data = Image.Encode(SKEncodedImageFormat.Ico, 100);
                ContentType = ContentTypeIcon;
            }
            else
                throw new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object));
 
            Bin = Data.ToArray();
            Data.Dispose();
 
            if (Dispose)
                Image.Dispose();
 
            return Task.FromResult(new KeyValuePair<byte[], string>(Bin, ContentType));
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            switch (FileExtension.ToLower())
            {
                case FileExtensionPng:
                    ContentType = ContentTypePng;
                    return true;
 
                case FileExtensionBmp:
                    ContentType = ContentTypeBmp;
                    return true;
 
                case FileExtensionGif:
                    ContentType = ContentTypeGif;
                    return true;
 
                case FileExtensionJpg:
                case "jpeg":
                    ContentType = ContentTypeJpg;
                    return true;
 
                case FileExtensionWebP:
                    ContentType = ContentTypeWebP;
                    return true;
 
                case FileExtensionTiff:
                case "tiff":
                    ContentType = ContentTypeTiff;
                    return true;
 
                case FileExtensionWmf:
                    ContentType = ContentTypeWmf;
                    return true;
 
                case FileExtensionEmf:
                    ContentType = ContentTypeEmf;
                    return true;
    
                case FileExtensionIcon:
                    ContentType = ContentTypeIcon;
                    return true;
 
                case FileExtensionSvg:
                    ContentType = ContentTypeSvg;
                    return true;
 
                default:
                    ContentType = string.Empty;
                    return false;
            }
        }
    
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case ContentTypePng:
                    FileExtension = FileExtensionPng;
                    return true;
 
                case ContentTypeBmp:
                    FileExtension = FileExtensionBmp;
                    return true;
 
                case ContentTypeGif:
                    FileExtension = FileExtensionGif;
                    return true;
 
                case ContentTypeJpg:
                    FileExtension = FileExtensionJpg;
                    return true;
 
                case ContentTypeWebP:
                    FileExtension = FileExtensionWebP;
                    return true;
 
                case ContentTypeTiff:
                    FileExtension = FileExtensionTiff;
                    return true;
 
                case ContentTypeWmf:
                    FileExtension = FileExtensionWmf;
                    return true;
 
                case ContentTypeEmf:
                    FileExtension = FileExtensionEmf;
                    return true;
 
                case ContentTypeIcon:
                    FileExtension = FileExtensionIcon;
                    return true;
 
                case ContentTypeSvg:
                    FileExtension = FileExtensionSvg;
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
    }
}