internal static BitmapSource ApplyOrientation(BitmapSource bitmap, BitmapMetadata metadata)
{
if (metadata == null || !metadata.ContainsQuery("System.Photo.Orientation"))
return bitmap;
ushort orientation = (ushort)metadata.GetQuery("System.Photo.Orientation");
switch (orientation)
{
case 2: // flip horizontal
return new TransformedBitmap(bitmap, new ScaleTransform(-1, 1));
case 3: // rotate 180
return new TransformedBitmap(bitmap, new RotateTransform(-180));
case 4: // flip vertical
return new TransformedBitmap(bitmap, new ScaleTransform(1, -1));
case 5: // transpose
bitmap = new TransformedBitmap(bitmap, new ScaleTransform(1, -1));
goto case 8;
case 6: // rotate 270
return new TransformedBitmap(bitmap, new RotateTransform(-270));
case 7: // transverse
bitmap = new TransformedBitmap(bitmap, new ScaleTransform(-1, 1));
goto case 8;
case 8: // rotate 90
return new TransformedBitmap(bitmap, new RotateTransform(-90));
default:
return bitmap;
}
}
public void Shrink(string sourcePath)
{
Debug.Assert(!String.IsNullOrWhiteSpace(sourcePath));
BitmapDecoder decoder;
BitmapEncoder encoder;
GetBitmapDecoderEncoder(sourcePath, out decoder, out encoder);
if (decoder == null || encoder == null)
throw new ArgumentException("Image type is not supported.");
// NOTE: grab its first (and usually only) frame. Only TIFF and GIF images support multiple frames
var sourceFrame = decoder.Frames[0];
// Apply the transform
var transform = GetTransform(sourceFrame);
if (transform == null)
return;
var transformedBitmap = new TransformedBitmap(sourceFrame, transform);
// Create the destination frame
var thumbnail = sourceFrame.Thumbnail;
var metadata = sourceFrame.Metadata as BitmapMetadata;
var colorContexts = sourceFrame.ColorContexts;
var destinationFrame = BitmapFrame.Create(transformedBitmap, thumbnail, metadata, colorContexts);
encoder.Frames.Add(destinationFrame);
SaveResultToFile(sourcePath, encoder);
}
/// <summary>
/// Resizes the image presented by the <paramref name="imageData"/> to a <paramref name="newSize"/>.
/// </summary>
/// <param name="imageData">
/// The binary data of the image to resize.
/// </param>
/// <param name="newSize">
/// The size to which to resize the image.
/// </param>
/// <param name="keepAspectRatio">
/// A flag indicating whether to save original aspect ratio.
/// </param>
/// <returns>
/// The structure which contains binary data of resized image and the actial size of resized image depending on <paramref name="keepAspectRatio"/> value.
/// </returns>
/// <exception cref="InvalidOperationException">
/// An error occurred during resizing the image.
/// </exception>
public static Task<ImageInfo> ResizeAsync(this byte[] imageData, Size newSize, bool keepAspectRatio)
{
var result = new ImageInfo();
var image = imageData.ToBitmap();
var percentWidth = (double) newSize.Width/(double) image.PixelWidth;
var percentHeight = (double) newSize.Height/(double) image.PixelHeight;
ScaleTransform transform;
if (keepAspectRatio)
{
transform = percentWidth < percentHeight
? new ScaleTransform {ScaleX = percentWidth, ScaleY = percentWidth}
: new ScaleTransform {ScaleX = percentHeight, ScaleY = percentHeight};
}
else
{
transform = new ScaleTransform {ScaleX = percentWidth, ScaleY = percentHeight};
}
var resizedImage = new TransformedBitmap(image, transform);
using (var memoryStream = new MemoryStream())
{
var jpegEncoder = new JpegBitmapEncoder();
jpegEncoder.Frames.Add(BitmapFrame.Create(resizedImage));
jpegEncoder.Save(memoryStream);
result.Data = memoryStream.ToArray();
result.Size = new Size(resizedImage.PixelWidth, resizedImage.PixelHeight);
}
return Task.FromResult(result);
}
public bool TryGetBitmapTransform(string optionValue, IEnumerable<KeyValuePair<string, string>> settings, out Func<BitmapSource, BitmapSource> bitmapTransformerFunc)
{
var cropOriginFunc = GetCropPointFunc(GetSetting(settings, "cropOrigin", "center,center"));
var cropSize = GetCropSize(optionValue);
bitmapTransformerFunc = bitmapSource =>
{
double widthScale = cropSize.Width / bitmapSource.PixelWidth;
double heightScale = cropSize.Height / bitmapSource.PixelHeight;
double scale = Math.Max(widthScale, heightScale);
bitmapSource = new TransformedBitmap(bitmapSource, new ScaleTransform(scale, scale));
var cropOrigin = cropOriginFunc(bitmapSource);
var x = cropOrigin.X - (cropSize.Width / 2);
x = Math.Max(0, x);
x = Math.Min(x, bitmapSource.PixelWidth - cropSize.Width);
var y = cropOrigin.Y - (cropSize.Height / 2);
y = Math.Max(0, y);
y = Math.Min(y, bitmapSource.PixelHeight - cropSize.Height);
return new CroppedBitmap(bitmapSource, new Int32Rect((int)Math.Round(x), (int)Math.Round(y), (int)cropSize.Width, (int)cropSize.Height));
};
return true;
}
public void PageLoaded(object sender, RoutedEventArgs args)
{
// Create Image element.
Image rotated90 = new Image();
rotated90.Width = 150;
// Create the TransformedBitmap to use as the Image source.
TransformedBitmap tb = new TransformedBitmap();
// Create the source to use as the tb source.
BitmapImage bi = new BitmapImage();
bi.BeginInit();
bi.UriSource = new Uri(@"sampleImages/watermelon.jpg", UriKind.RelativeOrAbsolute);
bi.EndInit();
// Properties must be set between BeginInit and EndInit calls.
tb.BeginInit();
tb.Source = bi;
// Set image rotation.
RotateTransform transform = new RotateTransform(90);
tb.Transform = transform;
tb.EndInit();
// Set the Image source.
rotated90.Source = tb;
//Add Image to the UI
Grid.SetColumn(rotated90, 1);
Grid.SetRow(rotated90, 1);
transformedGrid.Children.Add(rotated90);
}
public static void DrawImage (this ConsoleBuffer @this, ImageSource imageSource, int x, int y, int width, int height)
{
var bmp = imageSource as BitmapSource;
if (bmp == null)
throw new ArgumentException("Only rendering of bitmap source is supported.");
@this.OffsetX(ref x).OffsetY(ref y);
int x1 = x, x2 = x + width, y1 = y, y2 = y + height;
if ([email protected](ref x1, ref y1, ref x2, ref y2))
return;
if (width != bmp.PixelWidth || height != bmp.PixelHeight)
bmp = new TransformedBitmap(bmp, new ScaleTransform((double)width / bmp.PixelWidth, (double)height / bmp.PixelHeight));
if (bmp.Format != PixelFormats.Indexed4)
bmp = new FormatConvertedBitmap(bmp, PixelFormats.Indexed4, BitmapPalettes.Halftone8Transparent, 0.5);
const int bitsPerPixel = 4;
int stride = 4 * (bmp.PixelWidth * bitsPerPixel + 31) / 32;
byte[] bytes = new byte[stride * bmp.PixelHeight];
bmp.CopyPixels(bytes, stride, 0);
for (int iy = y1, py = 0; iy < y2; iy++, py++) {
ConsoleChar[] charsLine = @this.GetLine(iy);
for (int ix = x1, px = 0; ix < x2; ix++, px++) {
int byteIndex = stride * py + px / 2;
int bitOffset = px % 2 == 0 ? 4 : 0;
SetColor(ref charsLine[ix], bmp.Palette, (bytes[byteIndex] >> bitOffset) & 0xF);
}
}
}
private TransformedBitmap GetTransformedBitmapFromUri(string uri)
{
var bitmap = new Bitmap(uri);
var requiredRotation = GetRotationFromImage(bitmap);
var bitmapImage = new BitmapImage(new Uri(uri));
var transform = new RotateTransform(requiredRotation);
var tb = new TransformedBitmap(bitmapImage, transform);
return tb;
}
private static byte[] ResizeImage(ImageFormat format, BitmapSource photo, double? width, double? height)
{
var scaleX = (width.GetValueOrDefault(photo.Width) / photo.Width);
var scaleY = (height.GetValueOrDefault(photo.Height) / photo.Height);
var target = new TransformedBitmap(photo, new ScaleTransform(scaleX, scaleY, 0, 0));
var targetFrame = BitmapFrame.Create(target);
return targetFrame.ToByteArray(format);
}
private void buttonRotate_Click(object sender, RoutedEventArgs e)
{
TransformedBitmap tb = new TransformedBitmap();
tb.BeginInit();
tb.Transform = new RotateTransform(90);
tb.Source = this.imageViewModel.LoadedBitmap;
tb.EndInit();
this.imageViewModel.LoadedBitmap = tb;
this.imageViewModel.ClearPositions();
}
/// <summary>
/// Converts a bitmap and returns the result.
/// </summary>
/// <param name="bitmap">The bitmap to convert.</param>
/// <returns>The result.</returns>
public BitmapSource Convert(BitmapSource bitmap)
{
BitmapSource result = bitmap;
if(bitmap.Format != _format)
result = new FormatConvertedBitmap(result, _format, null, 0);
if(Rotate != 0)
result = new TransformedBitmap(result, new RotateTransform(Rotate));
return result;
}
public static void TransformSave(BitmapSource bi, double scale, int quality, string filename)
{
var tr = new ScaleTransform(scale, scale);
TransformedBitmap tb = new TransformedBitmap(bi, tr);
//if (File.Exists(filename)) File.Delete(filename);
var stream = new FileStream(filename, FileMode.OpenOrCreate, FileAccess.Write);
JpegBitmapEncoder encoder = new System.Windows.Media.Imaging.JpegBitmapEncoder();
encoder.QualityLevel = quality;
encoder.Frames.Add(BitmapFrame.Create(tb));
encoder.Save(stream);
stream.Close();
}
public ShowMyFace()
{
Title = "Show My Face";
///******************************************************************
// 3���� ShowMyFace ����
//******************************************************************/
Uri uri = new Uri("http://www.charlespetzold.com/PetzoldTattoo.jpg");
//BitmapImage bitmap = new BitmapImage(uri);
//Image img = new Image();
//img.Source = bitmap;
//Content = img;
///******************************************************************
// p1245 BitmapImage �ڵ�
//******************************************************************/
Image rotated90 = new Image();
TransformedBitmap tb = new TransformedBitmap();
FormatConvertedBitmap fb = new FormatConvertedBitmap();
CroppedBitmap cb = new CroppedBitmap();
// Create the source to use as the tb source.
BitmapImage bi = new BitmapImage();
bi.BeginInit();
bi.UriSource = uri;
bi.EndInit();
//cb.BeginInit();
//cb.Source = bi;
//Int32Rect rect = new Int32Rect();
//rect.X = 220;
//rect.Y = 200;
//rect.Width = 120;
//rect.Height = 80;
//cb.SourceRect = rect;
//cb.EndInit();
fb.BeginInit();
fb.Source = bi;
fb.DestinationFormat = PixelFormats.Gray2;
fb.EndInit();
// Properties must be set between BeginInit and EndInit calls.
tb.BeginInit();
tb.Source = fb;
// Set image rotation.
tb.Transform = new RotateTransform(90);
tb.EndInit();
// Set the Image source.
rotated90.Source = tb;
Content = rotated90;
}
/// <summary>
/// Resizes the given Image
/// </summary>
/// <param name="source"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns></returns>
public static BitmapImage ResizeImage(BitmapImage source, int width, int height)
{
var target = new TransformedBitmap(
source,
new ScaleTransform(
width / source.Width * 96 / source.DpiX,
height / source.Height * 96 / source.DpiY,
0, 0));
var resizedFrame = BitmapFrame.Create(target);
return FrameToBitmap(resizedFrame);
}
public async Task EncodeColorAsync(byte[] colorData, BinaryWriter writer)
{
await Task.Run(() =>
{
var format = PixelFormats.Bgra32;
int stride = (int)this.Width * format.BitsPerPixel / 8;
var bmp = BitmapSource.Create(
this.Width,
this.Height,
96.0,
96.0,
format,
null,
colorData,
stride);
BitmapFrame frame;
if (this.Width != this.OutputWidth || this.Height != this.OutputHeight)
{
var transform = new ScaleTransform((double)this.OutputHeight / this.Height, (double)this.OutputHeight / this.Height);
var scaledbmp = new TransformedBitmap(bmp, transform);
frame = BitmapFrame.Create(scaledbmp);
}
else
{
frame = BitmapFrame.Create(bmp);
}
var encoder = new JpegBitmapEncoder()
{
QualityLevel = this.JpegQuality
};
encoder.Frames.Add(frame);
using (var jpegStream = new MemoryStream())
{
encoder.Save(jpegStream);
if (writer.BaseStream == null || writer.BaseStream.CanWrite == false)
return;
// Header
writer.Write(this.OutputWidth);
writer.Write(this.OutputHeight);
writer.Write((int)jpegStream.Length);
// Data
jpegStream.Position = 0;
jpegStream.CopyTo(writer.BaseStream);
}
});
}
public void DrawImage(Image image, float x, float y, float width, float height)
{
var src = image.ToWpf((int)Math.Max(width, height));
if ((imageInterpolation == Eto.Drawing.ImageInterpolation.High || imageInterpolation == Eto.Drawing.ImageInterpolation.Default) &&
(width != src.Width || height != src.Height))
{
// better image quality by using transformed bitmap, plus it is actually faster
src = new swmi.TransformedBitmap(
src,
new swm.ScaleTransform(width / src.Width * 96 / src.DpiX, height / src.Height * 96 / src.DpiY, 0, 0)
);
}
Control.DrawImage(src, new sw.Rect(x + inverseoffset, y + inverseoffset, width, height));
}
public async void Initialize()
{
_tempBitmapFile = await _page.GenerateThumbnail();
Uri uri = new Uri(_tempBitmapFile.FileName, UriKind.Absolute);
var image = new BitmapImage();
image.BeginInit();
image.CacheOption = BitmapCacheOption.OnLoad;
image.UriSource = uri;
image.EndInit();
TransformedBitmap transformed = new TransformedBitmap(image, new RotateTransform(0));
Image.Value = transformed;
IsGeneratingImage.Value = false;
}
private static BitmapFrame GetBitmapFrame(MemoryStream original, int width, int height, BitmapScalingMode mode)
{
BitmapDecoder photoDecoder = BitmapDecoder.Create(original, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None);
BitmapFrame photo = photoDecoder.Frames[0];
TransformedBitmap target = new TransformedBitmap(
photo,
new ScaleTransform(
width / photo.Width * 96 / photo.DpiX,
height / photo.Height * 96 / photo.DpiY,
0, 0));
BitmapFrame thumbnail = BitmapFrame.Create(target);
BitmapFrame newPhoto = Resize(thumbnail, width, height, mode);
return newPhoto;
}
public void DrawImage(Image image, float x, float y, float width, float height)
{
SetOffset(true);
var src = image.ToWpf((int)Math.Max(width, height));
if ((ImageInterpolation == ImageInterpolation.High || ImageInterpolation == ImageInterpolation.Default) &&
(width != src.Width || height != src.Height))
{
// better image quality by using transformed bitmap, plus it is actually faster
src = new swmi.TransformedBitmap(
src,
new swm.ScaleTransform(width / src.Width * 96 / src.DpiX, height / src.Height * 96 / src.DpiY, 0, 0)
);
}
Control.DrawImage(src, WpfExtensions.NormalizedRect(x, y, width, height));
}
public ScannedImagesModel RotateImage( int rotate )
{
var bitmap = GetBitmapImage();
var rotated = new TransformedBitmap();
rotated.BeginInit();
rotated.Source = bitmap;
var transform = new RotateTransform( rotate );
rotated.Transform = transform;
rotated.EndInit();
// get temporary file
var filename = PathUtility.GetTempFileName();
var landscape = ( rotate == 90 || rotate == 270 ) ? !Landscape : Landscape;
SaveImage( rotated, filename );
return new ScannedImagesModel( filename, landscape );
}
internal static void GenerateThumbnail(Stream image, string path)
{
BitmapFrame img = BitmapFrame.Create(image);
double scale = 300.0 / Math.Min(img.PixelHeight, img.PixelWidth);
TransformedBitmap scaled = new TransformedBitmap(img, new ScaleTransform(scale, scale));
int startX = (scaled.PixelWidth - 300) / 2;
int startY = (scaled.PixelHeight - 300) / 2;
CroppedBitmap cropped = new CroppedBitmap(scaled, new Int32Rect(startX, startY, 300, 300));
BitmapSource rotated = ApplyOrientation(cropped, img.Metadata as BitmapMetadata);
using (Stream t = File.Create(path))
{
JpegBitmapEncoder jpg = new JpegBitmapEncoder();
jpg.Frames.Add(BitmapFrame.Create(rotated));
jpg.Save(t);
}
}
public void ChoosePictureFromLibrary(int maxPixelDimension, int percentQuality, Action<Stream, string> pictureAvailable, Action assumeCancelled)
{
var filePicker = new OpenFileDialog();
filePicker.Filter = "Image Files (*.jpg, *.jpeg)|*.jpg;*.jpeg";
filePicker.Multiselect = false;
if (filePicker.ShowDialog() == true)
{
try
{
var bm = new Bitmap(filePicker.FileName);
if (bm != null)
{
int targetWidth;
int targetHeight;
MvxPictureDimensionHelper.TargetWidthAndHeight(maxPixelDimension, bm.Width, bm.Height, out targetWidth, out targetHeight);
var transformBM = new TransformedBitmap(ConvertBitmapInBitmapSource(bm), new ScaleTransform(targetWidth / (double)bm.Width, targetHeight / (double)bm.Height));
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.QualityLevel = percentQuality;
MemoryStream stream = new MemoryStream();
encoder.Frames.Add(BitmapFrame.Create(transformBM));
encoder.Save(stream);
stream.Position = 0;
pictureAvailable(stream, filePicker.FileName);
}
}
catch (ArgumentException)
{
assumeCancelled();
}
}
else
{
assumeCancelled();
}
}
private static async Task<ImageAndSource> DecreaseImage(string inputFile)
{
var newLenght = maxFileLenght * 3;
var initialLength = new FileInfo(inputFile).Length;
var initialImage = await FileToImage(inputFile).ConfigureAwait(false);
while (true)
{
using (var scaledImage = new MemoryStream())
{
var scale = Math.Sqrt((((double)newLenght) / initialLength));
var transformed = new TransformedBitmap(initialImage, new ScaleTransform(scale, scale));
transformed.Freeze();
var saver = new JpegBitmapEncoder();
saver.Frames.Add(BitmapFrame.Create(transformed));
saver.Save(scaledImage);
scaledImage.Seek(0, SeekOrigin.Begin);
newLenght = newLenght * 4 / 5;
if (scaledImage.Length < maxFileLenght)
{
return new ImageAndSource
{
image = transformed,
source = scaledImage.ToArray()
};
}
}
}
}
/// <summary>
/// i dont know why i had to do all this bs, and for some reason i can't use it without screwing everything up...
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
private static Bitmap GetThumbnail(string filePath)
{
ShellFile shellFile = ShellFile.FromFilePath(filePath);
BitmapSource bitmapSource = shellFile.Thumbnail.ExtraLargeBitmapSource;
double newWidthRatio = 64 / (double)bitmapSource.PixelWidth;
double newHeightRatio = ((64 * bitmapSource.PixelHeight) / (double)bitmapSource.PixelWidth) / (double)bitmapSource.PixelHeight;
System.Windows.Media.Imaging.BitmapSource transformedBitmapSource = new System.Windows.Media.Imaging.TransformedBitmap(
bitmapSource,
new System.Windows.Media.ScaleTransform(newWidthRatio, newHeightRatio));
int width = transformedBitmapSource.PixelWidth;
int height = transformedBitmapSource.PixelHeight;
int stride = width * ((transformedBitmapSource.Format.BitsPerPixel + 7) / 8);
byte[] bits = new byte[height * stride];
transformedBitmapSource.CopyPixels(bits, stride, 0);
unsafe
{
fixed(byte *pBits = bits)
{
IntPtr ptr = new IntPtr(pBits);
System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(
width,
height,
stride,
System.Drawing.Imaging.PixelFormat.Format32bppArgb,
ptr);
bitmap = new Bitmap(filePath);
return(bitmap);
}
}
}
public static Stream ResizeImage(byte[] image, int size)
{
using (var imageStream = new MemoryStream(image))
{
var bitmap = BitmapDecoder.Create(imageStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None).Frames[0];
int width = bitmap.Width > bitmap.Height ? size : (int)(bitmap.Width * size / bitmap.Height);
int height = bitmap.Width > bitmap.Height ? (int)(bitmap.Height * size / bitmap.Width) : size;
var transformedBitmap = new TransformedBitmap(bitmap, new ScaleTransform(width / bitmap.Width, height / bitmap.Height, 0, 0));
var resizedBitmap = BitmapFrame.Create(transformedBitmap);
var convertedBitmap = new FormatConvertedBitmap(resizedBitmap, PixelFormats.Bgra32, null, 0);
int stride = convertedBitmap.PixelWidth * (convertedBitmap.Format.BitsPerPixel / 8);
byte[] data = new byte[stride * convertedBitmap.PixelHeight];
convertedBitmap.CopyPixels(data, stride, 0);
var writeBitmap = new WriteableBitmap(size, size, convertedBitmap.DpiX, convertedBitmap.DpiY, PixelFormats.Bgra32, null);
writeBitmap.WritePixels(new Int32Rect(0, 0, convertedBitmap.PixelWidth, convertedBitmap.PixelHeight), data, stride, 0);
MemoryStream resizeStream = new MemoryStream();
PngBitmapEncoder decoder = new PngBitmapEncoder();
decoder.Frames.Add(BitmapFrame.Create(writeBitmap));
decoder.Save(resizeStream);
resizeStream.Position = 0;
return resizeStream;
}
}
private void handleFrameFn(object sender, FrameReadyEventArgs e)
{
// Int32Rect cropRect = new Int32Rect(400, 380, 300, 200);
// BitmapSource croppedImage = new CroppedBitmap(e.BitmapImage, cropRect);
// image4.Source = croppedImage;
if (_rotationAngle != 0)
{
TransformedBitmap tmpImage = new TransformedBitmap();
tmpImage.BeginInit();
tmpImage.Source = e.BitmapImage; // of type BitmapImage
RotateTransform transform = new RotateTransform(_rotationAngle);
tmpImage.Transform = transform;
tmpImage.EndInit();
_dispImage.Source = tmpImage;
}
else
{
_dispImage.Source = e.BitmapImage;
}
}
public static void writeImage(String outputPath, BitmapSource image, Dictionary<String, Object> options = null, ImageMetadata metaData = null, CancellableOperationProgressBase progress = null)
{
int width = image.PixelWidth;
int height = image.PixelHeight;
float scale = ImageUtils.resizeRectangle(width, height, Constants.MAX_THUMBNAIL_WIDTH, Constants.MAX_THUMBNAIL_HEIGHT);
TransformedBitmap thumbnail = new TransformedBitmap(image, new System.Windows.Media.ScaleTransform(scale, scale));
if (options != null)
{
if (options.ContainsKey("Width"))
{
width = (int)options["Width"];
if (!options.ContainsKey("Height"))
{
height = (int)(((float)width / image.PixelWidth) * image.PixelHeight);
}
}
if (options.ContainsKey("Height")) {
height = (int)options["Height"];
if (!options.ContainsKey("Width"))
{
width = (int)(((float)height / image.PixelHeight) * image.PixelWidth);
}
}
}
BitmapSource outImage = image;
if (width != image.PixelWidth || height != image.PixelHeight)
{
outImage = new TransformedBitmap(image, new System.Windows.Media.ScaleTransform((double)width / image.PixelWidth, (double)height / image.PixelHeight));
}
ImageFormat format = MediaFormatConvert.fileNameToImageFormat(outputPath);
BitmapEncoder encoder = null;
if (format == ImageFormat.Jpeg)
{
encoder = configureJpeg(options, ref thumbnail);
}
else if (format == ImageFormat.Png)
{
encoder = configurePng(options);
}
else if (format == ImageFormat.Gif)
{
encoder = new GifBitmapEncoder();
}
else if (format == ImageFormat.Bmp)
{
encoder = new BmpBitmapEncoder();
}
else if (format == ImageFormat.Tiff)
{
encoder = configureTiff(options);
}
encoder.Frames.Add(BitmapFrame.Create(outImage, thumbnail, null, null));
FileStream outputFile = new FileStream(outputPath, FileMode.Create);
encoder.Save(outputFile);
outputFile.Close();
if (metaData != null)
{
metaData.Location = outputPath;
ImageFileMetadataWriter metadataWriter = new ImageFileMetadataWriter();
metadataWriter.writeMetadata(metaData, progress);
}
}
static BitmapEncoder configureJpeg(Dictionary<String, Object> options, ref TransformedBitmap thumbnail)
{
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
if (options != null)
{
if (options.ContainsKey("QualityLevel"))
{
encoder.QualityLevel = (int)options["QualityLevel"];
}
if (options.ContainsKey("Rotation"))
{
encoder.Rotation = (Rotation)options["Rotation"];
if (encoder.Rotation != Rotation.Rotate0)
{
thumbnail = new TransformedBitmap(thumbnail, new System.Windows.Media.RotateTransform((int)encoder.Rotation * 90));
}
}
if (options.ContainsKey("FlipHorizontal"))
{
encoder.FlipHorizontal = (bool)options["FlipHorizontal"];
if (encoder.FlipHorizontal)
{
System.Windows.Media.Matrix transform = System.Windows.Media.Matrix.Identity;
transform.M11 *= -1;
thumbnail = new TransformedBitmap(thumbnail, new System.Windows.Media.MatrixTransform(transform));
}
}
if (options.ContainsKey("FlipVertical"))
{
encoder.FlipVertical = (bool)options["FlipVertical"];
if (encoder.FlipVertical)
{
System.Windows.Media.Matrix transform = System.Windows.Media.Matrix.Identity;
transform.M22 *= -1;
thumbnail = new TransformedBitmap(thumbnail, new System.Windows.Media.MatrixTransform(transform));
}
}
}
return (encoder);
}
/// <summary>
/// Scales the image to the specified size in either width or height, depending on which is closer.
/// </summary>
/// <param name="size">The size to scale towards</param>
/// <returns></returns>
public Stream ScaleImage(int size)
{
var rawStream = FileStream;
using (rawStream)
{
rawStream.Position = 0;
// Create bitmap decoder
var decoder = BitmapDecoder.Create(
rawStream,
BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.None);
// Decode single bitmap frame
var frame = decoder.Frames[0];
Double xRatio = frame.Width / size;
Double yRatio = frame.Height / size;
Double ratio = Math.Max(xRatio, yRatio);
int nnx = (int)Math.Floor(frame.Width / ratio);
int nny = (int)Math.Floor(frame.Height / ratio);
// Resize the bitmap frame
var resizedFrame = new TransformedBitmap(
frame,
new ScaleTransform(
nnx / frame.Width * 96 / frame.DpiX,
nny / frame.Height * 96 / frame.DpiY,
0, 0));
// Re-encode the bitmap to stream
var stream = new MemoryStream();
var encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(resizedFrame));
encoder.Save(stream);
stream.Position = 0;
rawStream.Dispose();
return stream;
}
}
public void Draw(ApplicationContext actx, SWM.DrawingContext dc, double scaleFactor, double x, double y, ImageDescription idesc)
{
if (drawCallback != null) {
DrawingContext c = new DrawingContext (dc, scaleFactor);
actx.InvokeUserCode (delegate {
drawCallback (c, new Rectangle (x, y, idesc.Size.Width, idesc.Size.Height), idesc, actx.Toolkit);
});
}
else {
if (idesc.Alpha < 1)
dc.PushOpacity (idesc.Alpha);
var f = GetBestFrame (actx, scaleFactor, idesc.Size.Width, idesc.Size.Height, false);
var bmpImage = f as BitmapSource;
// When an image is a single bitmap that doesn't have the same intrinsic size as the drawing size, dc.DrawImage makes a very poor job of down/up scaling it.
// Thus we handle this manually by using a TransformedBitmap to handle the conversion in a better way when it's needed.
var scaledWidth = idesc.Size.Width * scaleFactor;
var scaledHeight = idesc.Size.Height * scaleFactor;
if (bmpImage != null && (Math.Abs (bmpImage.PixelHeight - scaledHeight) > 0.001 || Math.Abs (bmpImage.PixelWidth - scaledWidth) > 0.001))
f = new TransformedBitmap (bmpImage, new ScaleTransform (scaledWidth / bmpImage.PixelWidth, scaledHeight / bmpImage.PixelHeight));
dc.DrawImage (f, new Rect (x, y, idesc.Size.Width, idesc.Size.Height));
if (idesc.Alpha < 1)
dc.Pop ();
}
}
private void ClonePostscript(TransformedBitmap otherTransformedBitmap)
{
EndInit();
}
private static BitmapFrame Rotate(BitmapFrame photo, double angle, BitmapScalingMode mode)
{
TransformedBitmap target = new TransformedBitmap(
photo,
new RotateTransform(angle, photo.PixelWidth / 2, photo.PixelHeight / 2));
BitmapFrame thumbnail = BitmapFrame.Create(target);
BitmapFrame newPhoto = Resize(thumbnail, photo.PixelWidth, photo.PixelHeight, mode);
return newPhoto;
}
public static BitmapFrame GetBitmapFrame(BitmapFrame photo, int width, int height, BitmapScalingMode mode)
{
TransformedBitmap target = new TransformedBitmap(
photo,
new ScaleTransform(
width / photo.Width * 96 / photo.DpiX,
height / photo.Height * 96 / photo.DpiY,
0, 0));
BitmapFrame thumbnail = BitmapFrame.Create(target);
BitmapFrame newPhoto = Resize(thumbnail, width, height, mode);
return newPhoto;
}
private void ClonePrequel(TransformedBitmap otherTransformedBitmap)
{
BeginInit();
}
/// <summary>
/// Creates a thumbnail of the specified image
/// </summary>
/// <param name="thumbnailImageSource">The source filename to load a System.Drawing.Image from</param>
/// <param name="thumbnailImageDest">Filename of the thumbnail to create</param>
/// <param name="aThumbWidth">Maximum width of the thumbnail</param>
/// <param name="aThumbHeight">Maximum height of the thumbnail</param>
/// <param name="autocreateLargeThumbs">Auto create large thumbnail</param>
/// <param name="iRotate">
/// 0 = no rotate
/// 1 = rotate 90 degrees
/// 2 = rotate 180 degrees
/// 3 = rotate 270 degrees
/// <param name="fallBack">Needed if generated file need to be delete (for ex in temp folder)</param>
/// </param>
/// <returns>Whether the thumb has been successfully created</returns>
public static bool CreateThumbnail(string thumbnailImageSource, string thumbnailImageDest, int aThumbWidth,
int aThumbHeight, int iRotate, bool aFastMode, bool autocreateLargeThumbs, bool fallBack)
{
if (File.Exists(thumbnailImageDest))
{
return false;
}
if (string.IsNullOrEmpty(thumbnailImageSource) || string.IsNullOrEmpty(thumbnailImageDest) || aThumbHeight <= 0 ||
aThumbHeight <= 0)
{
return false;
}
BitmapSource ret = null;
BitmapMetadata meta = null;
Bitmap shellThumb = null;
Bitmap myTargetThumb = null;
BitmapFrame frame = null;
Image myImage = null;
TransformedBitmap thumbnail = null;
TransformGroup transformGroup = null;
double angle = 0;
bool result = false;
int iQuality = (int) Thumbs.Quality;
int decodeW = aThumbWidth;
MediaUrl = thumbnailImageSource;
try
{
if (fallBack)
{
frame = BitmapFrame.Create(new Uri(MediaUrl), BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
}
else
{
//Try generate Bitmap frame : speedy and low memory !
frame = BitmapFrame.Create(new Uri(MediaUrl), BitmapCreateOptions.DelayCreation,
BitmapCacheOption.None);
}
if (frame.Thumbnail == null) //If it failed try second method (slower and use more memory)
{
using (ShellObject shellFile = ShellObject.FromParsingName(thumbnailImageSource))
{
shellFile.Thumbnail.RetrievalOption = ShellThumbnailRetrievalOption.Default;
shellFile.Thumbnail.FormatOption = ShellThumbnailFormatOption.ThumbnailOnly;
switch (iQuality)
{
case 0:
shellThumb = shellFile.Thumbnail.MediumBitmap;
break;
case 1:
shellThumb = shellFile.Thumbnail.LargeBitmap;
break;
case 2:
shellThumb = shellFile.Thumbnail.LargeBitmap;
break;
case 3:
shellThumb = shellFile.Thumbnail.ExtraLargeBitmap;
break;
case 4:
shellThumb = shellFile.Thumbnail.ExtraLargeBitmap;
break;
default:
break;
}
switch (iRotate)
{
case 1:
shellThumb.RotateFlip(RotateFlipType.Rotate90FlipNone);
break;
case 2:
shellThumb.RotateFlip(RotateFlipType.Rotate180FlipNone);
break;
case 3:
shellThumb.RotateFlip(RotateFlipType.Rotate270FlipNone);
break;
default:
break;
}
if (shellThumb != null && !autocreateLargeThumbs)
{
int iWidth = aThumbWidth;
int iHeight = aThumbHeight;
double fAR = (shellThumb.Width)/((float) shellThumb.Height);
if (shellThumb.Width > shellThumb.Height)
iHeight = (int) Math.Floor((((float) iWidth)/fAR));
else
iWidth = (int) Math.Floor((fAR*((float) iHeight)));
try
{
Util.Utils.FileDelete(thumbnailImageDest);
}
catch (Exception ex)
{
Log.Error("Picture: Error deleting old thumbnail - {0}", ex.Message);
}
// Write small thumbnail
myTargetThumb = new Bitmap(shellThumb, iWidth, iHeight);
myTargetThumb.Save(thumbnailImageDest, Thumbs.ThumbCodecInfo, Thumbs.ThumbEncoderParams);
File.SetAttributes(thumbnailImageDest, File.GetAttributes(thumbnailImageDest) | FileAttributes.Hidden);
result = true;
}
else
{
int iWidth = aThumbWidth;
int iHeight = aThumbHeight;
double fAR = (shellThumb.Width)/((float) shellThumb.Height);
if (shellThumb.Width > shellThumb.Height)
iHeight = (int) Math.Floor((((float) iWidth)/fAR));
else
iWidth = (int) Math.Floor((fAR*((float) iHeight)));
try
{
Util.Utils.FileDelete(thumbnailImageDest);
}
catch (Exception ex)
{
Log.Error("Picture: Error deleting old thumbnail - {0}", ex.Message);
}
// Write Large thumbnail
myTargetThumb = new Bitmap(shellThumb, iWidth, iHeight);
myTargetThumb.Save(thumbnailImageDest, Thumbs.ThumbCodecInfo, Thumbs.ThumbEncoderParams);
File.SetAttributes(thumbnailImageDest, File.GetAttributes(thumbnailImageDest) | FileAttributes.Hidden);
result = true;
}
}
}
else
{
//Detect metas image
meta = frame.Metadata as BitmapMetadata;
ret = frame.Thumbnail;
//if ((meta != null) && (ret != null)) //si on a des meta, tentative de récupération de l'orientation
//{
// if (meta.GetQuery("/app1/ifd/{ushort=274}") != null)
// {
// orientation =
// (ExifOrientations)
// Enum.Parse(typeof (ExifOrientations), meta.GetQuery("/app1/ifd/{ushort=274}").ToString());
// }
// switch (orientation)
// {
// case ExifOrientations.Rotate90:
// angle = -90;
// break;
// case ExifOrientations.Rotate180:
// angle = 180;
// break;
// case ExifOrientations.Rotate270:
// angle = 90;
// break;
// }
// if (angle != 0) //on doit effectuer une rotation de l'image
// {
// ret = new TransformedBitmap(ret.Clone(), new RotateTransform(angle));
// ret.Freeze();
// }
//}
if (autocreateLargeThumbs)
{
if (ret != null)
{
// we'll make a thumbnail image then ... (too bad as the pre-created one is FAST!)
thumbnail = new TransformedBitmap();
thumbnail.BeginInit();
thumbnail.Source = frame as BitmapSource;
// we'll make a reasonable sized thumnbail
int pixelH = frame.PixelHeight;
int pixelW = frame.PixelWidth;
int decodeH = (frame.PixelHeight*decodeW)/pixelW;
double scaleX = decodeW/(double) pixelW;
double scaleY = decodeH/(double) pixelH;
transformGroup = new TransformGroup();
transformGroup.Children.Add(new ScaleTransform(scaleX, scaleY));
thumbnail.Transform = transformGroup;
thumbnail.EndInit();
ret = thumbnail;
// Write Large thumbnail
result = BitmapFromSource(ret, thumbnailImageDest);
}
}
else
{
if (ret != null)
{
// Write small thumbnail
result = BitmapFromSource(ret, thumbnailImageDest);
}
}
}
}
catch (Exception ex)
{
try
{
try
{
myImage = ImageFast.FromFile(thumbnailImageSource);
}
catch (FileNotFoundException)
{
result = false;
}
result = CreateThumbnail(myImage, thumbnailImageDest, aThumbWidth, aThumbHeight, iRotate, aFastMode);
}
catch (Exception)
{
Log.Warn("Picture: Fast loading of thumbnail {0} failed - trying safe fallback now", thumbnailImageDest);
try
{
try
{
myImage = ImageFast.FromFile(thumbnailImageDest);
result = CreateThumbnail(myImage, thumbnailImageDest, aThumbWidth, aThumbHeight, iRotate, aFastMode);
}
catch (Exception)
{
myImage = Image.FromFile(thumbnailImageDest, true);
result = CreateThumbnail(myImage, thumbnailImageDest, aThumbWidth, aThumbHeight, iRotate, aFastMode);
}
}
catch (FileNotFoundException)
{
result = false;
}
catch (OutOfMemoryException)
{
Log.Warn("Picture: Creating thumbnail failed - image format is not supported of {0}", thumbnailImageSource);
result = false;
}
catch (Exception)
{
Log.Info("Pictures: No thumbnail created for -- {0}", thumbnailImageSource);
result = false;
}
}
}
finally
{
if (shellThumb != null)
shellThumb.SafeDispose();
if (ret != null)
ret.SafeDispose();
if (thumbnail != null)
thumbnail.SafeDispose();
if (transformGroup != null)
transformGroup.SafeDispose();
if (myTargetThumb != null)
myTargetThumb.SafeDispose();
if (MediaUrl != null)
MediaUrl.SafeDispose();
if (frame != null)
frame.SafeDispose();
if (myImage != null)
myImage.SafeDispose();
}
if (result && Util.Utils.IsFileExistsCacheEnabled())
{
Log.Debug("CreateThumbnail : FileExistsInCache updated with new file: {0}", thumbnailImageDest);
Util.Utils.DoInsertExistingFileIntoCache(thumbnailImageDest);
}
return result;
}
public static ImageData CreateFlipped(ImageMetaData info, PixelFormat format, BitmapPalette palette,
byte[] pixel_data, int stride)
{
var bitmap = BitmapSource.Create((int)info.Width, (int)info.Height, DefaultDpiX, DefaultDpiY,
format, palette, pixel_data, stride);
var flipped = new TransformedBitmap(bitmap, new ScaleTransform { ScaleY = -1 });
flipped.Freeze();
return new ImageData(flipped, info);
}
internal override void FinalizeCreation()
{
_bitmapInit.EnsureInitializedComplete();
Uri uri = UriSource;
if (_baseUri != null)
{
uri = new Uri(_baseUri, UriSource);
}
if ((CreateOptions & BitmapCreateOptions.IgnoreImageCache) != 0)
{
ImagingCache.RemoveFromImageCache(uri);
}
BitmapImage bitmapImage = CheckCache(uri);
if (bitmapImage != null &&
bitmapImage.CheckAccess() &&
bitmapImage.SourceRect.Equals(SourceRect) &&
bitmapImage.DecodePixelWidth == DecodePixelWidth &&
bitmapImage.DecodePixelHeight == DecodePixelHeight &&
bitmapImage.Rotation == Rotation &&
(bitmapImage.CreateOptions & BitmapCreateOptions.IgnoreColorProfile) ==
(CreateOptions & BitmapCreateOptions.IgnoreColorProfile)
)
{
_syncObject = bitmapImage.SyncObject;
lock (_syncObject)
{
WicSourceHandle = bitmapImage.WicSourceHandle;
IsSourceCached = bitmapImage.IsSourceCached;
_convertedDUCEPtr = bitmapImage._convertedDUCEPtr;
//
// We nee d to keep the strong reference to the cached image for a few reasons:
//
// The application may release the original cached image and then keep a
// reference to this image only, in which case, the cache can be collected.
// This will cause a few undesirable results:
// 1. The application may choose to decode the same URI again in which case
// we will not retrieve it from the cache even though we have a copy already
// decoded.
// 2. The original cached image holds onto the file stream indirectly which if
// collected can cause bad behavior if the entire image is not loaded into
// memory.
//
_cachedBitmapImage = bitmapImage;
}
UpdateCachedSettings();
return;
}
BitmapDecoder decoder = null;
if (_decoder == null)
{
// Note: We do not want to insert in the cache if there is a chance that
// the decode pixel width/height may cause the decoder LOD to change
decoder = BitmapDecoder.CreateFromUriOrStream(
_baseUri,
UriSource,
StreamSource,
CreateOptions & ~BitmapCreateOptions.DelayCreation,
BitmapCacheOption.None, // do not cache the frames since we will do that here
_uriCachePolicy,
false
);
if (decoder.IsDownloading)
{
_isDownloading = true;
_decoder = decoder;
decoder.DownloadProgress += OnDownloadProgress;
decoder.DownloadCompleted += OnDownloadCompleted;
decoder.DownloadFailed += OnDownloadFailed;
}
else
{
Debug.Assert(decoder.SyncObject != null);
}
}
else
{
// We already had a decoder, meaning we were downloading
Debug.Assert(!_decoder.IsDownloading);
decoder = _decoder;
_decoder = null;
}
if (decoder.Frames.Count == 0)
{
throw new System.ArgumentException(SR.Get(SRID.Image_NoDecodeFrames));
}
BitmapFrame frame = decoder.Frames[0];
BitmapSource source = frame;
Int32Rect sourceRect = SourceRect;
if (sourceRect.X == 0 && sourceRect.Y == 0 &&
sourceRect.Width == source.PixelWidth &&
sourceRect.Height == source.PixelHeight)
{
sourceRect = Int32Rect.Empty;
}
if (!sourceRect.IsEmpty)
{
CroppedBitmap croppedSource = new CroppedBitmap();
croppedSource.BeginInit();
croppedSource.Source = source;
croppedSource.SourceRect = sourceRect;
croppedSource.EndInit();
source = croppedSource;
if (_isDownloading)
{
// Unregister the download events because this is a dummy image. See comment below.
source.UnregisterDownloadEventSource();
}
}
int finalWidth = DecodePixelWidth;
int finalHeight = DecodePixelHeight;
if (finalWidth == 0 && finalHeight == 0)
{
finalWidth = source.PixelWidth;
finalHeight = source.PixelHeight;
}
else if (finalWidth == 0)
{
finalWidth = (source.PixelWidth * finalHeight) / source.PixelHeight;
}
else if (finalHeight == 0)
{
finalHeight = (source.PixelHeight * finalWidth) / source.PixelWidth;
}
if (finalWidth != source.PixelWidth || finalHeight != source.PixelHeight ||
Rotation != Rotation.Rotate0)
{
TransformedBitmap transformedSource = new TransformedBitmap();
transformedSource.BeginInit();
transformedSource.Source = source;
TransformGroup transformGroup = new TransformGroup();
if (finalWidth != source.PixelWidth || finalHeight != source.PixelHeight)
{
int oldWidth = source.PixelWidth;
int oldHeight = source.PixelHeight;
Debug.Assert(oldWidth > 0 && oldHeight > 0);
transformGroup.Children.Add(
new ScaleTransform(
(1.0 * finalWidth) / oldWidth,
(1.0 * finalHeight) / oldHeight));
}
if (Rotation != Rotation.Rotate0)
{
double rotation = 0.0;
switch (Rotation)
{
case Rotation.Rotate0:
rotation = 0.0;
break;
case Rotation.Rotate90:
rotation = 90.0;
break;
case Rotation.Rotate180:
rotation = 180.0;
break;
case Rotation.Rotate270:
rotation = 270.0;
break;
default:
Debug.Assert(false);
break;
}
transformGroup.Children.Add(new RotateTransform(rotation));
}
transformedSource.Transform = transformGroup;
transformedSource.EndInit();
source = transformedSource;
if (_isDownloading)
{
//
// If we're currently downloading, then the BitmapFrameDecode isn't actually
// the image, it's just a 1x1 placeholder. The chain we're currently building
// will be replaced with another chain once download completes, so there's no
// need to have this chain handle DownloadCompleted.
//
// Having this chain handle DownloadCompleted is actually a bad thing. Because
// the dummy is just 1x1, the TransformedBitmap we're building here will have
// a large scaling factor (to scale the image from 1x1 up to whatever
// DecodePixelWidth/Height specifies). When the TransformedBitmap receives
// DownloadCompleted from the BFD, it will call into WIC to create a new
// bitmap scaler using the same large scaling factor, which can produce a huge
// bitmap (since the BFD is now no longer 1x1). This problem is made worse if
// this BitmapImage has BitmapCacheOption.OnLoad, since that will put a
// CachedBitmap after the TransformedBitmap. When DownloadCompleted propagates
// from the TransformedBitmap down to the CachedBitmap, the CachedBitmap will
// call CreateBitmapFromSource using the TransformedBitmap, which calls
// CopyPixels on the huge TransformedBitmap. We want to avoid chewing up the
// CPU and the memory, so we unregister the download event handlers here.
//
source.UnregisterDownloadEventSource();
}
}
//
// If the original image has a color profile and IgnoreColorProfile is not one of the create options,
// apply the profile so bits are color-corrected.
//
if ((CreateOptions & BitmapCreateOptions.IgnoreColorProfile) == 0 &&
frame.ColorContexts != null &&
frame.ColorContexts[0] != null &&
frame.ColorContexts[0].IsValid &&
source.Format.Format != PixelFormatEnum.Extended
)
{
// NOTE: Never do this for a non-MIL pixel format, because the format converter has
// special knowledge to deal with the profile
PixelFormat duceFormat = BitmapSource.GetClosestDUCEFormat(source.Format, source.Palette);
bool changeFormat = (source.Format != duceFormat);
ColorContext destinationColorContext;
// We need to make sure, we can actually create the ColorContext for the destination duceFormat
// If the duceFormat is gray or scRGB, the following is not supported, so we cannot
// create the ColorConvertedBitmap
try
{
destinationColorContext = new ColorContext(duceFormat);
}
catch (NotSupportedException)
{
destinationColorContext = null;
}
if (destinationColorContext != null)
{
bool conversionSuccess = false;
bool badColorContext = false;
// First try if the color converter can handle the source format directly
// Its possible that the color converter does not support certain pixelformats, so put a try/catch here.
try
{
ColorConvertedBitmap colorConvertedBitmap = new ColorConvertedBitmap(
source,
frame.ColorContexts[0],
destinationColorContext,
duceFormat
);
source = colorConvertedBitmap;
if (_isDownloading)
{
// Unregister the download events because this is a dummy image. See comment above.
source.UnregisterDownloadEventSource();
}
conversionSuccess = true;
}
catch (NotSupportedException)
{
}
catch (FileFormatException)
{
// If the file contains a bad color context, we catch the exception here
// and don't bother trying the color conversion below, since color transform isn't possible
// with the given color context.
badColorContext = true;
}
if (!conversionSuccess && !badColorContext && changeFormat)
{ // If the conversion failed, we first use
// a FormatConvertedBitmap, and then Color Convert that one...
FormatConvertedBitmap formatConvertedBitmap = new FormatConvertedBitmap(source, duceFormat, source.Palette, 0.0);
ColorConvertedBitmap colorConvertedBitmap = new ColorConvertedBitmap(
formatConvertedBitmap,
frame.ColorContexts[0],
destinationColorContext,
duceFormat
);
source = colorConvertedBitmap;
if (_isDownloading)
{
// Unregister the download events because this is a dummy image. See comment above.
source.UnregisterDownloadEventSource();
}
}
}
}
if (CacheOption != BitmapCacheOption.None)
{
try
{
// The bitmaps bits could be corrupt, and this will cause an exception if the CachedBitmap forces a decode.
CachedBitmap cachedSource = new CachedBitmap(source, CreateOptions & ~BitmapCreateOptions.DelayCreation, CacheOption);
source = cachedSource;
if (_isDownloading)
{
// Unregister the download events because this is a dummy image. See comment above.
source.UnregisterDownloadEventSource();
}
}
catch (Exception e)
{
RecoverFromDecodeFailure(e);
CreationCompleted = true; // we're bailing out because the decode failed
return;
}
}
// If CacheOption == OnLoad, no need to keep the stream around
if (decoder != null && CacheOption == BitmapCacheOption.OnLoad)
{
decoder.CloseStream();
}
else if (CacheOption != BitmapCacheOption.OnLoad)
{
//ensure that we don't GC the source
_finalSource = source;
}
WicSourceHandle = source.WicSourceHandle;
IsSourceCached = source.IsSourceCached;
CreationCompleted = true;
UpdateCachedSettings();
// Only insert in the imaging cache if download is complete
if (!IsDownloading)
{
InsertInCache(uri);
}
}
