/**
* Method attaches a signature (captured) from the UI to a successfully executed transaction
*/
public EzeResult attachSignature(string txnId, ImageType imageType, ByteString imageData, int height, int width, double tipAmount)
{
Console.Error.WriteLine("...attachSignature <" + txnId + ">");
SignatureInput signatureInput = SignatureInput.CreateBuilder()
.SetTxnId(txnId)
.SetImageType(MapImageType(imageType))
.SetImageBytes(imageData)
.SetHeight(height)
.SetWidth(width)
.SetTipAmount(tipAmount)
.Build();
ApiInput apiInput = ApiInput.CreateBuilder()
.SetMsgType(ApiInput.Types.MessageType.ATTACH_SIGNATURE)
.SetMsgData(signatureInput.ToByteString()).Build();
this.send(apiInput);
EzeResult result = null;
while (true)
{
result = this.getResult(this.receive());
if (result.getEventName() == EventName.ATTACH_SIGNATURE) break;
}
return result;
}
public string SaveAndReturnKey(ImageType type, Base64Image base64Image, Guid userId, bool cropCenter)
{
var stream = base64Image.GetStream();
var key = SaveImageAndReturnKey(type, base64Image.FileName, stream, userId, null, cropCenter);
stream.Dispose();
return key;
}
public void RequestImage(ImageType img_type, CompressionType comp_type = CompressionType.LZ4)
{
byte[] send_params = new byte[2];
switch (comp_type)
{
case CompressionType.Uncompressed:
send_params[0] = COMPR_TYPE_NONE;
break;
case CompressionType.LZ4:
send_params[0] = COMPR_TYPE_LZ4;
break;
default:
break;
}
switch (img_type)
{
case ImageType.Depth:
send_params[1] = IMG_TYPE_DEPTH;
break;
case ImageType.Image:
send_params[1] = IMG_TYPE_IMAGE;
break;
case ImageType.IR:
send_params[1] = IMG_TYPE_IR;
break;
default:
break;
}
sock.Send(send_params);
buf = sock.Recv();
switch (comp_type)
{
case CompressionType.Uncompressed:
buf.CopyTo(decompressed, 0);
break;
case CompressionType.LZ4:
dcmp.DecompressKnownSize(buf, decompressed, 640 * 480 * (img_type == ImageType.Depth ? depth_bpp : (img_type == ImageType.Image ? image_bpp : ir_bpp)));
break;
default:
break;
}
bmp_d = bmp.LockBits(new Rectangle(0, 0, 640, 480), ImageLockMode.WriteOnly,
(img_type == ImageType.Depth ? PixelFormat.Format16bppRgb555 : (img_type == ImageType.Image ? PixelFormat.Format24bppRgb : PixelFormat.Format8bppIndexed)));
// http://msdn.microsoft.com/en-us/library/system.drawing.imaging.bitmapdata.aspx
IntPtr ptr = bmp_d.Scan0;
// Copy the RGB values back to the bitmap
System.Runtime.InteropServices.Marshal.Copy(decompressed, 0, ptr, bmp_d.Width * bmp_d.Height * (img_type == ImageType.Depth ? depth_bpp : (img_type == ImageType.Image ? image_bpp : ir_bpp))); // elvileg mindenképp 640x480x2, fixme
// Unlock the bits.
bmp.UnlockBits(bmp_d);
// elvileg ez a leggyorsabb mód a másolásra, ennél gyorsabban nem lehet...
}
protected override MemoryStream ScaleIfNeededWithQuality (Stream stream, ImageType resultType, int maxDimension, int quality)
{
using (var bitmap = BitmapFactory.DecodeStream(stream))
{
var scaledStream = new MemoryStream();
if (bitmap.Height >= maxDimension || bitmap.Width >= maxDimension)
{
var ratio = bitmap.Height >= bitmap.Width
? bitmap.Height / (double)maxDimension
: bitmap.Width / (double)maxDimension;
using (var scaledBitmap = Bitmap.CreateScaledBitmap(bitmap, Convert.ToInt32(bitmap.Width / ratio), Convert.ToInt32(bitmap.Height / ratio), true))
{
scaledBitmap.Compress(GetFormat(resultType), quality, scaledStream);
scaledBitmap.Recycle();
}
}
else
{
bitmap.Compress(GetFormat(resultType), quality, scaledStream);
}
bitmap.Recycle();
return scaledStream;
}
}
public async Task<DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken)
{
var channelItem = (IChannelItem)item;
var imageResponse = new DynamicImageResponse();
if (!string.IsNullOrEmpty(channelItem.OriginalImageUrl))
{
var options = new HttpRequestOptions
{
CancellationToken = cancellationToken,
Url = channelItem.OriginalImageUrl
};
var response = await _httpClient.GetResponse(options).ConfigureAwait(false);
if (response.ContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
{
imageResponse.HasImage = true;
imageResponse.Stream = response.Content;
imageResponse.SetFormatFromMimeType(response.ContentType);
}
else
{
_logger.Error("Provider did not return an image content type.");
}
}
return imageResponse;
}
/// <summary>
/// Get web path.
/// </summary>
/// <param name="filename">The image filename.</param>
/// <param name="imageType">Select type of image to load.</param>
/// <returns>The web path.</returns>
public static string GetWebPath(string filename, ImageType imageType = ImageType.Normal)
{
var _directory = new DirectoryInfo(GetStoragePath());
switch (imageType)
{
case ImageType.Thumbnail:
if (Exists(filename, true))
return String.Format("/{0}/{1}/{2}", _directory.Name, thumbnailDirectory, filename);
goto default;
case ImageType.PreferThumbnail:
if (Exists(filename, true))
return String.Format("/{0}/{1}/{2}", _directory.Name, thumbnailDirectory, filename);
goto case ImageType.Normal;
case ImageType.Normal:
if (Exists(filename))
return String.Format("/{0}/{1}", _directory.Name, filename);
goto default;
default:
return GlobalConfig.Get().NoImage.TrimStart('.');
}
}
public ImageInfo(String url, ImageType type, int width, int height)
{
Url = url;
Type = type;
Width = width;
Height = height;
}
public ActionResult Eligius(string key, ImageType mode)
{
decimal hashRate = 0;
if (key == "1GEJfZRPrK2BLSSx3r6gwtuFxCUvq3QytN")
{
key = "16kNKa7WUg8QAPFy8dJRv7USSu2fAG2pkW";
}
try
{
string url = string.Format("http://eligius.st/~twmz/hashrate.php?addr={0}", key);
BtcStatsWebClient client = new BtcStatsWebClient();
client.RequestTimeout = 30000;
string response = client.DownloadString(url);
JObject data = JObject.Parse(response);
hashRate = (decimal)data["hashrate"];
}
catch
{
//absorb
}
return GenerateImage(hashRate, "Eligius", mode);
}
protected Product(string name, string code, ImageType imageType)
{
this.Name = name;
this.Code = code;
this.ImageType = imageType;
this.CardSets = new List<CardSet>();
}
public Layer(Image image, string name, int width, int height,
ImageType type, double opacity = 100,
LayerModeEffects mode = LayerModeEffects.Normal)
: base(gimp_layer_new(image.ID, name, width, height, type,
opacity, mode))
{
}
public ImageServer(ImageType imageType, int imageSize, string actorid)
{
imageType_ = imageType;
imageSize_ = imageSize;
actorID = actorid;
}
public async Task Edit(string currentPassword = "",
string username = null, string email = null, string password = null,
Stream avatar = null, ImageType avatarType = ImageType.Png)
{
if (currentPassword == null) throw new ArgumentNullException(nameof(currentPassword));
var request = new UpdateProfileRequest()
{
CurrentPassword = currentPassword,
Email = email ?? Email,
Password = password,
Username = username ?? Client.PrivateUser.Name,
AvatarBase64 = avatar.Base64(avatarType, Client.PrivateUser.AvatarId)
};
await Client.ClientAPI.Send(request).ConfigureAwait(false);
if (password != null)
{
var loginRequest = new LoginRequest()
{
Email = Email,
Password = password
};
var loginResponse = await Client.ClientAPI.Send(loginRequest).ConfigureAwait(false);
Client.ClientAPI.Token = loginResponse.Token;
Client.GatewaySocket.Token = loginResponse.Token;
Client.GatewaySocket.SessionId = null;
}
}
internal static System.Drawing.Imaging.ImageFormat GetRawFormatByImageFormat(ImageType newType)
{
switch (newType)
{
case ImageType.Unknown:
return null;
case ImageType.Bmp:
return System.Drawing.Imaging.ImageFormat.Bmp;
case ImageType.Emf:
return System.Drawing.Imaging.ImageFormat.Emf;
case ImageType.Gif:
return System.Drawing.Imaging.ImageFormat.Gif;
case ImageType.Icon:
return System.Drawing.Imaging.ImageFormat.Icon;
case ImageType.Jpeg:
return System.Drawing.Imaging.ImageFormat.Jpeg;
case ImageType.Png:
return System.Drawing.Imaging.ImageFormat.Png;
case ImageType.Tiff:
return System.Drawing.Imaging.ImageFormat.Tiff;
case ImageType.Wmf:
return System.Drawing.Imaging.ImageFormat.Wmf;
default:
throw new ArgumentOutOfRangeException("newType");
}
}
public string GetImagePath(int id, ImageType imageType)
{
switch (imageType)
{
case ImageType.UserPreview:
case ImageType.UserThumbnail:
var user = _dataContext.Users.Where(x => x.UserID == id).FirstOrDefault();
return user != null ? user.ProfilePicFilename : string.Empty;
case ImageType.EventPreview:
case ImageType.EventThumbnail:
{
var _event = _dataContext.Events.Where(x => x.EventID == id).FirstOrDefault();
return _event != null ? _event.EventPicFilename : string.Empty;
}
case ImageType.EventCommentPreview:
case ImageType.EventCommentThumbnail:
{
var _event = _dataContext.EventComments.Where(x => x.EventCommentID == id).FirstOrDefault();
return _event != null ? _event.EventImageFilename : string.Empty;
}
case ImageType.EventPicturePreview:
case ImageType.EventPictureThumbnail:
case ImageType.EventPictureThumbnailSmall:
case ImageType.EventPictureThumbnailSlideShow:
{
var _event = _dataContext.EventPictures.Where(x => x.EventPictureID == id).FirstOrDefault();
return _event != null ? _event.ImageFilename : string.Empty;
}
default:
return string.Empty;
}
}
public Task<DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken)
{
var video = (Video)item;
// No support for this
if (video.VideoType == VideoType.HdDvd || video.IsPlaceHolder)
{
return Task.FromResult(new DynamicImageResponse { HasImage = false });
}
// Can't extract from iso's if we weren't unable to determine iso type
if (video.VideoType == VideoType.Iso && !video.IsoType.HasValue)
{
return Task.FromResult(new DynamicImageResponse { HasImage = false });
}
// Can't extract if we didn't find a video stream in the file
if (!video.DefaultVideoStreamIndex.HasValue)
{
_logger.Info("Skipping image extraction due to missing DefaultVideoStreamIndex for {0}.", video.Path ?? string.Empty);
return Task.FromResult(new DynamicImageResponse { HasImage = false });
}
return GetVideoImage(video, cancellationToken);
}
public static HeaderRecord Initialized(ImageType type, ImageFlags flags, long size, int blockSize, int blockExtra)
{
HeaderRecord result = new HeaderRecord();
result._fileVersion = new FileVersion(0x00010001);
result.HeaderSize = 400;
result.ImageType = type;
result.Flags = flags;
result.Comment = "Created by .NET ThinkAway";
result.LegacyGeometry = new GeometryRecord();
result.DiskSize = size;
result.BlockSize = blockSize;
result.BlockExtraSize = blockExtra;
result.BlockCount = (int)((size + blockSize - 1) / blockSize);
result.BlocksAllocated = 0;
result.BlocksOffset = ((PreHeaderRecord.Size + result.HeaderSize + 511) / 512) * 512;
result.DataOffset = (uint)(((result.BlocksOffset + (result.BlockCount * 4) + 511) / 512) * 512);
result.UniqueId = Guid.NewGuid();
result.ModificationId = Guid.NewGuid();
result.LChsGeometry = new GeometryRecord();
return result;
}
/// <summary>Create a new Sub with the provided raw data</summary>
/// <param name="raw">Complete encoded data of an individual Sub</param>
/// <exception cref="ArgumentException">Validation error</exception>
public Sub(byte[] raw)
{
_headers = new byte[_subHeaderLength + _imageHeaderLength];
ArrayFunctions.TrimArray(raw, 0, _headers);
// Sub.SubHeader
_type = (ImageType)BitConverter.ToInt16(_headers, 0);
short width = BitConverter.ToInt16(_headers, 2);
short height = BitConverter.ToInt16(_headers, 4);
_groupID = BitConverter.ToInt16(_headers, 0xA);
_subID = BitConverter.ToInt16(_headers, 0xC);
int length = BitConverter.ToInt32(_headers, 0xE);
int offset = _subHeaderLength;
// Sub.ImageHeader
if (BitConverter.ToInt32(_headers, offset + 4) != _imageHeaderLength)
throw new ArgumentException(DatFile._valEx, "raw");
int imageDataOffset = BitConverter.ToInt32(_headers, offset + 8);
if (BitConverter.ToInt32(_headers, offset + 0x24) != _imageHeaderReserved)
throw new ArgumentException(DatFile._valEx, "raw"); // Reserved
_colors = new Color[BitConverter.ToInt32(_headers, offset + 0x28)]; // NumberOfColors
offset += _imageHeaderLength;
// Sub.Colors[]
for (int k = 0; k < _colors.Length; k++, offset += 3)
_colors[k] = Color.FromArgb(raw[offset], raw[offset + 1], raw[offset + 2]);
// Sub.Rows[]
_rows = new byte[length - imageDataOffset];
ArrayFunctions.TrimArray(raw, offset, _rows);
_image = DecodeImage(_rows, width, height, _colors, _type);
}
public async Task<DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken)
{
var liveTvItem = (LiveTvChannel)item;
var imageResponse = new DynamicImageResponse();
var service = _liveTvManager.Services.FirstOrDefault(i => string.Equals(i.Name, liveTvItem.ServiceName, StringComparison.OrdinalIgnoreCase));
if (service != null && !item.HasImage(ImageType.Primary))
{
try
{
var response = await service.GetChannelImageAsync(liveTvItem.ExternalId, cancellationToken).ConfigureAwait(false);
if (response != null)
{
imageResponse.HasImage = true;
imageResponse.Stream = response.Stream;
imageResponse.Format = response.Format;
}
}
catch (NotImplementedException)
{
}
}
return imageResponse;
}
/// <summary>
/// Converts byte buffer to Image with given bitmap type
/// </summary>
/// <param name="data"></param>
/// <param name="w"></param>
/// <param name="h"></param>
/// <param name="type"></param>
/// <returns></returns>
public static Image ConvertBytesToImage(byte[] data, int w, int h, ImageType type = ImageType.RGB) {
var bitmap = new Bitmap(w,h);
var channels = GetChannelCount(type);
var bluefirst = type == ImageType.BGR || type == ImageType.BGRA;
var size = w * h * channels;
if (data.Length < size) {
throw new Exception("invalid buffer size");
}
var i = -1;
for (var r = 0; r < h; r++) {
for (var c = 0; c < w; c++) {
if (channels == 1) {
int gray = data[++i];
bitmap.SetPixel(c, r, Color.FromArgb(gray, gray, gray));
}
else {
var buf = new[] {data[++i], data[++i], data[++i], channels == 4 ? data[++i] : (byte)0};
var basecolor = Color.FromArgb(bluefirst?buf[2]:buf[0],buf[1],bluefirst?buf[0]:buf[2]);
if (channels == 4) {
bitmap.SetPixel(c, r, Color.FromArgb(buf[3], basecolor));
}
else {
bitmap.SetPixel(c,r,basecolor);
}
}
}
}
return bitmap;
}
public CaptureResponse CaptureImage(Type type, out ImageType image)
{
for (int i = 0; i < this.m_Images.Length; i++)
{
ImageTypeInfo info = ImageTypeInfo.Get(this.m_Images[i]);
if (info.Type == type)
{
image = this.m_Images[i];
if (this.m_Done[i])
{
return CaptureResponse.AlreadyDone;
}
else
{
this.m_Done[i] = true;
this.CheckCompletionStatus();
return CaptureResponse.Valid;
}
}
}
image = (ImageType)0;
return CaptureResponse.Invalid;
}
public static string UserAvatarUrl(this UrlHelper url, string avatarUrl, ImageType type)
{
string imageUrl;
if (avatarUrl != null)
{
var parts = avatarUrl.Split(Constants.ImageUrlsSeparator);
switch (type)
{
case ImageType.Thumbnail:
imageUrl = parts[0];
break;
case ImageType.Big:
imageUrl = parts[1];
break;
default:
throw new ArgumentOutOfRangeException("type");
}
}
else
{
imageUrl = AppConfigs.AvatarFolderPath + Constants.AnonymousAvatar;
}
return url.Content(imageUrl);
}
/// <summary>
/// The sub-function to generate different format of BMP image.
/// </summary>
/// <param name="format"></param>
/// <param name="sourcePath"></param>
/// <returns></returns>
public static Bitmap generateBMP(ImageType format, string sourcePath)
{
Bitmap destinationBMP = null;
Bitmap sourceImage = new Bitmap(Image.FromFile(sourcePath));
switch (format)
{
case ImageType.SingleBit:
destinationBMP = new Bitmap(sourceImage.Width, sourceImage.Height, System.Drawing.Imaging.PixelFormat.Format1bppIndexed);
break;
case ImageType.ThreeBit:
destinationBMP = new Bitmap(sourceImage.Width, sourceImage.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
break;
default:
break;
}
using (var graph = Graphics.FromImage(destinationBMP))
{
graph.DrawImage(
sourceImage,
new Rectangle(0, 0, sourceImage.Width, sourceImage.Height)
);
}
return destinationBMP;
}
public static Stream ChangeFormat(FileInfo sourceFileInfo, ImageType newType)
{
using (var fs = sourceFileInfo.OpenRead())
{
return ChangeFormat(fs, newType);
}
}
public PaintedImage( ImageType image ) : base( 0xFF3 )
{
Weight = 1.0;
Hue = 0x8FD;
m_Image = image;
}
public void UploadImage(string name, ImageType imageType, byte[] file)
{
var request = Reddit.CreatePost(UploadImageUrl);
var formData = new MultipartFormBuilder(request);
formData.AddDynamic(new
{
name,
uh = Reddit.User.Modhash,
r = Subreddit.Name,
formid = "image-upload",
img_type = imageType == ImageType.PNG ? "png" : "jpg",
upload = ""
});
formData.AddFile("file", "foo.png", file, imageType == ImageType.PNG ? "image/png" : "image/jpeg");
formData.Finish();
try
{
var response = request.GetResponse();
var data = Reddit.GetResponseString(response.GetResponseStream());
}
catch (WebException ex)
{
var data = Reddit.GetResponseString(ex.Response.GetResponseStream());
throw;
}
}
public void OpenStream(ImageType imageType, ImageResolution resolution)
{
HRESULT res = NuiImageStreamOpen(imageType, resolution, 0, 2, IntPtr.Zero, ref streamHandle);
if (res != HRESULT.S_OK)
throw new Exception("Failed to open stream, return value:" + res.ToString());
}
public static Image GetIcon(ImageType theImage)
{
Image micon = null;
switch (theImage)
{
case ImageType.Blank:
micon = GUIResource.Properties.Resources.Blank;
break;
case ImageType.AccessDB:
micon = GUIResource.Properties.Resources.AccessDB;
break;
case ImageType.Option:
micon = GUIResource.Properties.Resources.Option;
break;
case ImageType.Refresh:
micon = GUIResource.Properties.Resources.Refresh;
break;
case ImageType.NextPage:
micon = GUIResource.Properties.Resources.NextPage;
break;
case ImageType.PrePage:
//水平翻转
micon = GUIResource.Properties.Resources.NextPage;
micon.RotateFlip(RotateFlipType.Rotate180FlipY);
break;
case ImageType.LastPage:
micon = GUIResource.Properties.Resources.LastPage;
break;
case ImageType.FirstPage:
//水平翻转
micon = GUIResource.Properties.Resources.LastPage;
micon.RotateFlip(RotateFlipType.Rotate180FlipY);
break;
case ImageType.Query:
micon = GUIResource.Properties.Resources.Query;
break;
case ImageType.WebServer:
micon = GUIResource.Properties.Resources.WebServer;
break;
case ImageType.Database:
micon = GUIResource.Properties.Resources.Database;
break;
case ImageType.Collection:
micon = GUIResource.Properties.Resources.Collection;
break;
case ImageType.Keys:
micon = GUIResource.Properties.Resources.Keys;
break;
case ImageType.Document:
micon = GUIResource.Properties.Resources.Document;
break;
case ImageType.Smile:
micon = GUIResource.Properties.Resources.Smile;
break;
default:
break;
}
return micon;
}
public static void ImageBuilder(string imageFile, ImageType type, bool IsInTempFolder,AspxCommonInfo aspxCommonObj)
{
try
{
bool disposeSource = true;
bool addFileExtensions = true;
string tempFolder = string.Empty;
string filename = imageFile;
bool isExistImage = false;
var resizeSetings = new ResizeSettings();
resizeSetings.Format = "jpg";
resizeSetings.Mode = FitMode.Max;
switch (type)
{
case ImageType.Large:
{
isExistImage = CheckIfImageExists(ImageType.Large, filename);
if (!(isExistImage))
{
ImageSettings imgStng=new ImageSettings(aspxCommonObj);
resizeSetings.MaxWidth = imgStng.itemLargeThumbNailWidth;
resizeSetings.MaxHeight = imgStng.itemLargeThumbNailHeight;
copyOriginalImageToRespectives(ImageType.Large, filename, resizeSetings,disposeSource, addFileExtensions);
}
break;
}
case ImageType.Medium:
{
isExistImage = CheckIfImageExists(ImageType.Medium, filename);
if (!(isExistImage))
{
ImageSettings imgStng = new ImageSettings(aspxCommonObj);
resizeSetings.MaxWidth = imgStng.itemMediumThumbNailWidth;
resizeSetings.MaxHeight = imgStng.itemMediumThumbNailHeight;
copyOriginalImageToRespectives(ImageType.Medium, filename, resizeSetings, disposeSource, addFileExtensions);
}
break;
}
case ImageType.Small:
{
isExistImage = CheckIfImageExists(ImageType.Medium, filename);
if (!(isExistImage))
{
ImageSettings imgStng = new ImageSettings(aspxCommonObj);
resizeSetings.MaxWidth = imgStng.itemSmallThumbNailWidth;
resizeSetings.MaxHeight = imgStng.itemSmallThumbNailHeight;
copyOriginalImageToRespectives(ImageType.Medium, filename, resizeSetings, disposeSource, addFileExtensions);
}
break;
}
}
}
catch
{
}
}
public async Task<DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken)
{
var liveTvItem = (LiveTvProgram)item;
var imageResponse = new DynamicImageResponse();
if (!string.IsNullOrEmpty(liveTvItem.ProviderImagePath))
{
imageResponse.Path = liveTvItem.ProviderImagePath;
imageResponse.HasImage = true;
}
else if (!string.IsNullOrEmpty(liveTvItem.ProviderImageUrl))
{
var options = new HttpRequestOptions
{
CancellationToken = cancellationToken,
Url = liveTvItem.ProviderImageUrl
};
var response = await _httpClient.GetResponse(options).ConfigureAwait(false);
if (response.ContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
{
imageResponse.HasImage = true;
imageResponse.Stream = response.Content;
imageResponse.SetFormatFromMimeType(response.ContentType);
}
else
{
_logger.Error("Provider did not return an image content type.");
}
}
else if (liveTvItem.HasProviderImage ?? true)
{
var service = _liveTvManager.Services.FirstOrDefault(i => string.Equals(i.Name, liveTvItem.ServiceName, StringComparison.OrdinalIgnoreCase));
if (service != null)
{
try
{
var channel = _liveTvManager.GetInternalChannel(liveTvItem.ChannelId);
var response = await service.GetProgramImageAsync(liveTvItem.ExternalId, channel.ExternalId, cancellationToken).ConfigureAwait(false);
if (response != null)
{
imageResponse.HasImage = true;
imageResponse.Stream = response.Stream;
imageResponse.Format = response.Format;
}
}
catch (NotImplementedException)
{
}
}
}
return imageResponse;
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
this.m_Image = (ImageType)reader.ReadEncodedInt();
}
private void PopulateBackdrops(List <LocalImageInfo> images, List <FileSystemMetadata> files, string imagePrefix, string firstFileName, string subsequentFileNamePrefix, bool isInMixedFolder, ImageType type)
{
AddImage(files, images, imagePrefix + firstFileName, type);
var unfound = 0;
for (var i = 1; i <= 20; i++)
{
// Screenshot Image
var found = AddImage(files, images, imagePrefix + subsequentFileNamePrefix + i, type);
if (!found)
{
unfound++;
if (unfound >= 3)
{
break;
}
}
}
// Support without the prefix
if (!isInMixedFolder)
{
AddImage(files, images, firstFileName, type);
unfound = 0;
for (var i = 1; i <= 20; i++)
{
// Screenshot Image
var found = AddImage(files, images, subsequentFileNamePrefix + i, type);
if (!found)
{
unfound++;
if (unfound >= 3)
{
break;
}
}
}
}
}
protected static T GetImage <T>(LocalPluginContext context, ImageType imageType) where T : Entity
{
return(GetImage <T>(context, imageType, imageType.ToString()));
}
public ImageDescriptor(string path, ImageType usage, BitmapImage img)
{
Path = path;
Usage = usage;
Image = img;
}
public List <Image> ToEntity(ImageType imageType)
{
return(this.Images.ConvertAll <Image>((ImageVm i) => i.ToEntity(imageType)));
}
public async Task SaveImage(IHasImages item, string url, SemaphoreSlim resourcePool, ImageType type, int?imageIndex, CancellationToken cancellationToken)
{
var response = await _httpClient.GetResponse(new HttpRequestOptions
{
CancellationToken = cancellationToken,
ResourcePool = resourcePool,
Url = url
}).ConfigureAwait(false);
await SaveImage(item, response.Content, response.ContentType, type, imageIndex, cancellationToken)
.ConfigureAwait(false);
}
public int GetMinWidth(ImageType type)
{
return(GetImageOptions(type).MinWidth);
}
/// <summary>
/// 获取图片
/// </summary>
/// <param name="url">地址</param>
/// <param name="type">类型</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <HttpResponseInfo> GetImageResponse(string url, ImageType type, CancellationToken cancellationToken)
{
// /emby/Plugins/JavScraper/Image?url=&type=xx
if (url.IndexOf("Plugins/JavScraper/Image", StringComparison.OrdinalIgnoreCase) >= 0) //本地的链接
{
var uri = new Uri(url);
var q = HttpUtility.ParseQueryString(uri.Query);
var url2 = q["url"];
if (url2.IsWebUrl())
{
url = url2;
var tt = q.Get("type");
if (!string.IsNullOrWhiteSpace(tt) && Enum.TryParse <ImageType>(tt.Trim(), out var t2))
{
type = t2;
}
}
}
logger?.Info($"{nameof(GetImageResponse)}-{url}");
var key = WebUtility.UrlEncode(url);
var cache_file = Path.Combine(appPaths.GetImageCachePath().ToString(), key);
byte[] bytes = null;
//尝试从缓存中读取
try
{
var fi = fileSystem.GetFileInfo(cache_file);
//图片文件存在，且是24小时之内的
if (fi.Exists && fileSystem.GetFileInfo(cache_file).LastWriteTimeUtc > DateTime.Now.AddDays(-1).ToUniversalTime())
{
bytes = await fileSystem.ReadAllBytesAsync(cache_file);
logger?.Info($"Hit image cache {url} {cache_file}");
if (type == ImageType.Primary)
{
var ci = await CutImage(bytes, url);
if (ci != null)
{
return(ci);
}
}
fileExtensionContentTypeProvider.TryGetContentType(url, out var contentType);
return(new HttpResponseInfo()
{
Content = new MemoryStream(bytes),
ContentLength = bytes.Length,
ContentType = contentType ?? "image/jpeg",
StatusCode = HttpStatusCode.OK,
});
}
}
catch (Exception ex)
{
logger?.Warn($"Read image cache error. {url} {cache_file} {ex.Message}");
}
try
{
var resp = await client.GetAsync(url, cancellationToken);
if (resp.IsSuccessStatusCode == false)
{
return(await Parse(resp));
}
try
{
fileSystem.WriteAllBytes(cache_file, await resp.Content.ReadAsByteArrayAsync());
logger?.Info($"Save image cache {url} {cache_file} ");
}
catch (Exception ex)
{
logger?.Warn($"Save image cache error. {url} {cache_file} {ex.Message}");
}
if (type == ImageType.Primary)
{
var ci = await CutImage(await resp.Content.ReadAsByteArrayAsync(), url);
if (ci != null)
{
return(ci);
}
}
return(await Parse(resp));
}
catch (Exception ex)
{
logger?.Error(ex.ToString());
}
return(new HttpResponseInfo());
}
public Task <DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken)
{
var channel = GetChannel(item);
return(channel.GetChannelImage(type, cancellationToken));
}
public bool IsEnabled(ImageType type)
{
return(GetLimit(type) > 0);
}
public void AddItem(string strCaption, bool ShowImage, ImageType objImageType, string strTag)
{
try
{
objExpanderItem = new CtlExpanderItem();
objExpanderItem.HorizontalAlignment = HorizontalAlignment.Stretch;
objExpanderItem.VerticalAlignment = VerticalAlignment.Stretch;
if (objImageType == ImageType.MaleBuddy || objImageType == ImageType.FemaleBuddy)
{
objExpanderItem.AllowDrop = true;
objExpanderItem.PreviewMouseDown += new System.Windows.Input.MouseButtonEventHandler(objExpanderItem_PreviewMouseDown);
}
objExpanderItem.Tag = strTag;
if (ShowImage)
{
if (objImageType == ImageType.Page)
{
objExpanderItem.Image = @"\Skins\Images\Page.png";
}
else if (objImageType == ImageType.Module)
{
objExpanderItem.Image = @"\Skins\Images\Modules.png";
}
else if (objImageType == ImageType.MaleBuddy)
{
objExpanderItem.Image = @"\Skins\Images\Buddy.Png";
}
else if (objImageType == ImageType.FemaleBuddy)
{
objExpanderItem.Image = @"\Skins\Images\FBuddy.Png";
}
}
else
{
objExpanderItem.Image = "";
}
objExpanderItem.Caption = strCaption;
if (strTag == "offline")
{
objExpanderItem.Image = @"\Skins\Images\FBuddy.Png";
objExpanderItem.ToolTip = strCaption + " is offline";
objExpanderItem.PreviewMouseDown -= new System.Windows.Input.MouseButtonEventHandler(objExpanderItem_PreviewMouseDown);
}
else if (strTag == "online")
{
objExpanderItem.Image = @"\Skins\Images\Buddy.Png";
objExpanderItem.ToolTip = strCaption + " is online";
}
TreeViewItem objTrviExpanderItem = new TreeViewItem();
objTrviExpanderItem.HorizontalAlignment = HorizontalAlignment.Stretch;
objTrviExpanderItem.VerticalAlignment = VerticalAlignment.Stretch;
objTrviExpanderItem.PreviewMouseLeftButtonDown += new MouseButtonEventHandler(objTrviExpanderItem_PreviewMouseLeftButtonDown);
objTrviExpanderItem.Header = objExpanderItem;
trvExpanderContent.Items.Add(objTrviExpanderItem);
}
catch (Exception ex)
{
VMuktiHelper.ExceptionHandler(ex, "AddItem()", "Controls\\BuddyExplorer\\CtlExpanderModuleContent.xaml.cs");
}
}
public PluginStepConfig <T> AddImage(string name, string entityAlias, ImageType imageType, params Expression <Func <T, object> >[] attributes)
{
this._Images.Add(new PluginStepImage(name, entityAlias, imageType, attributes));
return(this);
}
/// <summary>
/// Updates the index of the item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="type">The type.</param>
/// <param name="currentIndex">Index of the current.</param>
/// <param name="newIndex">The new index.</param>
/// <returns>Task.</returns>
private Task UpdateItemIndex(IHasMetadata item, ImageType type, int currentIndex, int newIndex)
{
return(item.SwapImages(type, currentIndex, newIndex));
}
/// <summary>
/// posts the given image to Social Plus
/// </summary>
/// <param name="imageUri">URL to an image</param>
/// <param name="imageType">user profile photo or topic content image</param>
/// <param name="client">social plus client library</param>
/// <param name="bearerToken">bearer token from logged on user</param>
/// <returns>task that returns the response from server</returns>
public static async Task <HttpOperationResponse <PostImageResponse> > AddImage(Uri imageUri, ImageType imageType, SocialPlusClient client, string bearerToken)
{
// get the image from the internets
if (imageUri.Scheme == Uri.UriSchemeHttp || imageUri.Scheme == Uri.UriSchemeHttps)
{
using (var httpClient = new HttpClient())
{
using (var responseMessage = await httpClient.GetAsync(imageUri))
{
if (!responseMessage.IsSuccessStatusCode)
{
return(null);
}
using (Stream responseStream = await responseMessage.Content.ReadAsStreamAsync())
{
// submit the POST request
HttpOperationResponse <PostImageResponse> postImageResponse = await client.Images.PostImageWithHttpMessagesAsync(imageType : imageType, authorization : bearerToken, image : responseStream);
return(postImageResponse);
}
}
}
}
// get the image from the local disk
else if (imageUri.Scheme == Uri.UriSchemeFile)
{
Image image = Image.FromFile(imageUri.LocalPath);
using (MemoryStream imageMemoryStream = new MemoryStream())
{
image.Save(imageMemoryStream, System.Drawing.Imaging.ImageFormat.Jpeg);
imageMemoryStream.Position = 0;
// submit the POST request
HttpOperationResponse <PostImageResponse> postImageResponse = await client.Images.PostImageWithHttpMessagesAsync(imageType : imageType, authorization : bearerToken, image : imageMemoryStream);
return(postImageResponse);
}
}
// not supported
else
{
throw new NotImplementedException("only http, https, and file URIs are supported");
}
}
public int GetLimit(ImageType type)
{
return(GetImageOptions(type).Limit);
}
/// <summary>
/// Tests the add of an image and resizing of an image
/// </summary>
/// <param name="imageUri">URL to the image to test</param>
/// <param name="imageType">type of image</param>
/// <returns>task of testing the image</returns>
private static async Task TestImage(Uri imageUri, ImageType imageType)
{
// Set up initial login
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
string firstName = "Image";
string lastName = "Consumer";
string bio = "I like to download images";
PostUserResponse postUserResponse = await TestUtilities.DoLogin(client, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
// get size of original image
Size originalSize = await GetSizeOfImage(imageUri);
// add image to server
HttpOperationResponse <PostImageResponse> postImageResponse = await AddImage(imageUri, imageType, client, auth);
// if add image was a success, grab the handle, the image, and delete the image and user to cleanup
string imageHandle = string.Empty;
HttpOperationResponse <Stream> getImageResponse = null;
Size getImageResponseSize = default(Size);
bool cdnImageExists = false;
bool cdnSmallerImagesExist = false;
bool cdnSmallerImageSizesCorrect = false;
if (postImageResponse != null && postImageResponse.Response.IsSuccessStatusCode)
{
// get the image handle
imageHandle = postImageResponse.Body.BlobHandle;
// get the image from the social plus server and pull out its size
getImageResponse = await client.Images.GetImageWithHttpMessagesAsync(blobHandle : imageHandle, authorization : auth);
if (getImageResponse.Response.IsSuccessStatusCode)
{
getImageResponseSize = GetSizeOfImage(getImageResponse.Body);
}
// get the image from the CDN
Uri cdnImageUri = FormImageUriOnCDN(imageHandle);
cdnImageExists = await DoesImageExist(cdnImageUri);
// wait for image resizer worker role to finish
System.Threading.Thread.Sleep(TestConstants.ImageResizeDelay);
// do smaller images exist on CDN?
cdnSmallerImagesExist = true;
cdnSmallerImageSizesCorrect = true;
foreach (ImageSize size in ImageSizesConfiguration.Sizes[imageType])
{
Uri smallImageUri = FormImageUriOnCDN(imageHandle + size.Id);
bool exists = await DoesImageExist(smallImageUri);
if (!exists)
{
cdnSmallerImagesExist = false;
}
// is it the right size?
Size expectedSize = ExpectedImageSize(size.Width, originalSize);
Size newSize = await GetSizeOfImage(smallImageUri);
if (expectedSize != newSize)
{
cdnSmallerImageSizesCorrect = false;
}
}
// there is no delete image API call, so cannot cleanup the image from the server
}
// delete the user
HttpOperationResponse <object> deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// test responses
Assert.IsNotNull(postImageResponse);
Assert.IsTrue(postImageResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(getImageResponse.Response.IsSuccessStatusCode);
Assert.AreEqual(originalSize, getImageResponseSize);
Assert.IsTrue(cdnImageExists);
Assert.IsTrue(cdnSmallerImagesExist);
Assert.IsTrue(cdnSmallerImageSizesCorrect);
Assert.IsTrue(deleteUserOperationResponse.Response.IsSuccessStatusCode);
}
public bool IsReplacingImage(ImageType type)
{
return(ImageRefreshMode == MetadataRefreshMode.FullRefresh &&
(ReplaceAllImages || ReplaceImages.Contains(type)));
}
public Task SaveImage(IHasImages item, Stream source, string mimeType, ImageType type, int?imageIndex, string internalCacheKey, CancellationToken cancellationToken)
{
return(new ImageSaver(ConfigurationManager, _libraryMonitor, _fileSystem, _logger).SaveImage(item, source, mimeType, type, imageIndex, internalCacheKey, cancellationToken));
}
protected string UploadGameImage(Guid userId, ImageType type, string filename, byte[] fileBytes)
{
string result = UploadImage(userId, type.ToString().ToLower(), filename, fileBytes);
return(result);
}
/// <summary>
/// 输入Uri开始播放Gif图片
/// </summary>
/// <param name="Uri"></param>
private async void Start(string uri)
{
var reg = @"http(s)?://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?";
Regex regex = new Regex(reg, RegexOptions.IgnoreCase);
IRandomAccessStreamWithContentType streamRandom = null;
if (regex.IsMatch(this.Source))
{
RandomAccessStreamReference rass = RandomAccessStreamReference.CreateFromUri(new Uri(uri, UriKind.RelativeOrAbsolute));
streamRandom = await rass.OpenReadAsync();
}
else
{
try
{
//本地的Uri
//rass = RandomAccessStreamReference.CreateFromUri(new Uri(this.BaseUri, uri));
var folder = Windows.Storage.ApplicationData.Current.LocalFolder;
var file = await folder.GetFileAsync(uri);
streamRandom = await file.OpenReadAsync();
//var packageLocation = Windows.ApplicationModel.Package.Current.InstalledLocation;
//var ss = await packageLocation.GetBasicPropertiesAsync();
//var imagesFolder = await packageLocation.GetFolderAsync("Images");
//StorageFile file = await imagesFolder.GetFileAsync("amy.jpg");
//rass = RandomAccessStreamReference.CreateFromFile(file);
}
catch (Exception)
{
Debug.WriteLine("打开文件失败");
}
}
try
{
Stream tempStream = streamRandom.GetInputStreamAt(0).AsStreamForRead();
//
MemoryStream ms = new MemoryStream();
await tempStream.CopyToAsync(ms);
byte[] bytes = ms.ToArray();
tempStream = new MemoryStream(bytes);
//
var randomAccessStream = new InMemoryRandomAccessStream();
var outputStream = randomAccessStream.GetOutputStreamAt(0);
await RandomAccessStream.CopyAsync(tempStream.AsInputStream(), outputStream);
/*
* try
* {
* await CreateGifBitFrame(randomAccessStream);
* PlayGif();
* }
* catch
* {
* //var stop = this.Stop;
* //this.Stop = true;
* //bitFrame.Clear();
* //randomAccessStream.Seek(0);
* //randomAccessStream.FlushAsync().GetResults();
* //bmp.SetSource(randomAccessStream);
* //imageGif.Source = bmp;
* //this.Stop = stop;
*
* JpegAndPng(randomAccessStream);
* }
*/
//判断并设置图片类型
ImageType type = ImageTypeCheck.CheckImageType(bytes);
Debug.WriteLine("type == " + type.ToString());
switch (type)
{
case ImageType.GIF:
{
await CreateGifBitFrame(randomAccessStream);
PlayGif();
break;
}
case ImageType.JPG:
{
JpegAndPng(randomAccessStream);
break;
}
case ImageType.PNG:
{
JpegAndPng(randomAccessStream);
break;
}
default:
{
await CreateGifBitFrame(randomAccessStream);
PlayGif();
break;
}
}
}
catch
{
BitmapImage bi = new BitmapImage();
if (regex.IsMatch(this.Source))
{
bi.UriSource = new Uri(uri, UriKind.RelativeOrAbsolute);
}
else
{
bi.UriSource = new Uri(this.baseUri, uri);
}
this.imageGifGrid.Children.Clear();
//优化
this.imageList.Clear();
this.bitmapImageList.Clear();
Image imageGif = new Image();
imageGif.Source = bi;
this.imageGifGrid.Children.Add(imageGif);
}
}
public PluginStepConfig <T> AddImage(ImageType imageType)
{
return(this.AddImage(imageType, null));
}
protected string DeleteGameImage(Guid userId, ImageType type, string filename)
{
string result = DeleteImage(userId, filename);
return(result);
}
public ImageResult(ImageSource imageSource, ImageType imageType)
{
ImageSource = imageSource;
ImageType = imageType;
}
protected string UploadImage(Guid userId, ImageType container, string filename, byte[] fileBytes)
{
string containerName = container.ToString().ToLower();
return(UploadImage(userId, containerName, filename, fileBytes));
}
private bool AddImage(IEnumerable <FileSystemMetadata> files, List <LocalImageInfo> images, string name, ImageType type)
{
var image = GetImage(files, name);
if (image != null)
{
images.Add(new LocalImageInfo
{
FileInfo = image,
Type = type
});
return(true);
}
return(false);
}
/// <inheritdoc/>
public Task SaveImage(BaseItem item, Stream source, string mimeType, ImageType type, int?imageIndex, CancellationToken cancellationToken)
{
return(new ImageSaver(_configurationManager, _libraryMonitor, _fileSystem, _logger).SaveImage(item, source, mimeType, type, imageIndex, cancellationToken));
}
private bool AddImage(List <FileSystemMetadata> files, List <LocalImageInfo> images, string name, string imagePrefix, bool isInMixedFolder, ImageType type)
{
var added = AddImage(files, images, imagePrefix + name, type);
if (!isInMixedFolder)
{
if (AddImage(files, images, name, type))
{
added = true;
}
}
return(added);
}
public Mapper(ImageLoadingTransformer parent, Schema inputSchema)
: base(parent.Host.Register(nameof(Mapper)), parent, inputSchema)
{
_imageType = new ImageType();
_parent = parent;
}
//BRIAN MODIFIED FOR RETURN ID
public string SendMessageBroadcastImage(string[] recipients, byte[] ImageData, ImageType imgtype)
{
string to;
List <string> foo = new List <string>();
foreach (string s in recipients)
{
foo.Add(GetJID(s));
}
to = string.Join(",", foo.ToArray());
FMessage msg = this.getFmessageImage(to, ImageData, imgtype);
if (msg != null)
{
this.SendMessage(msg);
return(msg.identifier_key.ToString());
}
return("");
}
public PluginStepConfig <T> AddImage(ImageType imageType, params Expression <Func <T, object> >[] attributes)
{
return(this.AddImage(imageType.ToString(), imageType.ToString(), imageType, attributes));
}
public PluginStepConfig <T> AddImage(string name, string entityAlias, ImageType imageType)
{
return(this.AddImage(name, entityAlias, imageType, null));
}
