MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Media.Imaging;

using System.Windows.Media;

using System.Collections.ObjectModel;

using System.Diagnostics;

using System.Security.Permissions;

using System.Windows.Threading;

using System.IO;

namespace ImageFields

{

    internal class BitmapTransformer

    {

        // Fields

        private WriteableBitmap bitmap;

        private KeyedCollection<string, CachedFrame> cachedFrames = new CachedFrameCollection();

        private KeyedCollection<string, InputNode> inputs = new InputNodeCollection();

        private int largeFile = 0x5f5e100;

        private KeyedCollection<string, OutputNode> outputs = new OutputNodeCollection();

        private byte[] pixelStorage;

        public const int TargetDpi = 0x60;

        private const double Tolerance = 1E-10;

        private int totalBlank;

        private int totalComposite;

        private int totalOutputs;

        private int totalSingle;

        // Events

        public event EventHandler<StreamEventArgs> InputCompleted;

        public event EventHandler<StreamEventArgs> InputNeeded;

        public event EventHandler<StreamEventArgs> OutputCompleted;

        public event EventHandler<StreamEventArgs> OutputNeeded;

        // Methods

        public BitmapTransformer()

        {

            this.OutputAlpha = true;

            this.KeepImagesInCache = true;

            this.StripingEnabled = true;

        }

        public void AddInput(string fileName)

        {

            if (!this.inputs.Contains(fileName))

            {

                this.inputs.Add(new InputNode(fileName));

            }

        }

        public void AddOutput(string fileName, int width, int height, double quality, ImageFormat format, Color backgroundColor, bool cacheFrame)

        {

            if (!this.outputs.Contains(fileName))

            {

                OutputNode item = new OutputNode(fileName)

                {

                    BackgroundColor = backgroundColor,

                    Width = width,

                    Height = height,

                    Quality = quality,

                    Format = format,

                    CacheFrame = cacheFrame

                };

                this.outputs.Add(item);

                this.totalOutputs++;

            }

        }

        public void AddOutputAsInput(string fileName)

        {

            if (!this.inputs.Contains(fileName) && this.cachedFrames.Contains(fileName))

            {

                InputNode node = new InputNode(fileName);

                   node.InputSource = this.cachedFrames[fileName].frame;

                   node. PixelHeight = node.InputSource.PixelHeight;

                    node.PixelWidth = node.InputSource.PixelWidth;

                    node.LastScanLineLoaded = node.PixelHeight;

                this.inputs.Add(node);

            }

        }

        public void AddTransformation(string input, string output, Rect inputRect, Rect outputRect)

        {

            Debug.Assert(!inputRect.IsEmpty, "Empty input rect");

            Debug.Assert(!outputRect.IsEmpty, "Empty output rect");

            Debug.Assert((inputRect.X >= 0.0) && (inputRect.Y >= 0.0), "Negative input rect");

            Debug.Assert((outputRect.X >= 0.0) && (outputRect.Y >= 0.0), "Negative output rect");

            if ((outputRect.Width > 0.5) && (outputRect.Height > 0.5))

            {

                Int32Rect rect = RectToInt32Rect(inputRect);

                if ((inputRect.Width > 0.0) && (rect.Width == 0))

                {

                    rect.Width = 1;

                    rect.X = (int)Math.Floor(inputRect.X);

                }

                if ((inputRect.Height > 0.0) && (rect.Height == 0))

                {

                    rect.Height = 1;

                    rect.Y = (int)Math.Floor(inputRect.Y);

                }

                if ((rect.Width > 0) && (rect.Height > 0))

                {

                    TransformationNode item = new TransformationNode

                    {

                        Input = input,

                        InputRect = rect,

                        OutputRect = outputRect

                    };

                    this.outputs[output].Transforms.Add(item);

                }

            }

        }

        internal PixelFormat ChoosePixelFormat(ImageFormat imageFormat)

        {

            if (((imageFormat == ImageFormat.Png) || (imageFormat == ImageFormat.Wdp)) && this.OutputAlpha)

            {

                return PixelFormats.Bgra32;

            }

            return PixelFormats.Bgr24;

        }

        public void CleanUp()

        {

            this.CloseAllInputs();

            this.cachedFrames.Clear();

            this.outputs.Clear();

            GC.Collect(2);

            GC.Collect(2);

        }

        public void CloseAllInputs()

        {

            foreach (InputNode node in this.inputs)

            {

                this.CloseInput(node.FileName);

            }

            this.bitmap = null;

            this.pixelStorage = null;

        }

        public void CloseInput(string fileName)

        {

            InputNode node = this.inputs[fileName];

            node.InputSource = null;

            node.FirstScanLineLoaded = 0;

            node.LastScanLineLoaded = 0;

        }

        [FileIOPermission(SecurityAction.LinkDemand)]

        public void CloseOutput(string fileName)

        {

            if (this.outputs.Contains(fileName))

            {

                this.CloseOutputImpl(this.outputs[fileName]);

                this.outputs.Remove(fileName);

            }

        }

        [FileIOPermission(SecurityAction.LinkDemand)]

        private void CloseOutputImpl(OutputNode outputNode)

        {

            PixelFormat format;

            BitmapSource source;

            string str;

            DrawingVisual visual;

            DrawingContext context;

            RenderTargetBitmap bitmap2;

            FormatConvertedBitmap bitmap3;

            WriteableBitmap bitmap4;

            BitmapEncoder encoder = this.GetEncoder(outputNode, out format, out str);

            Rect rectangle = new Rect(0.0, 0.0, (double)outputNode.Width, (double)outputNode.Height);

            BitmapMetadata destinationMD = null;

            if (this.CopyMetadata)

            {

                string containerFormat = string.Empty;

                switch (outputNode.Format)

                {

                    case ImageFormat.Jpg:

                        containerFormat = "jpg";

                        break;

                    case ImageFormat.Png:

                        containerFormat = "png";

                        break;

                    case ImageFormat.Wdp:

                        containerFormat = "wmphoto";

                        break;

                }

                destinationMD = new BitmapMetadata(containerFormat);

            }

            bool flag = true;

            if (((IsFormatOpaque(format) && (outputNode.BackgroundColor.R == Colors.Black.R)) && ((outputNode.BackgroundColor.G == Colors.Black.G) && (outputNode.BackgroundColor.B == Colors.Black.B))) || (!IsFormatOpaque(format) && (outputNode.BackgroundColor.A == Colors.Transparent.A)))

            {

                flag = false;

            }

            if (outputNode.Transforms.Count <= 0)

            {

                if (flag)

                {

                    bitmap2 = new RenderTargetBitmap(outputNode.Width, outputNode.Height, 96.0, 96.0, PixelFormats.Default);

                    visual = new DrawingVisual();

                    using (context = visual.RenderOpen())

                    {

                        context.DrawRectangle(new SolidColorBrush(outputNode.BackgroundColor), null, rectangle);

                    }

                    bitmap2.Render(visual);

                    bitmap3 = new FormatConvertedBitmap(bitmap2, format, null, 0.0);

                    source = bitmap3;

                }

                else

                {

                    bitmap4 = new WriteableBitmap(outputNode.Width, outputNode.Height, 96.0, 96.0, format, null);

                    source = bitmap4;

                }

                this.totalBlank++;

            }

            else

            {

                TransformationNode node = null;

                Rect outputRect;

                Int32Rect rect3;

                BitmapSource source2;

                Int32Rect inputRect;

                InputNode node2;

                BitmapSource source4;

                BitmapMetadata metadata;

                bool flag2 = true;

                for (int i = outputNode.Transforms.Count - 1; i > 0; i--)

                {

                    node = outputNode.Transforms[i];

                    if (node.OutputRect == rectangle)

                    {

                        rect3 = new Int32Rect(0, 0, 0, 0);

                        if (IsFormatOpaque(this.CreateInputFrame(this.inputs[node.Input], rect3).Format))

                        {

                            outputNode.Transforms.RemoveRange(0, i);

                            break;

                        }

                    }

                }

                if (outputNode.Transforms.Count != 1)

                {

                    flag2 = false;

                }

                if (flag2)

                {

                    node = outputNode.Transforms[0];

                    rect3 = new Int32Rect(0, 0, 0, 0);

                    BitmapSource source3 = this.CreateInputFrame(this.inputs[node.Input], rect3);

                    if ((source3.DpiX != 96.0) || (source3.DpiY != 96.0))

                    {

                        flag2 = false;

                    }

                    if (!RectEqualWithTolerance(node.OutputRect, rectangle))

                    {

                        flag2 = false;

                    }

                    if (!(!(outputNode.BackgroundColor != Colors.Transparent) || IsFormatOpaque(source3.Format)))

                    {

                        flag2 = false;

                    }

                }

                if (flag2)

                {

                    node = outputNode.Transforms[0];

                    outputRect = node.OutputRect;

                    inputRect = node.InputRect;

                    node2 = this.inputs[node.Input];

                    source2 = this.CreateInputFrame(node2, inputRect);

                    if (!this.KeepImagesInCache)

                    {

                        this.CloseInput(node.Input);

                    }

                    inputRect.Y -= node2.FirstScanLineLoaded;

                    source4 = ScaleAndCropBitmap(ref outputRect, ref inputRect, source2);

                    if (source2.Format != format)

                    {

                        source4 = new FormatConvertedBitmap(source4, format, null, 0.0);

                    }

                    if (this.CopyMetadata)

                    {

                        metadata = (BitmapMetadata)source2.Metadata;

                        if (metadata != null)

                        {

                            CopyBitmapMetadata(metadata, destinationMD);

                        }

                    }

                    source = source4;

                    this.totalSingle++;

                }

                else

                {

                    bool flag3 = flag;

                    if (!flag3)

                    {

                        foreach (TransformationNode item in outputNode.Transforms)

                        {

                            rect3 = new Int32Rect(0, 0, 0, 0);

                            source2 = this.CreateInputFrame(this.inputs[item.Input], rect3);

                            if (!(IsFormatOpaque(source2.Format) && (source2.DpiX == source2.DpiY)))

                            {

                                flag3 = true;

                                break;

                            }

                        }

                    }

                    if (flag3)

                    {

                        visual = new DrawingVisual();

                        using (context = visual.RenderOpen())

                        {

                            if (flag)

                            {

                                context.DrawRectangle(new SolidColorBrush(outputNode.BackgroundColor), null, rectangle);

                            }

                            foreach (TransformationNode item in outputNode.Transforms)

                            {

                                outputRect = item.OutputRect;

                                inputRect = item.InputRect;

                                node2 = this.inputs[item.Input];

                                source2 = this.CreateInputFrame(node2, inputRect);

                                if (!this.KeepImagesInCache)

                                {

                                    this.CloseInput(node.Input);

                                }

                                if (this.CopyMetadata)

                                {

                                    metadata = (BitmapMetadata)source2.Metadata;

                                    if (metadata != null)

                                    {

                                        CopyBitmapMetadata(metadata, destinationMD);

                                    }

                                }

                                inputRect.Y -= node2.FirstScanLineLoaded;

                                if (source2.DpiX == source2.DpiY)

                                {

                                    source4 = ScaleAndCropBitmap(ref outputRect, ref inputRect, source2);

                                    context.DrawImage(source4, outputRect);

                                }

                                else

                                {

                                    Rect r = Int32RectToRect(inputRect);

                                    if (source2.DpiX > source2.DpiY)

                                    {

                                        r.Scale(1.0, source2.DpiX / source2.DpiY);

                                    }

                                    else

                                    {

                                        r.Scale(source2.DpiY / source2.DpiX, 1.0);

                                    }

                                    Int32Rect sourceRect = RectToInt32Rect(r);

                                    CroppedBitmap imageSource = new CroppedBitmap(source2, sourceRect);

                                    context.DrawImage(imageSource, outputRect);

                                }

                            }

                            context.Close();

                        }

                        bitmap2 = new RenderTargetBitmap(outputNode.Width, outputNode.Height, 96.0, 96.0, PixelFormats.Default);

                        bitmap2.Render(visual);

                        bitmap3 = new FormatConvertedBitmap(bitmap2, format, null, 0.0);

                        source = bitmap3;

                    }

                    else

                    {

                        bitmap4 = new WriteableBitmap(outputNode.Width, outputNode.Height, 96.0, 96.0, format, null);

                        foreach (TransformationNode item in outputNode.Transforms)

                        {

                            outputRect = item.OutputRect;

                            inputRect = item.InputRect;

                            node2 = this.inputs[item.Input];

                            source2 = this.CreateInputFrame(node2, inputRect);

                            if (!this.KeepImagesInCache)

                            {

                                this.CloseInput(node.Input);

                            }

                            if (this.CopyMetadata)

                            {

                                metadata = (BitmapMetadata)source2.Metadata;

                                if (metadata != null)

                                {

                                    CopyBitmapMetadata(metadata, destinationMD);

                                }

                            }

                            inputRect.Y -= node2.FirstScanLineLoaded;

                            Int32Rect rect7 = RectToInt32Rect(outputRect);

                            if ((rect7.Width > 0) && (rect7.Height > 0))

                            {

                                var _rec = Int32RectToRect(rect7);

                                source4 = ScaleAndCropBitmap(ref _rec, ref inputRect, source2);

                                if (source2.Format != format)

                                {

                                    source4 = new FormatConvertedBitmap(source4, format, null, 0.0);

                                }

                                int num2 = (source4.PixelWidth * source4.PixelHeight) * 4;

                                if ((this.pixelStorage == null) || (this.pixelStorage.Length < num2))

                                {

                                    this.pixelStorage = new byte[num2];

                                }

                                int stride = ((rect7.Width * format.BitsPerPixel) + 7) / 8;

                                source4.CopyPixels(this.pixelStorage, stride, 0);

                                bitmap4.WritePixels(rect7, this.pixelStorage, stride, 0);

                            }

                        }

                        source = bitmap4;

                    }

                    this.totalComposite++;

                }

            }

            List<ColorContext> list = new List<ColorContext> {

            new ColorContext(format)

        };

            BitmapFrame frameToCache = BitmapFrame.Create(source, null, destinationMD, null);

            if (outputNode.CacheFrame)

            {

                this.cachedFrames.Add(new CachedFrame(outputNode.FileName, frameToCache));

            }

            encoder.Frames.Add(frameToCache);

            StreamEventArgs e = new StreamEventArgs(outputNode.FileName)

            {

                MimeType = str,

                Compress = false,

                Progress = ((double)((this.totalBlank + this.totalComposite) + this.totalSingle)) / ((double)this.totalOutputs)

            };

            EventHandler<StreamEventArgs> outputNeeded = this.OutputNeeded;

            if (outputNeeded == null)

            {

                using (FileStream stream = new FileStream(outputNode.FileName, FileMode.Create))

                {

                    encoder.Save(stream);

                    stream.Flush();

                }

            }

            else

            {

                outputNeeded(this, e);

                encoder.Save(e.Stream);

                e.Stream.Flush();

            }

            EventHandler<StreamEventArgs> outputCompleted = this.OutputCompleted;

            if (outputCompleted != null)

            {

                outputCompleted(this, e);

            }

            outputNode.Transforms.Clear();

        }

        private static void CopyBitmapMetadata(BitmapMetadata sourceMD, BitmapMetadata destinationMD)

        {

            if (destinationMD.Format == sourceMD.Format)

            {

                destinationMD.SetQuery("/", sourceMD);

            }

            else

            {

                if (sourceMD.DateTaken != null)

                {

                    destinationMD.DateTaken = sourceMD.DateTaken;

                }

                if ((destinationMD.Format != "png") && (sourceMD.Format != "png"))

                {

                    if (sourceMD.ApplicationName != null)

                    {

                        destinationMD.ApplicationName = sourceMD.ApplicationName;

                    }

                    if (sourceMD.Author != null)

                    {

                        destinationMD.Author = sourceMD.Author;

                    }

                    if (sourceMD.CameraManufacturer != null)

                    {

                        destinationMD.CameraManufacturer = sourceMD.CameraManufacturer;

                    }

                    if (sourceMD.CameraModel != null)

                    {

                        destinationMD.CameraModel = sourceMD.CameraModel;

                    }

                    if (sourceMD.Comment != null)

                    {

                        destinationMD.Comment = sourceMD.Comment;

                    }

                    if (sourceMD.Copyright != null)

                    {

                        destinationMD.Copyright = sourceMD.Copyright;

                    }

                    if (sourceMD.Keywords != null)

                    {

                        destinationMD.Keywords = sourceMD.Keywords;

                    }

                    destinationMD.Rating = sourceMD.Rating;

                    if (sourceMD.Subject != null)

                    {

                        destinationMD.Subject = sourceMD.Subject;

                    }

                    if (sourceMD.Title != null)

                    {

                        destinationMD.Title = sourceMD.Title;

                    }

                }

            }

        }

        internal BitmapDecoder CreateBitmapDecoder(StreamEventArgs streamEventArgs, BitmapCreateOptions createOptions, BitmapCacheOption cacheOption)

        {

            BitmapDecoder decoder = null;

            string absoluteUri;

            NotSupportedException exception;

            if (this.InputNeeded == null)

            {

                Uri bitmapUri = new Uri(streamEventArgs.FileName, UriKind.RelativeOrAbsolute);

                absoluteUri = bitmapUri.AbsoluteUri;

                try

                {

                    decoder = BitmapDecoder.Create(bitmapUri, createOptions, cacheOption);

                }

                catch (NotSupportedException exception1)

                {

                    exception = exception1;

                    throw new InvalidDataException("File is not in an image format '" + absoluteUri + "'. Exception message: " + exception.Message);

                }

                catch (OutOfMemoryException)

                {

                    decoder = BitmapDecoder.Create(bitmapUri, BitmapCreateOptions.IgnoreImageCache, BitmapCacheOption.None);

                }

            }

            else

            {

                absoluteUri = streamEventArgs.FileName;

                this.InputNeeded(this, streamEventArgs);

                try

                {

                    decoder = BitmapDecoder.Create(streamEventArgs.Stream, createOptions, cacheOption);

                }

                catch (NotSupportedException exception3)

                {

                    exception = exception3;

                    throw new InvalidDataException("File is not in an image format '" + absoluteUri + "'. Exception message: " + exception.Message);

                }

            }

            if (decoder.IsDownloading)

            {

                bool downloadFailed = false;

                DispatcherFrame frame = new DispatcherFrame();

                decoder.DownloadCompleted += delegate

                {

                    frame.Continue = false;

                };

                decoder.DownloadFailed += delegate

                {

                    downloadFailed = true;

                    frame.Continue = false;

                };

                Dispatcher.PushFrame(frame);

                if (downloadFailed)

                {

                    throw new InvalidDataException("Download failed '" + absoluteUri + "'.");

                }

            }

            return decoder;

        }

        private BitmapSource CreateInputFrame(InputNode inputNode, Int32Rect rectNeeded)

        {

            bool flag = false;

            if ((inputNode.InputSource == null) || (!rectNeeded.IsEmpty && ((rectNeeded.Y < inputNode.FirstScanLineLoaded) || ((rectNeeded.Height + rectNeeded.Y) > inputNode.LastScanLineLoaded))))

            {

                if (inputNode.InputSource != null)

                {

                    inputNode.InputSource = null;

                    inputNode.FirstScanLineLoaded = 0;

                    inputNode.LastScanLineLoaded = 0;

                    GC.Collect(2);

                    GC.Collect(2);

                }

                BitmapDecoder decoder = null;

                StreamEventArgs streamEventArgs = new StreamEventArgs(inputNode.FileName);

                decoder = this.CreateBitmapDecoder(streamEventArgs, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);

                if (!rectNeeded.IsEmpty)

                {

                    inputNode.FirstScanLineLoaded = 0;

                    inputNode.LastScanLineLoaded = decoder.Frames[0].PixelHeight;

                }

                bool flag2 = false;

                if ((this.LargeFile != 0) && ((decoder.Frames[0].PixelWidth * rectNeeded.Height) <= this.LargeFile))

                {

                    flag2 = true;

                }

                bool flag3 = false;

                if ((decoder.Frames[0].PixelHeight * decoder.Frames[0].PixelWidth) > this.LargeFile)

                {

                    flag3 = true;

                }

                if ((this.LargeFile != 0) && flag3)

                {

                    if ((!rectNeeded.IsEmpty && this.StripingEnabled) && flag2)

                    {

                        flag = true;

                    }

                    decoder = this.CreateBitmapDecoder(streamEventArgs, BitmapCreateOptions.IgnoreImageCache, BitmapCacheOption.None);

                }

                BitmapSource frame = decoder.Frames[0];

                StraightenFrame(ref frame);

                inputNode.PixelHeight = frame.PixelHeight;

                inputNode.PixelWidth = frame.PixelWidth;

                inputNode.Format = frame.Format;

                inputNode.Palette = frame.Palette;

                inputNode.InputSource = frame;

                if (flag)

                {

                    int num = (int)Math.Ceiling((double)((inputNode.PixelHeight * inputNode.PixelWidth) / ((double)this.LargeFile)));

                    int pixelHeight = (int)Math.Round((double)(((double)inputNode.PixelHeight) / ((double)num)));

                    int num3 = (int)Math.Truncate((double)(((double)rectNeeded.Y) / ((double)pixelHeight)));

                    inputNode.FirstScanLineLoaded = pixelHeight * num3;

                    inputNode.LastScanLineLoaded = Math.Min(inputNode.FirstScanLineLoaded + pixelHeight, inputNode.PixelHeight);

                    if ((inputNode.FirstScanLineLoaded > rectNeeded.Y) || (inputNode.LastScanLineLoaded < (rectNeeded.Height + rectNeeded.Y)))

                    {

                        inputNode.FirstScanLineLoaded = rectNeeded.Y;

                        inputNode.LastScanLineLoaded = rectNeeded.Height + rectNeeded.Y;

                        pixelHeight = inputNode.LastScanLineLoaded - inputNode.FirstScanLineLoaded;

                    }

                    Int32Rect sourceRect = new Int32Rect(0, inputNode.FirstScanLineLoaded, inputNode.PixelWidth, inputNode.LastScanLineLoaded - inputNode.FirstScanLineLoaded);

                    if (((this.bitmap == null) || (this.bitmap.PixelHeight < pixelHeight)) || (this.bitmap.PixelWidth < inputNode.PixelWidth))

                    {

                        if (this.bitmap != null)

                        {

                            this.bitmap = null;

                            GC.Collect();

                            GC.Collect();

                        }

                        this.bitmap = new WriteableBitmap(inputNode.PixelWidth, pixelHeight, 96.0, 96.0, inputNode.Format, inputNode.Palette);

                    }

                    int stride = ((inputNode.PixelWidth * inputNode.Format.BitsPerPixel) + 7) / 8;

                    int num5 = stride * pixelHeight;

                    byte[] pixels = new byte[num5];

                    frame.CopyPixels(sourceRect, pixels, stride, 0);

                    frame = null;

                    sourceRect.Y = 0;

                    this.bitmap.WritePixels(sourceRect, pixels, stride, 0);

                    inputNode.InputSource = this.bitmap;

                    inputNode.Format = this.bitmap.Format;

                    inputNode.Palette = this.bitmap.Palette;

                    GC.Collect(2);

                    GC.Collect(2);

                }

                if (this.InputCompleted != null)

                {

                    this.InputCompleted(this, streamEventArgs);

                }

            }

            return inputNode.InputSource;

        }

        [FileIOPermission(SecurityAction.LinkDemand)]

        public void Execute()

        {

            Debug.WriteLine("Inputs:" + this.inputs.Count);

            Debug.WriteLine("Outputs:" + this.outputs.Count);

            int num = 0;

            foreach (OutputNode node in this.outputs)

            {

                this.CloseOutputImpl(node);

                num++;

                if ((num % 30) == 0)

                {

                    GC.Collect(2);

                }

            }

            this.outputs.Clear();

            Debug.WriteLine("Single Outputs written:" + this.totalSingle);

            Debug.WriteLine("Composite Outputs written:" + this.totalComposite);

            Debug.WriteLine("Blank Outputs written:" + this.totalBlank);

        }

        public Point GetDpi(string fileName)

        {

            Int32Rect rectNeeded = new Int32Rect(0, 0, 0, 0);

            BitmapSource source = this.CreateInputFrame(this.inputs[fileName], rectNeeded);

            return new Point(source.DpiX, source.DpiY);

        }

        private BitmapEncoder GetEncoder(OutputNode outputNode, out PixelFormat pixelFormat, out string mimeType)

        {

            pixelFormat = this.ChoosePixelFormat(outputNode.Format);

            switch (outputNode.Format)

            {

                case ImageFormat.Jpg:

                    {

                        JpegBitmapEncoder encoder = new JpegBitmapEncoder

                        {

                            QualityLevel = 1 + ((int)Math.Round((double)(outputNode.Quality * 99.0)))

                        };

                        mimeType = "image/jpeg";

                        return encoder;

                    }

                case ImageFormat.Png:

                    mimeType = "image/png";

                    return new PngBitmapEncoder();

                case ImageFormat.Wdp:

                    {

                        WmpBitmapEncoder encoder2 = new WmpBitmapEncoder

                        {

                            QualityLevel = (byte)Math.Round((double)(105.0 - (outputNode.Quality * 100.0)))

                        };

                        if (outputNode.Quality == 1.0)

                        {

                            encoder2.QualityLevel = 1;

                        }

                        encoder2.OverlapLevel = 0;

                        encoder2.InterleavedAlpha = true;

                        encoder2.UseCodecOptions = true;

                        mimeType = "image/vnd.ms-photo";

                        return encoder2;

                    }

            }

            pixelFormat = PixelFormats.Default;

            mimeType = "";

            return null;

        }

        public PixelFormat GetPixelFormat(string fileName)

        {

            Int32Rect rectNeeded = new Int32Rect(0, 0, 0, 0);

            return this.CreateInputFrame(this.inputs[fileName], rectNeeded).Format;

        }

        public Point GetPixelSize(string fileName)

        {

            Int32Rect rectNeeded = new Int32Rect(0, 0, 0, 0);

            InputNode inputNode = this.inputs[fileName];

            this.CreateInputFrame(inputNode, rectNeeded);

            return new Point((double)inputNode.PixelWidth, (double)inputNode.PixelHeight);

        }

        public static Rect Int32RectToRect(Int32Rect r)

        {

            if (r.IsEmpty)

            {

                return Rect.Empty;

            }

            return new Rect((double)r.X, (double)r.Y, (double)r.Width, (double)r.Height);

        }

        private static bool IsFormatOpaque(PixelFormat pixelFormat)

        {

            return ((((((pixelFormat == PixelFormats.Bgr101010) || (pixelFormat == PixelFormats.Bgr24)) || ((pixelFormat == PixelFormats.Bgr32) || (pixelFormat == PixelFormats.Bgr555))) || (((pixelFormat == PixelFormats.Bgr565) || (pixelFormat == PixelFormats.BlackWhite)) || ((pixelFormat == PixelFormats.Cmyk32) || (pixelFormat == PixelFormats.Gray16)))) || ((((pixelFormat == PixelFormats.Gray2) || (pixelFormat == PixelFormats.Gray32Float)) || ((pixelFormat == PixelFormats.Gray4) || (pixelFormat == PixelFormats.Gray8))) || ((pixelFormat == PixelFormats.Rgb128Float) || (pixelFormat == PixelFormats.Rgb24)))) || (pixelFormat == PixelFormats.Rgb48));

        }

        public bool IsOpaque(string fileName)

        {

            return IsFormatOpaque(this.GetPixelFormat(fileName));

        }

        private static bool RectEqualWithTolerance(Rect a, Rect b)

        {

            return ((a == b) || ((((Math.Abs((double)(a.X - b.X)) < 1E-10) && (Math.Abs((double)(a.Y - b.Y)) < 1E-10)) && (Math.Abs((double)(a.Width - b.Width)) < 1E-10)) && (Math.Abs((double)(a.Height - b.Height)) < 1E-10)));

        }

        public static Int32Rect RectToInt32Rect(Rect r)

        {

            int x = (int)Math.Round(r.X);

            int y = (int)Math.Round(r.Y);

            int width = ((int)Math.Round(r.Right)) - x;

            return new Int32Rect(x, y, width, ((int)Math.Round(r.Bottom)) - y);

        }

        private static BitmapSource ScaleAndCropBitmap(ref Rect outputRect, ref Int32Rect inputRect, BitmapSource inputSource)

        {

            bool flag = (Math.Round(outputRect.Width) != inputRect.Width) || (Math.Round(outputRect.Height) != inputRect.Height);

            bool flag2 = (((inputRect.X != 0) || (inputRect.Y != 0)) || (inputRect.Width != inputSource.PixelWidth)) || (inputRect.Height != inputSource.PixelHeight);

            BitmapSource source = inputSource;

            if (flag2)

            {

                source = new CroppedBitmap(source, inputRect);

            }

            if (flag)

            {

                ScaleTransform newTransform = new ScaleTransform(outputRect.Width / ((double)inputRect.Width), outputRect.Height / ((double)inputRect.Height));

                source = new TransformedBitmap(source, newTransform);

            }

            return source;

        }

        internal static bool StraightenFrame(ref BitmapSource frame)

        {

            bool flag = false;

            BitmapMetadata metadata = (BitmapMetadata)frame.Metadata;

            if ((metadata != null) && metadata.ContainsQuery("/app1/ifd/exif:{uint=274}"))

            {

                int angle = 0;

                object query = metadata.GetQuery("/app1/ifd/exif:{uint=274}");

                if (query.GetType() == typeof(ushort))

                {

                    switch (((ushort)query))

                    {

                        case 6:

                            angle = 90;

                            break;

                        case 8:

                            angle = 270;

                            break;

                        case 3:

                            angle = 180;

                            break;

                    }

                }

                if (angle != 0)

                {

                    RotateTransform newTransform = new RotateTransform(angle, ((double)frame.PixelWidth) / 2.0, ((double)frame.PixelHeight) / 2.0);

                    BitmapSource source = new TransformedBitmap(frame, newTransform);

                    BitmapMetadata metadata2 = metadata.Clone();

                    metadata2.SetQuery("/app1/ifd/exif:{uint=274}", (ushort)1);

                    switch (angle)

                    {

                        case 90:

                        case 270:

                            {

                                flag = true;

                                object obj3 = null;

                                object obj4 = null;

                                if (metadata2.ContainsQuery("/app1/ifd/exif:{uint=282}"))

                                {

                                    obj3 = metadata2.GetQuery("/app1/ifd/exif:{uint=282}");

                                }

                                if (metadata2.ContainsQuery("/app1/ifd/exif:{uint=283}"))

                                {

                                    obj4 = metadata2.GetQuery("/app1/ifd/exif:{uint=283}");

                                }

                                if (obj3 != null)

                                {

                                    metadata2.SetQuery("/app1/ifd/exif:{uint=283}", obj3);

                                }

                                else

                                {

                                    metadata2.RemoveQuery("/app1/ifd/exif:{uint=283}");

                                }

                                if (obj4 != null)

                                {

                                    metadata2.SetQuery("/app1/ifd/exif:{uint=282}", obj4);

                                }

                                else

                                {

                                    metadata2.RemoveQuery("/app1/ifd/exif:{uint=282}");

                                }

                                object obj5 = null;

                                object obj6 = null;

                                if (metadata2.ContainsQuery("/app1/ifd/exif/subifd:{uint=40962}"))

                                {

                                    obj5 = metadata2.GetQuery("/app1/ifd/exif/subifd:{uint=40962}");

                                }

                                if (metadata2.ContainsQuery("/app1/ifd/exif/subifd:{uint=40963}"))

                                {

                                    obj6 = metadata2.GetQuery("/app1/ifd/exif/subifd:{uint=40963}");

                                }

                                if (obj5 != null)

                                {

                                    metadata2.SetQuery("/app1/ifd/exif/subifd:{uint=40963}", obj5);

                                }

                                else

                                {

                                    metadata2.RemoveQuery("/app1/ifd/exif/subifd:{uint=40963}");

                                }

                                if (obj6 != null)

                                {

                                    metadata2.SetQuery("/app1/ifd/exif/subifd:{uint=40962}", obj6);

                                }

                                else

                                {

                                    metadata2.RemoveQuery("/app1/ifd/exif/subifd:{uint=40962}");

                                }

                                break;

                            }

                    }

                    frame = source;

                }

            }

            return flag;

        }

        // Properties

        public bool CopyMetadata { get; set; }

        public bool KeepImagesInCache { get; set; }

        public int LargeFile

        {

            get

            {

                return this.largeFile;

            }

            set

            {

                this.largeFile = value;

            }

        }

        public bool OutputAlpha { get; set; }

        public bool StripingEnabled { get; set; }

        // Nested Types

        private class CachedFrameCollection : KeyedCollection<string, CachedFrame>

        {

            // Methods

            protected override string GetKeyForItem(CachedFrame item)

            {

                return item.path;

            }

        }

        private class InputNode

        {

            // Fields

            private string fileName;

            private int firstScanLineLoaded;

            private int lastScanLineLoaded;

            // Methods

            public InputNode(string fileName)

            {

                this.fileName = fileName;

                this.PixelHeight = 0;

                this.PixelWidth = 0;

                this.firstScanLineLoaded = 0;

                this.lastScanLineLoaded = 0;

                this.Format = PixelFormats.Default;

                this.Palette = null;

            }

            // Properties

            public string FileName

            {

                get

                {

                    return this.fileName;

                }

            }

            public int FirstScanLineLoaded

            {

                get

                {

                    return this.firstScanLineLoaded;

                }

                set

                {

                    this.firstScanLineLoaded = value;

                }

            }

            public PixelFormat Format { get; set; }

            public BitmapSource InputSource { get; set; }

            public int LastScanLineLoaded

            {

                get

                {

                    return this.lastScanLineLoaded;

                }

                set

                {

                    this.lastScanLineLoaded = value;

                }

            }

            public BitmapPalette Palette { get; set; }

            public int PixelHeight { get; set; }

            public int PixelWidth { get; set; }

        }

        private class InputNodeCollection : KeyedCollection<string, BitmapTransformer.InputNode>

        {

            // Methods

            protected override string GetKeyForItem(BitmapTransformer.InputNode item)

            {

                return item.FileName;

            }

        }

        private class OutputNode

        {

            // Fields

            private Color backgroundColor;

            public bool CacheFrame;

            private string fileName;

            private ImageFormat format;

            private int height;

            private double quality;

            private List<BitmapTransformer.TransformationNode> transforms;

            private int width;

            // Methods

            public OutputNode(string fileName)

            {

                this.fileName = fileName;

                this.transforms = new List<BitmapTransformer.TransformationNode>();

                this.CacheFrame = false;

            }

            // Properties

            public Color BackgroundColor

            {

                get

                {

                    return this.backgroundColor;

                }

                set

                {

                    this.backgroundColor = value;

                }

            }

            public string FileName

            {

                get

                {

                    return this.fileName;

                }

            }

            public ImageFormat Format

            {

                get

                {

                    return this.format;

                }

                set

                {

                    this.format = value;

                }

            }

            public int Height

            {

                get

                {

                    return this.height;

                }

                set

                {

                    Debug.Assert(value > 0, "Height must be greater than 0.");

                    this.height = value;

                }

            }

            public double Quality

            {

                get

                {

                    return this.quality;

                }

                set

                {

                    Debug.Assert((value >= 0.0) && (value <= 1.0), "Quality must be between 0 and 1.");

                    this.quality = value;

                }

            }

            public List<BitmapTransformer.TransformationNode> Transforms

            {

                get

                {

                    return this.transforms;

                }

            }

            public int Width

            {

                get

                {

                    return this.width;

                }

                set

                {

                    Debug.Assert(value > 0, "Width must be greater than 0.");

                    this.width = value;

                }

            }

        }

        private class OutputNodeCollection : KeyedCollection<string, BitmapTransformer.OutputNode>

        {

            // Methods

            protected override string GetKeyForItem(BitmapTransformer.OutputNode item)

            {

                return item.FileName;

            }

        }

        private class TransformationNode

        {

            // Fields

            private string input;

            private Int32Rect inputRect;

            private Rect outputRect;

            // Properties

            public string Input

            {

                get

                {

                    return this.input;

                }

                set

                {

                    this.input = value;

                }

            }

            public Int32Rect InputRect

            {

                get

                {

                    return this.inputRect;

                }

                set

                {

                    this.inputRect = value;

                }

            }

            public Rect OutputRect

            {

                get

                {

                    return this.outputRect;

                }

                set

                {

                    this.outputRect = value;

                }

            }

        }

    }

}