protected virtual ProcessImageQuery BuildImageQuery() { var query = new ProcessImageQuery(); if (Size > 0) { query.MaxSize = Size.Value; } if (Width > 0) { query.MaxWidth = Width.Value; } if (Height > 0) { query.MaxHeight = Height.Value; } if (ResizeMode.HasValue) { query.ScaleMode = ResizeMode.Value.ToString().ToLower(); } if (AnchorPosition.HasValue) { query.AnchorPosition = AnchorPosition.Value.ToString().Kebaberize(); } return(query); }
private async Task <ProcessImageQuery> CreateImageQuery(HttpContext context, string mimeType, string extension) { if (extension == "svg") { return(new ProcessImageQuery { Format = "svg" }); } // TODO: (mc) implement "raw" image handling later //if (qs.GetValues(null).Contains("raw", StringComparer.OrdinalIgnoreCase) || qs["raw"] != null) //{ // return null; //} var query = new ProcessImageQuery(null, context.Request.Query); //if (query.Quality == null) //{ // query.Quality = _mediaSettings.DefaultImageQuality; //} await _eventPublisher.PublishAsync(new ImageQueryCreatedEvent(query, context, mimeType, extension)); return(query); }
private async Task <byte[]> ProcessAndPutToCacheAsync(CachedImageResult cachedImage, byte[] buffer, ProcessImageQuery query) { if (!query.NeedsProcessing()) { await _imageCache.PutAsync(cachedImage, buffer); return(buffer); } else { var processQuery = new ProcessImageQuery(query) { Source = buffer, Format = query.Format ?? cachedImage.Extension, FileName = cachedImage.FileName, DisposeSource = true }; using (var result = _imageProcessor.ProcessImage(processQuery)) { var outBuffer = result.OutputStream.GetBuffer(); await _imageCache.PutAsync(cachedImage, outBuffer); if (cachedImage.Extension != result.FileExtension) { cachedImage.Path = Path.ChangeExtension(cachedImage.Path, result.FileExtension); cachedImage.Extension = result.FileExtension; } Logger.DebugFormat($"Processed image '{cachedImage.FileName}' in {result.ProcessTimeMs} ms.", null); return(outBuffer); } } }
protected virtual ProcessImageQuery CreateImageQuery(string mimeType, string extension) { var qs = Request.QueryString; // TODO: (mc) implement "raw" image handling later //if (qs.GetValues(null).Contains("raw", StringComparer.OrdinalIgnoreCase) || qs["raw"] != null) //{ // return null; //} var query = new ProcessImageQuery(null, qs); if (query.MaxWidth == null && query.MaxHeight == null && query.Contains("size")) { int size = query["size"].Convert <int>(); query.MaxWidth = size; query.MaxHeight = size; query.Remove("size"); } if (query.Quality == null) { query.Quality = _mediaSettings.DefaultImageQuality; } _eventPublisher.Publish(new ImageQueryCreatedEvent(query, this.HttpContext, mimeType, extension)); return(query); }
protected virtual ProcessImageQuery CreateImageQuery(string mimeType, string extension) { if (extension == "svg") { return(new ProcessImageQuery { Format = "svg" }); } var qs = Request.QueryString; // TODO: (mc) implement "raw" image handling later //if (qs.GetValues(null).Contains("raw", StringComparer.OrdinalIgnoreCase) || qs["raw"] != null) //{ // return null; //} var query = new ProcessImageQuery(null, qs); if (query.Quality == null) { query.Quality = _mediaSettings.DefaultImageQuality; } _eventPublisher.Publish(new ImageQueryCreatedEvent(query, this.HttpContext, mimeType, extension)); return(query); }
protected override async Task ProcessImageAsync(MediaHandlerContext context, CachedImage cachedImage, Stream inputStream) { var processQuery = new ProcessImageQuery(context.ImageQuery) { Source = inputStream, Format = context.ImageQuery.Format ?? cachedImage.Extension, FileName = cachedImage.FileName, DisposeSource = false }; using (var result = await _imageProcessor.ProcessImageAsync(processQuery, false)) { Logger.Debug($"Processed image '{cachedImage.FileName}' in {result.ProcessTimeMs} ms."); var ext = result.Image.Format.DefaultExtension; if (!cachedImage.Extension.EqualsNoCase(ext)) { // jpg <> jpeg cachedImage.Path = Path.ChangeExtension(cachedImage.Path, ext); cachedImage.Extension = ext; } context.ResultImage = result.Image; } }
public static string GenerateUrl( this IMediaUrlGenerator service, MediaFileInfo file, ProcessImageQuery imageQuery, string host = null, bool doFallback = true) { return(service.GenerateUrl(file, imageQuery != null ? imageQuery.ToQueryString() : QueryString.Empty, host, doFallback)); }
public static string GetFallbackUrl(this IMediaService service, int thumbnailSize = 0) { ProcessImageQuery query = thumbnailSize > 0 ? new ProcessImageQuery { MaxSize = thumbnailSize } : null; return(service.GetUrl((MediaFileInfo)null, query, null, true)); }
public static string GetUrl(this IMediaService service, MediaFileInfo file, int thumbnailSize, string host = null, bool doFallback = true) { ProcessImageQuery query = thumbnailSize > 0 ? new ProcessImageQuery { MaxSize = thumbnailSize } : null; return(service.GetUrl(file, query, host, doFallback)); }
public static async Task <string> GetUrlAsync(this IMediaService service, int?fileId, int thumbnailSize, string host = null, bool doFallback = true) { ProcessImageQuery query = thumbnailSize > 0 ? new ProcessImageQuery { MaxSize = thumbnailSize } : null; return(service.GetUrl(await service.GetFileByIdAsync(fileId ?? 0, MediaLoadFlags.AsNoTracking), query, host, doFallback)); }
private void ImageResize(string path, string dest, int maxWidth, int maxHeight, bool notify = true) { if (dest.IsEmpty()) { return; } if (maxWidth == 0 && maxHeight == 0) { maxWidth = _mediaSettings.Value.MaximumImageSize; maxHeight = _mediaSettings.Value.MaximumImageSize; } var buffer = System.IO.File.ReadAllBytes(path); var query = new ProcessImageQuery(buffer) { Quality = _mediaSettings.Value.DefaultImageQuality, Format = Path.GetExtension(path).Trim('.').ToLower(), IsValidationMode = true, Notify = notify }; var originalSize = ImageHeader.GetDimensions(buffer, MimeTypes.MapNameToMimeType(path)); if (originalSize.IsEmpty || (originalSize.Height <= maxHeight && originalSize.Width <= maxWidth)) { // Give subscribers the chance to (pre)-process var evt = new ImageUploadValidatedEvent(query, originalSize); _eventPublisher.Publish(evt); if (evt.ResultBuffer != null) { System.IO.File.WriteAllBytes(dest, evt.ResultBuffer); } return; } if (maxWidth > 0) { query.MaxWidth = maxWidth; } if (maxHeight > 0) { query.MaxHeight = maxHeight; } using (var result = _imageProcessor.Value.ProcessImage(query)) { buffer = result.OutputStream.GetBuffer(); System.IO.File.WriteAllBytes(dest, buffer); } }
protected async Task <AsyncOut <IImage> > ProcessImage(MediaFile file, Stream inStream) { var originalSize = Size.Empty; var format = _imageProcessor.Factory.FindFormatByExtension(file.Extension) ?? new UnsupportedImageFormat(file.MimeType, file.Extension); try { originalSize = ImageHeader.GetPixelSize(inStream, file.MimeType); } catch { } IImage outImage; if (format is UnsupportedImageFormat) { outImage = new ImageWrapper(inStream, originalSize, format); return(new AsyncOut <IImage>(true, outImage)); } var maxSize = _mediaSettings.MaximumImageSize; var query = new ProcessImageQuery(inStream) { Format = file.Extension, DisposeSource = true, ExecutePostProcessor = ImagePostProcessingEnabled, IsValidationMode = true }; if (originalSize.IsEmpty || (originalSize.Height <= maxSize && originalSize.Width <= maxSize)) { // Give subscribers the chance to (pre)-process var evt = new ImageUploadedEvent(query, originalSize); await _eventPublisher.PublishAsync(evt); outImage = evt.ResultImage ?? new ImageWrapper(inStream, originalSize, format); return(new AsyncOut <IImage>(true, outImage)); } query.MaxSize = maxSize; using (var result = await _imageProcessor.ProcessImageAsync(query, false)) { outImage = result.Image; return(new AsyncOut <IImage>(true, outImage)); } }
protected virtual ProcessImageQuery CreateImageQuery(string mimeType, string extension) { var query = new ProcessImageQuery(null, Request.QueryString); if (query.MaxWidth == null && query.MaxHeight == null && query.Contains("size")) { int size = query["size"].Convert <int>(); query.MaxWidth = size; query.MaxHeight = size; query.Remove("size"); } if (query.Quality == null) { query.Quality = _mediaSettings.DefaultImageQuality; } _eventPublisher.Publish(new ImageQueryCreatedEvent(query, this.HttpContext, mimeType, extension)); return(query); }
protected override void ProcessCore(TagHelperContext context, TagHelperOutput output) { var query = new ProcessImageQuery(); if (ImageSize > 0) { query.MaxSize = ImageSize.Value; } if (ImageWidth > 0) { query.MaxWidth = ImageWidth.Value; } if (ImageHeight > 0) { query.MaxHeight = ImageHeight.Value; } if (ImageResizeMode.HasValue) { query.ScaleMode = ImageResizeMode.Value.ToString().ToLower(); } var src = _urlGenerator.GenerateUrl(File, query.ToQueryString()); output.Attributes.SetAttribute("src", src); if (File.Alt.HasValue()) { output.Attributes.SetAttributeNoReplace("alt", File.Alt); } if (File.TitleAttribute.HasValue()) { output.Attributes.SetAttributeNoReplace("title", File.TitleAttribute); } }
public static string Media(this UrlHelper urlHelper, MediaFileInfo file, ProcessImageQuery query, string host = null, bool doFallback = true) { var mediaService = EngineContext.Current.Resolve <IMediaService>(); return(mediaService.GetUrl(file, query, host, doFallback)); }
private async Task <ActionResult> HandleImage( ProcessImageQuery query, CachedImageResult cachedImage, string nameWithoutExtension, string mime, string extension, Func <string, Task <byte[]> > getSourceBuffer) { string prevMime = null; if (extension != cachedImage.Extension) { // The query requests another format. // Adjust extension and mime type fo proper ETag creation. extension = cachedImage.Extension; prevMime = mime; mime = MimeTypes.MapNameToMimeType(cachedImage.FileName); } if (cachedImage.Exists) { if (ETagMatches(nameWithoutExtension, mime, cachedImage.LastModifiedUtc.Value)) { return(Content(null)); } } var isFaulted = false; try { if (!cachedImage.Exists) { // get the async (semaphore) locker specific to this key var keyLock = AsyncLock.Acquire("lock" + cachedImage.Path); // Lock concurrent requests to same resource using (await keyLock.LockAsync()) { _imageCache.RefreshInfo(cachedImage); // File could have been processed by another request in the meantime, check again. if (!cachedImage.Exists) { // Call inner function byte[] source = await getSourceBuffer(prevMime); if (source == null) { return(NotFound(mime)); } source = await ProcessAndPutToCacheAsync(cachedImage, source, query); return(File(source, mime)); } } } if (Request.HttpMethod == "HEAD") { return(new HttpStatusCodeResult(200)); } if (cachedImage.IsRemote && !_streamRemoteMedia) { // Redirect to existing remote file Response.ContentType = mime; return(Redirect(_imageCache.GetPublicUrl(cachedImage.Path))); } else { // Open existing stream return(File(cachedImage.File.OpenRead(), mime)); } } catch (Exception ex) { isFaulted = true; if (!(ex is ProcessImageException)) { // ProcessImageException is logged already in ImageProcessor Logger.ErrorFormat(ex, "Error processing media file '{0}'.", cachedImage.Path); } return(new HttpStatusCodeResult(500, ex.Message)); } finally { if (!isFaulted) { FinalizeRequest(nameWithoutExtension, mime, cachedImage.LastModifiedUtc.GetValueOrDefault()); } } }
private async Task <ActionResult> HandleImageAsync( ProcessImageQuery query, CachedImageResult cachedImage, string nameWithoutExtension, string mime, string extension, Func <string, Task <byte[]> > getSourceBufferAsync) { string prevMime = null; if (extension != cachedImage.Extension) { // The query requests another format. // Adjust extension and mime type fo proper ETag creation. extension = cachedImage.Extension; prevMime = mime; mime = MimeTypes.MapNameToMimeType(cachedImage.FileName); } try { if (!cachedImage.Exists) { // Lock concurrent requests to same resource using (await KeyedLock.LockAsync("MediaController.HandleImage." + cachedImage.Path)) { _imageCache.RefreshInfo(cachedImage); // File could have been processed by another request in the meantime, check again. if (!cachedImage.Exists) { // Call inner function byte[] source = await getSourceBufferAsync(prevMime); if (source == null || source.Length == 0) { return(NotFound(mime)); } source = await ProcessAndPutToCacheAsync(cachedImage, source, query); return(new CachedFileResult(mime, cachedImage.LastModifiedUtc.GetValueOrDefault(), () => source, source.LongLength)); } } } if (Request.HttpMethod == "HEAD") { return(new HttpStatusCodeResult(200)); } if (cachedImage.IsRemote && !_streamRemoteMedia) { // Redirect to existing remote file Response.ContentType = mime; return(Redirect(_imageCache.GetPublicUrl(cachedImage.Path))); } else { // Open existing stream return(new CachedFileResult(cachedImage.File, mime)); } } catch (Exception ex) { if (!(ex is ProcessImageException)) { // ProcessImageException is logged already in ImageProcessor Logger.ErrorFormat(ex, "Error processing media file '{0}'.", cachedImage.Path); } return(new HttpStatusCodeResult(500, ex.Message)); } }
public static async Task <string> GetUrlAsync(this IMediaService service, int?fileId, ProcessImageQuery imageQuery, string host = null, bool doFallback = true) { return(service.GetUrl(await service.GetFileByIdAsync(fileId ?? 0, MediaLoadFlags.AsNoTracking), imageQuery, host, doFallback)); }
protected override string GenerateMediaUrl() { ImageQuery = BuildImageQuery(); return(MediaUrlGenerator.GenerateUrl(File, ImageQuery.ToQueryString(), Host, !NoFallback)); }
public string GetUrl(MediaFileInfo file, ProcessImageQuery imageQuery, string host = null, bool doFallback = true) { return(_urlGenerator.GenerateUrl(file, imageQuery, host, doFallback)); }
public static string Media(this IUrlHelper urlHelper, MediaFileInfo file, ProcessImageQuery query, string host = null, bool doFallback = true) { var mediaService = urlHelper.ActionContext.HttpContext.RequestServices.GetRequiredService <IMediaService>(); return(mediaService.GetUrl(file, query, host, doFallback)); }
public static Task <string> MediaAsync(this IUrlHelper urlHelper, int?fileId, ProcessImageQuery query, string host = null, bool doFallback = true) { var mediaService = urlHelper.ActionContext.HttpContext.RequestServices.GetRequiredService <IMediaService>(); return(mediaService.GetUrlAsync(fileId, query, host, doFallback)); }
public static string Media(this UrlHelper urlHelper, int?fileId, ProcessImageQuery query, string host = null, bool doFallback = true) { return(EngineContext.Current.Resolve <IMediaService>().GetUrl(fileId, query, host, doFallback)); }