示例#1
0
        private void LoaderThreadThumbnails()
        {
            do
            {
                _loaderThreadThumbnailEvent.WaitOne();

                LoadImageRequest loadTask = null;

                do
                {
                    lock (_loadThumbnailStack)
                    {
                        loadTask = _loadThumbnailStack.Count > 0 ? _loadThumbnailStack.Pop() : null;
                    }

                    if (loadTask != null && !loadTask.IsCanceled)
                    {
                        var bitmapSource = GetBitmapSource(loadTask);

                        EndLoading(loadTask.Image, bitmapSource, loadTask, false);

                        lock (_loadNormalStack)
                        {
                            _loadNormalStack.Push(loadTask);
                        }

                        _loaderThreadNormalSizeEvent.Set();
                    }
                }while(loadTask != null);
            }while(true);
        }
示例#2
0
        private void BeginLoading(Image image, LoadImageRequest loadTask)
        {
            lock (_imagesLastRunningTask)
            {
                if (_imagesLastRunningTask.ContainsKey(image))
                {
                    _imagesLastRunningTask[image].IsCanceled = true;
                    _imagesLastRunningTask[image]            = loadTask;
                }
                else
                {
                    _imagesLastRunningTask.Add(image, loadTask);
                }
            }

            image.Dispatcher.BeginInvoke(new ThreadStart(delegate
            {
                Loader.SetIsLoading(image, true);

                if (image.RenderTransform == Transform.Identity)
                {
                    if (Loader.GetDisplayWaitingAnimationDuringLoading(image))
                    {
                        image.Source = _loadingImage;
                        image.RenderTransformOrigin = new Point(0.5, 0.5);
                        image.RenderTransform       = _loadingAnimationTransform;
                    }
                }
            }));
        }
示例#3
0
        public void LoadImage(string source, Image image)
        {
            var loadTask = new LoadImageRequest {
                Image = image, Source = source
            };

            BeginLoading(image, loadTask);

            lock (_loadThumbnailStack)
            {
                _loadThumbnailStack.Push(loadTask);
            }

            _loaderThreadThumbnailEvent.Set();
        }
示例#4
0
        private void EndLoading(Image image, ImageSource imageSource, LoadImageRequest loadTask, bool markAsFinished)
        {
            lock (_imagesLastRunningTask)
            {
                if (_imagesLastRunningTask.ContainsKey(image))
                {
                    if (_imagesLastRunningTask[image].Source != loadTask.Source)
                    {
                        return;
                    }

                    if (markAsFinished)
                    {
                        _imagesLastRunningTask.Remove(image);
                    }
                }
                else
                {
                    Debug.WriteLine("EndLoading() - unexpected condition: there is no running task for this image!");
                }

                image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                {
                    if (image.RenderTransform == _loadingAnimationTransform)
                    {
                        image.RenderTransform = Transform.Identity;
                    }

                    if (Loader.GetErrorDetected(image) && Loader.GetDisplayErrorThumbnailOnError(image))
                    {
                        imageSource = _errorThumbnail;
                    }

                    image.Source = imageSource;

                    if (markAsFinished)
                    {
                        Loader.SetIsLoading(image, false);
                    }
                }));
            }
        }
示例#5
0
        public void LoadImage(Image image)
        {
            LoadImageRequest loadTask = new LoadImageRequest()
            {
                Image = image,
                SourceUri = image.SourceUri
            };

            BeginLoading(image);

            _loadQueue.Push(loadTask);

            _loaderThreadEvent.Set();
        }
示例#6
0
        private ImageSource GetBitmapSource(LoadImageRequest loadTask)
        {
            Image image = loadTask.Image;
            string sourceUri = loadTask.SourceUri;

            if (string.IsNullOrWhiteSpace(sourceUri))
            {
                SetError(image);
                return null;
            }

            double width = double.NaN;
            double height = double.NaN;

            image.Dispatcher.Invoke(new ThreadStart(delegate
            {
                width = image.Width;
                height = image.Height;
            }));

            string cacheKey = ComputeHash(sourceUri);

            byte[] byteImage = _cache.Get(cacheKey) as byte[];

            if (byteImage == null)
            {
                byteImage = LoaderFactory.CreateLoader(sourceUri).Load();

                if (byteImage != null)
                {
                    try
                    {
                        _cache.Set(
                            cacheKey,
                            byteImage,
                            new CacheItemPolicy() {
                                SlidingExpiration = new TimeSpan(0, 0, ItemCacheExpirationMinutes, 0, 0)
                            }
                        );
                    }
                    catch
                    {

                    }
                }
            }

            if (byteImage == null)
            {
                SetError(image);
                return null;
            }

            try
            {
                using (MemoryStream memStream = new MemoryStream(byteImage))
                {
                    BitmapImage bitmapImage = new BitmapImage();
                    bitmapImage.BeginInit();
                    bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
                    if (!double.IsNaN(width) && !double.IsNaN(height))
                    {
                        bitmapImage.DecodePixelWidth = (int)width;
                        bitmapImage.DecodePixelHeight = (int)height;
                    }
                    bitmapImage.StreamSource = memStream;
                    bitmapImage.EndInit();

                    bitmapImage.Freeze();

                    return bitmapImage;
                }
            }
            catch
            {
                SetError(image);
                return null;
            }
        }
示例#7
0
        public void LoadImage(string source, Image image)
        {
            LoadImageRequest loadTask = new LoadImageRequest() { Image = image, Source = source };

            // Begin Loading
            BeginLoading(image, loadTask);

            lock (_loadThumbnailStack)
            {
                _loadThumbnailStack.Push(loadTask);
            }

            _loaderThreadThumbnailEvent.Set();
        }
示例#8
0
        private ImageSource GetBitmapSource(LoadImageRequest loadTask, DisplayOptions loadType)
        {
            Image image = loadTask.Image;
            string source = loadTask.Source;

            ImageSource imageSource = null;

            if (!string.IsNullOrWhiteSpace(source))
            {
                Stream imageStream = null;

                SourceType sourceType = SourceType.LocalDisk;

                image.Dispatcher.Invoke(new ThreadStart(delegate
                {
                    sourceType = Loader.GetSourceType(image);
                }));

                try
                {
                    if (loadTask.Stream == null)
                    {
                        ILoader loader = LoaderFactory.CreateLoader(sourceType);
                        imageStream = loader.Load(source);
                        loadTask.Stream = imageStream;
                    }
                    else
                    {
                        imageStream = new MemoryStream();
                        loadTask.Stream.Position = 0;
                        loadTask.Stream.CopyTo(imageStream);
                        imageStream.Position = 0;
                    }
                }
                catch (Exception) { }

                if (imageStream != null)
                {
                    try
                    {
                        if (loadType == DisplayOptions.Preview)
                        {
                            BitmapFrame bitmapFrame = BitmapFrame.Create(imageStream);
                            imageSource = bitmapFrame.Thumbnail;

                            if (imageSource == null) // Preview it is not embedded into the file
                            {
                                // we'll make a thumbnail image then ... (too bad as the pre-created one is FAST!)
                                TransformedBitmap thumbnail = new TransformedBitmap();
                                thumbnail.BeginInit();
                                thumbnail.Source = bitmapFrame as BitmapSource;

                                // we'll make a reasonable sized thumnbail with a height of 240
                                int pixelH = bitmapFrame.PixelHeight;
                                int pixelW = bitmapFrame.PixelWidth;
                                int decodeH = 240;
                                int decodeW = (bitmapFrame.PixelWidth * decodeH) / pixelH;
                                double scaleX = decodeW / (double)pixelW;
                                double scaleY = decodeH / (double)pixelH;
                                TransformGroup transformGroup = new TransformGroup();
                                transformGroup.Children.Add(new ScaleTransform(scaleX, scaleY));
                                thumbnail.Transform = transformGroup;
                                thumbnail.EndInit();

                                // this will disconnect the stream from the image completely ...
                                WriteableBitmap writable = new WriteableBitmap(thumbnail);
                                writable.Freeze();
                                imageSource = writable;
                            }
                        }
                        else if (loadType == DisplayOptions.FullResolution)
                        {
                            BitmapImage bitmapImage = new BitmapImage();
                            bitmapImage.BeginInit();
                            bitmapImage.StreamSource = imageStream;
                            bitmapImage.EndInit();
                            imageSource = bitmapImage;
                        }
                    }
                    catch (Exception) { }
                }

                if (imageSource == null)
                {
                    image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                    {
                        Loader.SetErrorDetected(image, true);
                    }));
                }
                else
                {
                    imageSource.Freeze();

                    image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                    {
                        Loader.SetErrorDetected(image, false);
                    }));
                }
            }
            else
            {
                image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                {
                    Loader.SetErrorDetected(image, false);
                }));
            }

            return imageSource;
        }
示例#9
0
        private void EndLoading(Image image, ImageSource imageSource, LoadImageRequest loadTask, bool markAsFinished)
        {
            lock (_imagesLastRunningTask)
            {
                if (_imagesLastRunningTask.ContainsKey(image))
                {
                    if (_imagesLastRunningTask[image].Source != loadTask.Source)
                        return; // if the last launched task for this image is not this one, abort it!

                    if (markAsFinished)
                        _imagesLastRunningTask.Remove(image);
                }
                else
                {
                    /* ERROR! */
                    System.Diagnostics.Debug.WriteLine("EndLoading() - unexpected condition: there is no running task for this image!");
                }

                image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                {
                    if (image.RenderTransform == _loadingAnimationTransform)
                    {
                        image.RenderTransform = MatrixTransform.Identity;
                    }

                    if (Loader.GetErrorDetected(image) && Loader.GetDisplayErrorThumbnailOnError(image))
                    {
                        imageSource = _errorThumbnail;
                    }

                    image.Source = imageSource;

                    if (markAsFinished)
                    {
                        // Set IsLoading Pty
                        Loader.SetIsLoading(image, false);
                    }
                }));
            }
        }
示例#10
0
        private void BeginLoading(Image image, LoadImageRequest loadTask)
        {
            lock (_imagesLastRunningTask)
            {
                if (_imagesLastRunningTask.ContainsKey(image))
                { // Cancel previous loading...
                    _imagesLastRunningTask[image].IsCanceled = true;
                    _imagesLastRunningTask[image] = loadTask;
                }
                else
                {
                    _imagesLastRunningTask.Add(image, loadTask);
                }
            }

            image.Dispatcher.BeginInvoke(new ThreadStart(delegate
            {
                // Set IsLoading Pty
                Loader.SetIsLoading(image, true);

                if (image.RenderTransform == MatrixTransform.Identity) // Don't apply loading animation if image already has transform...
                {
                    // Manage Waiting Image Parameter
                    if (Loader.GetDisplayWaitingAnimationDuringLoading(image))
                    {
                        image.Source = _loadingImage;
                        image.RenderTransformOrigin = new Point(0.5, 0.5);
                        image.RenderTransform = _loadingAnimationTransform;
                    }
                }
            }));
        }
示例#11
0
文件: Manager.cs 项目: TNOCS/csTouch
        private ImageSource GetBitmapSource(LoadImageRequest loadTask, DisplayOptions loadType)
        {
            DisplayOptions lt = loadType;
            Image image = loadTask.Image;
            string source = loadTask.Source;
            string nSource = source;
            string cacheFile = Path.Combine(AppStateSettings.CacheFolder, "Media", nSource.GetSHA1Hash().ToString() + "s" + loadTask.CachHeight + ".png"); // REVIEW TODO: Used Path instead of String concat.

            if (File.Exists(cacheFile))
            {
                nSource = cacheFile;
                lt = DisplayOptions.FullResolution;
                //return new BitmapImage(new Uri("file://" + cacheFile));
            }

            ImageSource imageSource = null;

            if (!string.IsNullOrWhiteSpace(nSource))
            {
                Stream imageStream = null;

                SourceType sourceType = SourceType.LocalDisk;

                image.Dispatcher.Invoke(new ThreadStart(delegate
                {
                    sourceType = Loader.GetSourceType(image);
                }));


                try
                {
                    if (loadTask.Stream == null)
                    {
                        ILoader loader = LoaderFactory.CreateLoader(sourceType, nSource);
                        imageStream = loader.Load(nSource);
                        loadTask.Stream = imageStream;
                    }
                    else
                    {
                        imageStream = new MemoryStream();
                        loadTask.Stream.Position = 0;
                        loadTask.Stream.CopyTo(imageStream);
                        imageStream.Position = 0;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }

                if (imageStream != null)
                {
                    try
                    {
                        if (lt == DisplayOptions.Preview)
                        {
                            BitmapFrame bitmapFrame = BitmapFrame.Create(imageStream);
                            imageSource = bitmapFrame.Thumbnail;

                            if (imageSource == null) // Preview it is not embedded into the file
                            {
                                // we'll make a thumbnail image then ... (too bad as the pre-created one is FAST!)
                                TransformedBitmap thumbnail = new TransformedBitmap();
                                thumbnail.BeginInit();
                                thumbnail.Source = bitmapFrame as BitmapSource;

                                // we'll make a reasonable sized thumnbail with a height of 240
                                int pixelH = bitmapFrame.PixelHeight;
                                int pixelW = bitmapFrame.PixelWidth;
                                int decodeH = (int)loadTask.CachHeight;
                                int decodeW = (bitmapFrame.PixelWidth * decodeH) / pixelH;
                                double scaleX = decodeW / (double)pixelW;
                                double scaleY = decodeH / (double)pixelH;
                                TransformGroup transformGroup = new TransformGroup();
                                transformGroup.Children.Add(new ScaleTransform(scaleX, scaleY));
                                thumbnail.Transform = transformGroup;
                                thumbnail.EndInit();

                                // this will disconnect the stream from the image completely ...
                                WriteableBitmap writable = new WriteableBitmap(thumbnail);


                                BitmapFrame frame = BitmapFrame.Create(writable);
                                var encoder = new PngBitmapEncoder();
                                encoder.Frames.Add(frame);

                                using (var stream = File.Create(cacheFile))
                                {
                                    encoder.Save(stream);
                                }


                                writable.Freeze();
                                imageSource = writable;
                            }
                        }
                        else if (lt == DisplayOptions.FullResolution)
                        {
                            BitmapImage bitmapImage = new BitmapImage();
                            bitmapImage.BeginInit();
                            bitmapImage.StreamSource = imageStream;
                            bitmapImage.EndInit();
                            imageSource = bitmapImage;
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }
                }

                if (imageSource == null)
                {
                    image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                    {
                        Loader.SetErrorDetected(image, true);
                    }));
                }
                else
                {
                    imageSource.Freeze();

                    image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                    {
                        Loader.SetErrorDetected(image, false);
                    }));
                }
            }
            else
            {
                image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                {
                    Loader.SetErrorDetected(image, false);
                }));
            }

            return imageSource;
        }
示例#12
0
文件: Manager.cs 项目: TNOCS/csTouch
        public void LoadImage(object source, Image image, double cacheHeight)
        {
            if (source == null) return;
            var imageSource = source as ImageSource;
            if (imageSource != null)
            {
                image.Source = imageSource;
            }
            else
            {
                var loadTask = new LoadImageRequest
                {
                    Image = image,
                    Source = source.ToString(),
                    CachHeight = cacheHeight
                };

                // Begin Loading
                BeginLoading(image, loadTask);

                lock (_loadThumbnailStack)
                {
                    _loadThumbnailStack.Push(loadTask);
                }

                _loaderThreadThumbnailEvent.Set();
            }

        }
示例#13
0
        private ImageSource GetBitmapSource(LoadImageRequest loadTask, DisplayOptions loadType)
        {
            Image image = loadTask.Image;
            object source = loadTask.Source;
            ImageSource imageSource = null;

            if (source != null)
            {
                Stream imageStream = null;

                SourceType sourceType = SourceType.LocalDisk;

                image.Dispatcher.Invoke(new ThreadStart(delegate
                {
                    sourceType = Loader.GetSourceType(image);
                }));

                try
                {
                    if (loadType != DisplayOptions.VideoPreview)
                    {
                        if (loadTask.Stream == null)
                        {
                            ILoader loader = LoaderFactory.CreateLoader(sourceType);
                            imageStream = loader.Load(source);
                            loadTask.Stream = imageStream;
                        }
                        else
                        {
                            imageStream = new MemoryStream();
                            loadTask.Stream.Position = 0;
                            loadTask.Stream.CopyTo(imageStream);
                            imageStream.Position = 0;
                        }
                    }
                    else if (sourceType == SourceType.ZipFile)
                    {
                        throw new InvalidOperationException("Can't load video preview from zip file.");
                    }
                }
                catch (Exception) { }

                if (imageStream != null || loadType == DisplayOptions.VideoPreview)
                {
                    try
                    {
                        if (loadType == DisplayOptions.Preview)
                        {
                            BitmapFrame bitmapFrame = BitmapFrame.Create(imageStream);
                            int rotation = GetRotation(bitmapFrame.Metadata as BitmapMetadata);

                            if (bitmapFrame.Thumbnail != null)
                            {
                                BitmapSource src = bitmapFrame.Thumbnail;
                                // crop black bars if necessary
                                double ratio = (double)bitmapFrame.PixelWidth / bitmapFrame.PixelHeight;
                                double thumbRatio = (double)src.PixelWidth / src.PixelHeight;
                                if (Math.Abs(ratio - thumbRatio) >= 0.01)
                                {
                                    if (ratio > thumbRatio) // crop top/bottom
                                    {
                                        int newHeight = (int)(src.PixelWidth / ratio);
                                        int top = (src.PixelHeight - newHeight) / 2;
                                        src = new CroppedBitmap(src, new Int32Rect(0, top, src.PixelWidth, newHeight));
                                    }
                                    else // crop left/right
                                    {
                                        int newWidth = (int)(src.PixelHeight * ratio);
                                        int left = (src.PixelWidth - newWidth) / 2;
                                        src = new CroppedBitmap(src, new Int32Rect(left, 0, newWidth, src.PixelHeight));
                                    }
                                }

                                TransformedBitmap thumbnail = new TransformedBitmap();
                                thumbnail.BeginInit();
                                thumbnail.Source = src;
                                TransformGroup transformGroup = new TransformGroup();
                                // rotate according to metadata
                                transformGroup.Children.Add(new RotateTransform(rotation));
                                thumbnail.Transform = transformGroup;
                                thumbnail.EndInit();
                                imageSource = thumbnail;
                            }
                            else // Preview it is not embedded into the file
                            {
                                // we'll make a thumbnail image then ... (too bad as the pre-created one is FAST!)
                                TransformedBitmap thumbnail = new TransformedBitmap();
                                thumbnail.BeginInit();
                                thumbnail.Source = bitmapFrame as BitmapSource;

                                // we'll make a reasonable sized thumnbail with a height of 240
                                int pixelH = bitmapFrame.PixelHeight;
                                int pixelW = bitmapFrame.PixelWidth;
                                int decodeH = 240;
                                int decodeW = (pixelW * decodeH) / pixelH;
                                double scaleX = decodeW / (double)pixelW;
                                double scaleY = decodeH / (double)pixelH;
                                TransformGroup transformGroup = new TransformGroup();
                                transformGroup.Children.Add(new ScaleTransform(scaleX, scaleY));
                                transformGroup.Children.Add(new RotateTransform(rotation));
                                thumbnail.Transform = transformGroup;
                                thumbnail.EndInit();

                                // this will disconnect the stream from the image completely ...
                                WriteableBitmap writable = new WriteableBitmap(thumbnail);
                                writable.Freeze();
                                imageSource = writable;
                            }
                        }
                        else if (loadType == DisplayOptions.Combined || loadType == DisplayOptions.FullResolution)
                        {
                            BitmapFrame bitmapFrame = BitmapFrame.Create(imageStream);
                            int rotation = GetRotation(bitmapFrame.Metadata as BitmapMetadata);

                            TransformedBitmap bitmapImage = new TransformedBitmap();
                            bitmapImage.BeginInit();
                            bitmapImage.Source = bitmapFrame as BitmapSource;
                            TransformGroup transformGroup = new TransformGroup();
                            transformGroup.Children.Add(new RotateTransform(rotation));
                            bitmapImage.Transform = transformGroup;
                            bitmapImage.EndInit();

                            WriteableBitmap writable = new WriteableBitmap(bitmapImage);
                            writable.Freeze();

                            imageSource = writable;
                        }
                        else if (loadType == DisplayOptions.VideoPreview)
                        {
                            var player = new MediaPlayer { Volume = 0, ScrubbingEnabled = true };

                            Uri uri;
                            if (loadTask.Source is string)
                                uri = new Uri(loadTask.Source as string);
                            else if (loadTask.Source is Uri)
                                uri = loadTask.Source as Uri;
                            else
                                throw new InvalidOperationException();

                            player.Open(uri);
                            player.Pause();
                            player.Position = new TimeSpan(0, 0, 20); // go to 20 seconds (if the video is shorter, a black image will be captured)

                            Thread.Sleep(1000);

                            int i = 0;
                            while (i < 10 && (player.NaturalDuration.TimeSpan.TotalSeconds* player.BufferingProgress) <= 20)
                            {
                                Thread.Sleep(100);
                                i++;
                            }

                            var pixelW = player.NaturalVideoWidth;
                            var pixelH = player.NaturalVideoHeight;

                            int decodeH = 240;
                            int decodeW = (pixelW * decodeH) / pixelH;

                            var rtb = new RenderTargetBitmap(decodeW, decodeH, 96, 96, PixelFormats.Pbgra32);
                            DrawingVisual dv = new DrawingVisual();

                            using (DrawingContext dc = dv.RenderOpen())
                                dc.DrawVideo(player, new Rect(0, 0, decodeW, decodeH));

                            rtb.Render(dv);
                            imageSource = (ImageSource)BitmapFrame.Create(rtb).GetCurrentValueAsFrozen();
                            player.Close();
                        }
                    }
                    catch (Exception) { }
                }

                if (imageSource == null)
                {
                    image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                    {
                        Loader.SetErrorDetected(image, true);
                    }));
                }
                else
                {
                    imageSource.Freeze();

                    image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                    {
                        Loader.SetErrorDetected(image, false);
                    }));
                }
            }
            else
            {
                image.Dispatcher.BeginInvoke(new ThreadStart(delegate
                {
                    Loader.SetErrorDetected(image, false);
                }));
            }

            return imageSource;
        }
示例#14
0
        public void LoadImage(object source, Image image)
        {
            LoadImageRequest loadTask = new LoadImageRequest() { Image = image, Source = source };

            // Begin Loading
            BeginLoading(image, loadTask);

            lock (_loadThumbnailQueue)
            {
                _loadThumbnailQueue.Enqueue(loadTask);
            }

            _loaderThreadThumbnailEvent.Set();
        }
示例#15
0
        private ImageSource GetBitmapSource(LoadImageRequest loadTask)
        {
            var image  = loadTask.Image;
            var source = loadTask.Source;

            ImageSource imageSource = null;

            if (!string.IsNullOrWhiteSpace(source))
            {
                Stream imageStream = null;

                var sourceType = SourceType.LocalDisk;

                if (source.StartsWith("http"))
                {
                    sourceType = SourceType.ExternalResource;
                }
                //image.Dispatcher.Invoke(new ThreadStart(delegate { sourceType = Loader.GetSourceType(image); }));

                try
                {
                    if (loadTask.Stream == null)
                    {
                        var loader = LoaderFactory.CreateLoader(sourceType);
                        imageStream     = loader.Load(source);
                        loadTask.Stream = imageStream;
                    }
                    else
                    {
                        imageStream = new MemoryStream();
                        loadTask.Stream.Position = 0;
                        loadTask.Stream.CopyTo(imageStream);
                        imageStream.Position = 0;
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.Message);
                }

                if (imageStream != null)
                {
                    try
                    {
                        var bitmapImage = new BitmapImage();
                        bitmapImage.BeginInit();
                        bitmapImage.StreamSource = imageStream;
                        bitmapImage.EndInit();
                        imageSource = bitmapImage;
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.Message);
                    }
                }

                if (imageSource == null)
                {
                    image.Dispatcher.BeginInvoke(new ThreadStart(() => Loader.SetErrorDetected(image, true)));
                }
                else
                {
                    imageSource.Freeze();

                    image.Dispatcher.BeginInvoke(new ThreadStart(() => Loader.SetErrorDetected(image, false)));
                }
            }
            else
            {
                image.Dispatcher.BeginInvoke(new ThreadStart(() => Loader.SetErrorDetected(image, false)));
            }

            return(imageSource);
        }