示例#1
0
        public async Task <bool> CompressImage(Stream fileStream, string inputFile, string outputFile)
        {
            NSError error = await Task.Run(() =>
            {
                Debug.WriteLine($"Original image file '{inputFile}' (Size: {new FileInfo(inputFile).Length / 1024} KB)");

                UIImage img = new UIImage(NSData.FromStream(fileStream));

                CGSize imgSize = img.Size;
                switch (ImageCompression.DeterminePrimaryScaleDimension(imgSize.Height, imgSize.Width))
                {
                case ImageCompression.ScaleDown.Height:
                    imgSize = new CGSize(
                        ImageCompression.SecondaryTargetSize(imgSize.Height, imgSize.Width),
                        ImageCompression.MaximumDimension
                        );
                    img = img.Scale(imgSize);
                    break;

                case ImageCompression.ScaleDown.Width:
                    imgSize = new CGSize(
                        ImageCompression.MaximumDimension,
                        ImageCompression.SecondaryTargetSize(imgSize.Width, imgSize.Height)
                        );
                    img = img.Scale(imgSize);
                    break;

                case ImageCompression.ScaleDown.None:
                    break;
                }

                NSData imgData = img.AsJPEG(ImageCompression.CompressionFactorJpegFloat);
                imgData.Save(outputFile, NSDataWritingOptions.FileProtectionCompleteUntilFirstUserAuthentication, out error);
                Debug.WriteLine($"Wrote compressed image file to '{outputFile}' (Size: {new FileInfo(outputFile).Length / 1024} KB)");

                return(error);
            });             // TODO: maybe use configure context here

            return(error == null);
        }
示例#2
0
        public async Task <bool> CompressImage(Stream fileStream, string inputFile, string outputFile)
        {
            SDebug.WriteLine($"Original image file '{inputFile}' (Size: {new FileInfo(inputFile).Length / 1024} KB)");
            Bitmap img = await BitmapFactory.DecodeStreamAsync(fileStream);

            switch (ImageCompression.DeterminePrimaryScaleDimension(img.Height, img.Width))
            {
            case ImageCompression.ScaleDown.Height:
                img = Bitmap.CreateScaledBitmap(
                    img,
                    ImageCompression.SecondaryTargetSize(img.Height, img.Width),
                    ImageCompression.MaximumDimension,
                    true);
                break;

            case ImageCompression.ScaleDown.Width:
                img = Bitmap.CreateScaledBitmap(
                    img,
                    ImageCompression.MaximumDimension,
                    ImageCompression.SecondaryTargetSize(img.Width, img.Height),
                    true);
                break;

            case ImageCompression.ScaleDown.None:
                break;
            }

            FileStream writeStream = new FileStream(path: outputFile,
                                                    mode: FileMode.Create,
                                                    access: FileAccess.Write,
                                                    share: FileShare.None,
                                                    bufferSize: 8,
                                                    useAsync: true);
            bool success = await img.CompressAsync(Bitmap.CompressFormat.Jpeg, ImageCompression.CompressionFactorJpeg, writeStream);              // async version available

            writeStream.Close();
            SDebug.WriteLine($"Wrote compressed image file to '{outputFile}' (Size: {new FileInfo(outputFile).Length / 1024} KB)");

            return(success);
        }