public WicFrameReader(WicDecoder dec, WicProcessingContext ctx) { Frame = AddRef(dec.Decoder.GetFrame((uint)ctx.Settings.FrameIndex)); Source = Frame; Context = ctx; if (ctx.ContainerFormat == Consts.GUID_ContainerFormatRaw && ctx.Settings.FrameIndex == 0) { try { Source = AddRef(dec.Decoder.GetPreview()); } catch { } } ctx.PixelFormat = Source.GetPixelFormat(); Source.GetSize(out ctx.Width, out ctx.Height); var ptrans = Source as IWICPlanarBitmapSourceTransform; if (ptrans != null) { uint pw = ctx.Width, ph = ctx.Height; var pdesc = new WICBitmapPlaneDescription[2]; var pfmts = new Guid[] { Consts.GUID_WICPixelFormat8bppY, Consts.GUID_WICPixelFormat16bppCbCr }; ctx.SupportsPlanar = ptrans.DoesSupportTransform(ref pw, ref ph, WICBitmapTransformOptions.WICBitmapTransformRotate0, WICPlanarOptions.WICPlanarOptionsPreserveSubsampling, pfmts, pdesc, 2); ctx.IsSubsampled = pdesc[0].Width != pdesc[1].Width || pdesc[0].Height != pdesc[1].Height; } }
public static void ProcessImage(Stream istm, Stream ostm, ProcessImageSettings s) { if (istm == null) { throw new ArgumentNullException(nameof(istm)); } if (ostm == null) { throw new ArgumentNullException(nameof(ostm)); } if (!istm.CanSeek || !istm.CanRead) { throw new ArgumentException("Input Stream must allow Seek and Read", nameof(istm)); } if (!ostm.CanSeek || !ostm.CanWrite) { throw new ArgumentException("Output Stream must allow Seek and Write", nameof(ostm)); } if (istm.Length <= 0 || istm.Position >= istm.Length) { throw new ArgumentException("Input Stream is empty or positioned at its end", nameof(istm)); } using (var ctx = new WicProcessingContext(s)) using (var dec = new WicDecoder(istm, ctx)) processImage(dec, ctx, ostm); }
private static void processImage(WicDecoder dec, WicProcessingContext ctx, Stream ostm) { using (var frm = new WicFrameReader(dec, ctx)) using (var met = new WicMetadataReader(frm)) { if (!ctx.Settings.Normalized) { ctx.Settings.Fixup((int)ctx.Width, (int)ctx.Height, ctx.IsRotated90); } if (EnablePlanarPipeline && ctx.SupportsPlanar) { MagicPlanarImageProcessor.ProcessImage(met, ctx, ostm); return; } using (var qsc = new WicNativeScaler(met)) using (var rot = new WicExifRotator(qsc)) using (var cac = new WicConditionalCache(rot)) using (var crp = new WicCropper(cac)) using (var pix = new WicPixelFormatConverter(crp)) using (var cmy = new WicCmykConverter(pix)) using (var res = new WicScaler(cmy, true)) using (var lll = new WicConvertToCustomPixelFormat(res)) using (var mmm = new WicHighQualityScaler(lll)) using (var mat = new WicMatteTransform(mmm)) using (var ggg = new WicConvertFromCustomPixelFormat(mat)) using (var csc = new WicColorspaceConverter(ggg)) using (var sss = new WicUnsharpMask(csc)) using (var dit = new WicPaletizer(sss)) using (var enc = new WicEncoder(ostm.AsIStream(), ctx)) enc.WriteSource(dit); } }
private static void processImage(WicDecoder dec, WicProcessingContext ctx, Stream ostm) { using (var frm = new WicFrameReader(dec, ctx)) using (var met = new WicMetadataReader(frm)) { if (!ctx.Settings.Normalized) { ctx.Settings.Fixup((int)ctx.Width, (int)ctx.Height, ctx.IsRotated90); } ctx.Settings.HybridMode = HybridScaleMode.Turbo; //ctx.NeedsCache = true; using (var qsc = new WicNativeScaler(met)) using (var rot = new WicExifRotator(qsc)) using (var cac = new WicConditionalCache(rot)) using (var crp = new WicCropper(cac)) using (var pix = new WicPixelFormatConverter(crp)) using (var cmy = new WicCmykConverter(pix)) using (var res = new WicScaler(cmy)) using (var csc = new WicColorspaceConverter(res)) using (var mat = new WicMatteTransform(csc)) using (var pal = new WicPaletizer(mat, 256)) using (var enc = new WicEncoder(ostm.AsIStream(), ctx)) enc.WriteSource(pal); } }
private void loadInfo(WicDecoder dec, WicProcessingContext ctx) { ContainerType = FileFormat.Unknown; if (ctx.ContainerFormat == Consts.GUID_ContainerFormatJpeg) { ContainerType = FileFormat.Jpeg; } else if (ctx.ContainerFormat == Consts.GUID_ContainerFormatPng) { ContainerType = FileFormat.Png; } else if (ctx.ContainerFormat == Consts.GUID_ContainerFormatGif) { ContainerType = FileFormat.Gif; } else if (ctx.ContainerFormat == Consts.GUID_ContainerFormatBmp) { ContainerType = FileFormat.Bmp; } else if (ctx.ContainerFormat == Consts.GUID_ContainerFormatTiff) { ContainerType = FileFormat.Tiff; } Frames = new FrameInfo[ctx.ContainerFrameCount]; for (int i = 0; i < ctx.ContainerFrameCount; i++) { ctx.Settings.FrameIndex = i; using (var frm = new WicFrameReader(dec, ctx)) using (var met = new WicMetadataReader(frm, basicOnly: true)) { Frames[i] = new FrameInfo((int)ctx.Width, (int)ctx.Height, ctx.IsRotated90, ctx.HasAlpha); } } }
private static ProcessImageResult processImage(WicDecoder dec, WicProcessingContext ctx, Stream ostm) { var frm = new WicFrameReader(ctx); WicTransforms.AddMetadataReader(ctx); ctx.FinalizeSettings(); WicTransforms.AddNativeScaler(ctx); WicTransforms.AddExifRotator(ctx); WicTransforms.AddConditionalCache(ctx); WicTransforms.AddCropper(ctx); WicTransforms.AddPixelFormatConverter(ctx); WicTransforms.AddScaler(ctx); WicTransforms.AddColorspaceConverter(ctx); MagicTransforms.AddMatte(ctx); MagicTransforms.AddPad(ctx); WicTransforms.AddIndexedColorConverter(ctx); var enc = new WicEncoder(ctx, ostm.AsIStream()); enc.WriteSource(ctx); return(new ProcessImageResult { Settings = ctx.UsedSettings, Stats = ctx.Stats }); }
public static void ProcessImage(byte[] imgBuffer, Stream ostm, ProcessImageSettings s) { Contract.Requires <ArgumentNullException>(imgBuffer != null, nameof(imgBuffer)); Contract.Requires <ArgumentNullException>(ostm != null, nameof(ostm)); Contract.Requires <ArgumentException>(ostm.CanSeek && ostm.CanWrite, "Output Stream must allow Seek and Write"); using (var ctx = new WicProcessingContext(s)) using (var dec = new WicDecoder(imgBuffer, ctx)) processImage(dec, ctx, ostm); }
/// <summary>Constructs a new processing pipeline from which pixels can be retrieved.</summary> /// <param name="imgStream">A stream containing a supported input image container.</param> /// <param name="settings">The settings for this processing operation.</param> /// <returns>A <see cref="ProcessingPipeline" /> containing the <see cref="IPixelSource" />, settings used, and basic instrumentation for the pipeline.</returns> public static ProcessingPipeline BuildPipeline(Stream imgStream, ProcessImageSettings settings) { checkInStream(imgStream); var ctx = new WicProcessingContext(settings); var dec = new WicDecoder(imgStream, ctx); buildPipeline(ctx, false); return(new ProcessingPipeline(ctx)); }
public ImageFileInfo(byte[] imgBuffer, DateTime lastModified) { Contract.Requires <ArgumentNullException>(imgBuffer != null, nameof(imgBuffer)); using (var ctx = new WicProcessingContext(new ProcessImageSettings())) using (var dec = new WicDecoder(imgBuffer, ctx)) loadInfo(dec, ctx); FileSize = imgBuffer.Length; FileDate = lastModified; }
public static void ProcessImage(Stream istm, Stream ostm, ProcessImageSettings s) { Contract.Requires <ArgumentNullException>(istm != null, nameof(istm)); Contract.Requires <ArgumentNullException>(ostm != null, nameof(ostm)); Contract.Requires <ArgumentException>(istm.CanSeek && istm.CanRead, "Input Stream must allow Seek and Read"); Contract.Requires <ArgumentException>(ostm.CanSeek && ostm.CanWrite, "Output Stream must allow Seek and Write"); Contract.Assume(istm.Position < istm.Length, "Input Stream Position is at the end. Did you forget to Seek?"); using (var ctx = new WicProcessingContext(s)) using (var dec = new WicDecoder(istm, ctx)) processImage(dec, ctx, ostm); }
/// <summary>All-in-one processing of an image according to the specified <paramref name="settings" />.</summary> /// <param name="imgStream">A stream containing a supported input image container.</param> /// <param name="outStream">The stream to which the output image will be written.</param> /// <param name="settings">The settings for this processing operation.</param> /// <returns>A <see cref="ProcessImageResult" /> containing the settings used and basic instrumentation for the pipeline.</returns> public static ProcessImageResult ProcessImage(Stream imgStream, Stream outStream, ProcessImageSettings settings) { checkInStream(imgStream); checkOutStream(outStream); using (var ctx = new WicProcessingContext(settings)) { var dec = new WicDecoder(imgStream, ctx); buildPipeline(ctx); return(executePipeline(ctx, outStream)); } }
/// <summary>Constructs a new processing pipeline from which pixels can be retrieved.</summary> /// <param name="imgSource">A custom pixel source to use as input.</param> /// <param name="settings">The settings for this processing operation.</param> /// <returns>A <see cref="ProcessingPipeline" /> containing the <see cref="IPixelSource" />, settings used, and basic instrumentation for the pipeline.</returns> public static ProcessingPipeline BuildPipeline(IPixelSource imgSource, ProcessImageSettings settings) { if (imgSource is null) { throw new ArgumentNullException(nameof(imgSource)); } var ctx = new WicProcessingContext(settings); var dec = new WicDecoder(imgSource, ctx); buildPipeline(ctx, false); return(new ProcessingPipeline(ctx)); }
/// <summary>Constructs a new processing pipeline from which pixels can be retrieved.</summary> /// <param name="imgBuffer">A buffer containing a supported input image container.</param> /// <param name="settings">The settings for this processing operation.</param> /// <returns>A <see cref="ProcessingPipeline" /> containing the <see cref="IPixelSource" />, settings used, and basic instrumentation for the pipeline.</returns> public static ProcessingPipeline BuildPipeline(ReadOnlySpan <byte> imgBuffer, ProcessImageSettings settings) { if (imgBuffer == default) { throw new ArgumentNullException(nameof(imgBuffer)); } var ctx = new WicProcessingContext(settings); var dec = new WicDecoder(imgBuffer, ctx); buildPipeline(ctx, false); return(new ProcessingPipeline(ctx)); }
public static ProcessingPipeline BuildPipeline(string imgPath, ProcessImageSettings settings) { if (imgPath == null) { throw new ArgumentNullException(nameof(imgPath)); } var ctx = new WicProcessingContext(settings); var dec = new WicDecoder(imgPath, ctx); buildPipeline(ctx, false); return(new ProcessingPipeline(ctx)); }
public ImageFileInfo(byte[] imgBuffer, DateTime lastModified) { if (imgBuffer == null) { throw new ArgumentNullException(nameof(imgBuffer)); } using (var ctx = new WicProcessingContext(new ProcessImageSettings())) using (var dec = new WicDecoder(imgBuffer, ctx)) loadInfo(dec, ctx); FileSize = imgBuffer.Length; FileDate = lastModified; }
public ImageFileInfo(Stream istm, DateTime lastModified) { Contract.Requires <ArgumentNullException>(istm != null, nameof(istm)); Contract.Requires <ArgumentException>(istm.CanSeek && istm.CanRead, "Input Stream must allow Seek and Read"); Contract.Assert(istm.Length > 0, "Input Stream cannot be empty"); Contract.Assume(istm.Position < istm.Length, "Input Stream Position is at the end. Did you forget to Seek?"); using (var ctx = new WicProcessingContext(new ProcessImageSettings())) using (var dec = new WicDecoder(istm, ctx)) loadInfo(dec, ctx); FileSize = istm.Length; FileDate = lastModified; }
/// <summary>All-in-one processing of an image according to the specified <paramref name="settings" />.</summary> /// <param name="imgBuffer">A buffer containing a supported input image container.</param> /// <param name="outStream">The stream to which the output image will be written.</param> /// <param name="settings">The settings for this processing operation.</param> /// <returns>A <see cref="ProcessImageResult" /> containing the settings used and basic instrumentation for the pipeline.</returns> public static ProcessImageResult ProcessImage(ReadOnlySpan <byte> imgBuffer, Stream outStream, ProcessImageSettings settings) { if (imgBuffer == default) { throw new ArgumentNullException(nameof(imgBuffer)); } checkOutStream(outStream); using (var ctx = new WicProcessingContext(settings)) { var dec = new WicDecoder(imgBuffer, ctx); buildPipeline(ctx); return(executePipeline(ctx, outStream)); } }
/// <summary>All-in-one processing of an image according to the specified <paramref name="settings" />.</summary> /// <param name="imgPath">The path to a file containing the input image.</param> /// <param name="outStream">The stream to which the output image will be written.</param> /// <param name="settings">The settings for this processing operation.</param> /// <returns>A <see cref="ProcessImageResult" /> containing the settings used and basic instrumentation for the pipeline.</returns> public static ProcessImageResult ProcessImage(string imgPath, Stream outStream, ProcessImageSettings settings) { if (imgPath is null) { throw new ArgumentNullException(nameof(imgPath)); } checkOutStream(outStream); using (var ctx = new WicProcessingContext(settings)) { var dec = new WicDecoder(imgPath, ctx); buildPipeline(ctx); return(executePipeline(ctx, outStream)); } }
private void loadInfo(WicDecoder dec, WicProcessingContext ctx) { ContainerType = ctx.Decoder.ContainerFormat; Frames = new FrameInfo[ctx.Decoder.FrameCount]; for (int i = 0; i < ctx.Decoder.FrameCount; i++) { ctx.Settings.FrameIndex = i; var frm = new WicFrameReader(ctx); WicTransforms.AddMetadataReader(ctx, basicOnly: true); int width = (int)(frm.ExifOrientation.RequiresDimensionSwap() ? ctx.Source.Height : ctx.Source.Width); int height = (int)(frm.ExifOrientation.RequiresDimensionSwap() ? ctx.Source.Width : ctx.Source.Height); Frames[i] = new FrameInfo(width, height, ctx.Source.Format.AlphaRepresentation != PixelAlphaRepresentation.None, frm.ExifOrientation); } }
public ImageFileInfo(string imgPath) { var fi = new FileInfo(imgPath); if (!fi.Exists) { throw new FileNotFoundException("File not found", imgPath); } using (var ctx = new WicProcessingContext(new ProcessImageSettings())) using (var dec = new WicDecoder(imgPath, ctx)) loadInfo(dec, ctx); FileSize = fi.Length; FileDate = fi.LastWriteTimeUtc; }
public static ProcessingPipeline BuildPipeline(ArraySegment <byte> imgBuffer, ProcessImageSettings settings) { if (imgBuffer == null) { throw new ArgumentNullException(nameof(imgBuffer)); } if (imgBuffer.Offset != 0) { throw new ArgumentException($"{nameof(imgBuffer.Offset)} must be 0", nameof(imgBuffer)); } var ctx = new WicProcessingContext(settings); var dec = new WicDecoder(imgBuffer, ctx); buildPipeline(ctx, false); return(new ProcessingPipeline(ctx)); }
public ImageFileInfo(string imgPath) { Contract.Requires <ArgumentNullException>(imgPath != null, nameof(imgPath)); var fi = new FileInfo(imgPath); if (!fi.Exists) { throw new ArgumentException("File does not exist"); } using (var ctx = new WicProcessingContext(new ProcessImageSettings())) using (var dec = new WicDecoder(imgPath, ctx)) loadInfo(dec, ctx); FileSize = fi.Length; FileDate = fi.LastWriteTimeUtc; }
public static void ProcessImage(byte[] imgBuffer, Stream ostm, ProcessImageSettings s) { if (imgBuffer == null) { throw new ArgumentNullException(nameof(imgBuffer)); } if (ostm == null) { throw new ArgumentNullException(nameof(ostm)); } if (!ostm.CanSeek || !ostm.CanWrite) { throw new ArgumentException("Output Stream must allow Seek and Write", nameof(ostm)); } using (var ctx = new WicProcessingContext(s)) using (var dec = new WicDecoder(imgBuffer, ctx)) processImage(dec, ctx, ostm); }
public WicFrameReader(WicDecoder dec, WicProcessingContext ctx) : base(ctx) { Frame = AddRef(dec.Decoder.GetFrame((uint)ctx.Settings.FrameIndex)); Source = Frame; if (ctx.ContainerFormat == Consts.GUID_ContainerFormatRaw && ctx.Settings.FrameIndex == 0 && dec.Decoder.TryGetPreview(out var preview)) { Source = AddRef(preview); } ctx.PixelFormat = PixelFormat.Cache[Source.GetPixelFormat()]; Source.GetSize(out ctx.Width, out ctx.Height); Source.GetResolution(out ctx.DpiX, out ctx.DpiY); if (Source is IWICPlanarBitmapSourceTransform ptrans) { uint pw = ctx.Width, ph = ctx.Height; var pdesc = new WICBitmapPlaneDescription[2]; var pfmts = new Guid[] { Consts.GUID_WICPixelFormat8bppY, Consts.GUID_WICPixelFormat16bppCbCr }; ctx.SupportsPlanar = ptrans.DoesSupportTransform(ref pw, ref ph, WICBitmapTransformOptions.WICBitmapTransformRotate0, WICPlanarOptions.WICPlanarOptionsDefault, pfmts, pdesc, 2); } }
public ImageFileInfo(Stream istm, DateTime lastModified) { if (istm == null) { throw new ArgumentNullException(nameof(istm)); } if (!istm.CanSeek || !istm.CanRead) { throw new ArgumentException("Input Stream must allow Seek and Read", nameof(istm)); } if (istm.Length <= 0 || istm.Position >= istm.Length) { throw new ArgumentException("Input Stream is empty or positioned at its end", nameof(istm)); } using (var ctx = new WicProcessingContext(new ProcessImageSettings())) using (var dec = new WicDecoder(istm, ctx)) loadInfo(dec, ctx); FileSize = istm.Length; FileDate = lastModified; }
private static void processImage(WicDecoder dec, WicProcessingContext ctx, Stream ostm) { using (var frm = new WicFrameReader(dec, ctx)) using (var met = new WicMetadataReader(frm)) { if (!ctx.Settings.Normalized) { ctx.Settings.Fixup((int)ctx.Width, (int)ctx.Height, ctx.IsRotated90); } bool mod1 = (!ctx.IsSubsampled || ctx.Settings.HybridScaleRatio > 1d || (ctx.Settings.Crop.Width % 2 == 0 && ctx.Settings.Crop.Height % 2 == 0) || (ctx.Settings.Crop.Width == ctx.Width && ctx.Settings.Crop.Height == ctx.Height)); bool planar = ctx.SupportsPlanar && mod1; if (planar && ctx.Settings.HybridMode != HybridScaleMode.Off) { MagicPlanarImageProcessor.ProcessImage(met, ctx, ostm); return; } using (var qsc = new WicNativeScaler(met)) using (var rot = new WicExifRotator(qsc)) using (var cac = new WicConditionalCache(rot)) using (var crp = new WicCropper(cac)) using (var pix = new WicPixelFormatConverter(crp)) using (var cmy = new WicCmykConverter(pix)) using (var res = new WicScaler(cmy, true)) using (var lll = new WicGammaExpand(res)) using (var mmm = new WicHighQualityScaler(lll)) using (var mat = new WicMatteTransform(mmm)) using (var ggg = new WicGammaCompress(mat)) using (var csc = new WicColorspaceConverter(ggg)) using (var sss = new WicUnsharpMask(csc)) using (var dit = new WicPaletizer(sss, 256)) using (var enc = new WicEncoder(ostm.AsIStream(), ctx)) enc.WriteSource(dit); } }
public static void ProcessImage(byte[] imgBuffer, Stream ostm, ProcessImageSettings s) { using (var ctx = new WicProcessingContext(s)) using (var dec = new WicDecoder(imgBuffer, ctx)) processImage(dec, ctx, ostm); }
public static void ProcessImage(string imgPath, Stream ostm, ProcessImageSettings s) { using (var ctx = new WicProcessingContext(s)) using (var dec = new WicDecoder(imgPath, ctx)) processImage(dec, ctx, ostm); }