|
public WriteAsync ( [ buffer ) : uint>.IAsyncOperationWithProgress |
||
| buffer | [ | |
| return | uint>.IAsyncOperationWithProgress | |
public static async Task <byte[]> TranscodeImageFile(WriteableBitmap wb)
{
using (var ras = wb.PixelBuffer.AsStream().AsRandomAccessStream())
{
System.Diagnostics.Debug.WriteLine("1");
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(ras);
System.Diagnostics.Debug.WriteLine("2");
var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
System.Diagnostics.Debug.WriteLine("3");
BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder);
encoder.BitmapTransform.ScaledWidth = 320;
encoder.BitmapTransform.ScaledHeight = 240;
System.Diagnostics.Debug.WriteLine("4");
await encoder.FlushAsync();
System.Diagnostics.Debug.WriteLine("5");
var outbuff = new byte[memStream.Size];
System.Diagnostics.Debug.WriteLine("6");
await memStream.WriteAsync(outbuff.AsBuffer());
System.Diagnostics.Debug.WriteLine("7");
return(outbuff);
}
}
public async Task<byte[]> ConvertToGrayScale(byte[] imageBytes, int height, int width)
{
using (InMemoryRandomAccessStream rasStream = new InMemoryRandomAccessStream())
{
await rasStream.WriteAsync(imageBytes.AsBuffer());
var decoder = await BitmapDecoder.CreateAsync(rasStream);
var pixelData = await decoder.GetPixelDataAsync();
var pixels = pixelData.DetachPixelData();
if (_filter == null)
_filter = new ImageFilter();
await _filter.ToGrayScale(pixels.AsBuffer());
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, rasStream);
encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore, (uint)width, (uint)height, decoder.DpiX, decoder.DpiY, pixels);
await encoder.FlushAsync();
using (BinaryReader br = new BinaryReader(rasStream.AsStreamForRead()))
{
rasStream.Seek(0);
return br.ReadBytes((int)rasStream.AsStreamForRead().Length);
}
}
}
public async Task Should_produce_read_bytes_hash(int bufferSize)
{
var data = CryptographicBuffer.GenerateRandom(2048);
var expected = HashAlgorithmProvider
.OpenAlgorithm(HashAlgorithmNames.Sha256)
.HashData(data);
using (var file = new InMemoryRandomAccessStream())
{
await file.WriteAsync(data);
file.Seek(0);
var buffer = WindowsRuntimeBuffer.Create(bufferSize);
using (var hashed = new HashedInputStream(file))
{
for (var i = 0; i < 8; i++)
{
await hashed.ReadAsync(
buffer, buffer.Capacity);
}
var hash = hashed.GetHashAndReset();
Assert.Equal(expected.ToArray(), hash.ToArray());
}
}
}
/// <summary>
/// Decrypts the specified input stream.
/// </summary>
/// <param name="input">The input stream.</param>
/// <param name="masterKey">The master key.</param>
/// <param name="masterSeed">The master seed.</param>
/// <param name="encryptionIV">The encryption initialization vector.</param>
/// <returns>The decrypted buffer.</returns>
/// <exception cref="ArgumentNullException">
/// The <paramref name="input"/>, <paramref name="masterSeed"/>, <paramref name="masterKey"/>
/// and <paramref name="encryptionIV"/> cannot be <c>null</c>.
/// </exception>
public static async Task<IInputStream> Decrypt(IRandomAccessStream input,
IBuffer masterKey, IBuffer masterSeed, IBuffer encryptionIV)
{
if (input == null) throw new ArgumentNullException("input");
if (masterSeed == null) throw new ArgumentNullException("masterSeed");
if (masterKey == null) throw new ArgumentNullException("masterKey");
if (encryptionIV == null) throw new ArgumentNullException("encryptionIV");
var sha = HashAlgorithmProvider
.OpenAlgorithm(HashAlgorithmNames.Sha256)
.CreateHash();
sha.Append(masterSeed);
sha.Append(masterKey);
var seed = sha.GetValueAndReset();
var aes = SymmetricKeyAlgorithmProvider
.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7)
.CreateSymmetricKey(seed);
var buffer = WindowsRuntimeBuffer.Create(
(int)(input.Size - input.Position));
buffer = await input.ReadAsync(buffer, buffer.Capacity);
buffer = CryptographicEngine.Decrypt(aes, buffer, encryptionIV);
var stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(buffer);
stream.Seek(0);
return stream;
}
public static async Task<InMemoryRandomAccessStream> ConvertToInMemoryStream(byte[] arr)
{
var randomAccessStream = new InMemoryRandomAccessStream();
await randomAccessStream.WriteAsync(arr.AsBuffer());
randomAccessStream.Seek(0);
await randomAccessStream.FlushAsync(); // TODO: don't sure it's needed
return randomAccessStream;
}
private async void mjpeg_FrameReady(object sender, FrameReadyEventArgs e)
{
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(e.FrameBuffer);
stream.Seek(0);
_bmp.SetSource(stream);
image.Source = _bmp;
}
/// <summary>
/// 将Stream转换成IRandomAccessStream
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static async Task<IRandomAccessStream> ToRandomAccessStream(this Stream stream)
{
var buffer = CryptographicBuffer.CreateFromByteArray(stream.GetBytes());
InMemoryRandomAccessStream inme = new InMemoryRandomAccessStream();
await inme.WriteAsync(buffer);
inme.Seek(0);
return inme;
}
public static async Task<IRandomAccessStream> AsRandomAccessStreamAsync(this byte[] array)
{
var stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(array.AsBuffer());
stream.Seek(0);
return stream;
}
private async void client_ColorFrameReady(object sender, ColorFrameData e)
{
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(e.PixelBuffer);
stream.Seek(0);
_colorBitmap.SetSource(stream);
this.Color.Source = _colorBitmap;
}
public void SetSource(byte[] bytes)
{
var ms = new InMemoryRandomAccessStream();
ms.WriteAsync(bytes.AsBuffer());
ms.FlushAsync().AsTask().Wait();
ms.Seek(0);
bitmap = new BitmapImage();
bitmap.SetSource(ms);
}
public static async Task<BitmapImage> AsBitmapImageAsync(this IBuffer @this)
{
var img = new BitmapImage();
using (var stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(@this);
stream.Seek(0);
await img.SetSourceAsync(stream);
}
return img;
}
public static async Task<BitmapImage> ByteArrayToBitmapImageAsync(byte[] byteArray)
{
var bitmapImage = new BitmapImage();
var stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(byteArray.AsBuffer());
stream.Seek(0);
bitmapImage.SetSource(stream);
return bitmapImage;
}
public async Task Headers_should_detect_not_supported_files()
{
using (var file = new InMemoryRandomAccessStream())
{
await file.WriteAsync(
CryptographicBuffer.GenerateRandom(1024));
file.Seek(0);
var result = await FileFormat.Headers(file);
Assert.Null(result.Headers);
Assert.Equal(FileFormats.NotSupported, result.Format);
}
}
public async Task Should_detect_corrupt_data()
{
using (var input = new InMemoryRandomAccessStream())
{
await CopyData(input, "IO.HashedBlockStream.bin");
input.Seek(200);
await input.WriteAsync(CryptographicBuffer.GenerateRandom(8));
input.Seek(0);
await Assert.ThrowsAsync<InvalidDataException>(
() => HashedBlockFileFormat.Read(input));
}
}
public async Task Headers_should_detect_1x_file_format()
{
using (var file = new InMemoryRandomAccessStream())
{
await file.WriteAsync(CryptographicBuffer
.DecodeFromHexString("03D9A29A65FB4BB5"));
file.Seek(0);
var result = await FileFormat.Headers(file);
Assert.Null(result.Headers);
Assert.Equal(FileFormats.KeePass1x, result.Format);
}
}
public async Task Headers_should_detect_new_format()
{
using (var file = new InMemoryRandomAccessStream())
{
// Schema: 4.01
await file.WriteAsync(CryptographicBuffer
.DecodeFromHexString("03D9A29A67FB4BB501000400"));
file.Seek(0);
var result = await FileFormat.Headers(file);
Assert.Null(result.Headers);
Assert.Equal(FileFormats.NewVersion, result.Format);
}
}
public static BitmapImage AsBitmapImage(this byte[] byteArray)
{
if (byteArray != null)
{
using (var stream = new InMemoryRandomAccessStream())
{
stream.WriteAsync(byteArray.AsBuffer()).GetResults(); // I made this one synchronous on the UI thread; this is not a best practice.
var image = new BitmapImage();
stream.Seek(0);
image.SetSource(stream);
return image;
}
}
return null;
}
public static ImageSource ToImage(this byte[] self)
{
if (self == null)
return null;
if (self.Length == 0)
return null;
var stream = new InMemoryRandomAccessStream();
stream.WriteAsync(self.AsBuffer()).AsTask().Wait();
stream.Seek(0);
var myImage = new BitmapImage();
myImage.SetSource(stream);
return myImage;
}
public static async Task<string> ParseTextAsync()
{
try
{
using (var memoryStream = new MemoryStream())
using (var memoryRandomAccessStream = new InMemoryRandomAccessStream())
{
await Task.Run(() => SaveScreenshot(memoryStream));
await memoryRandomAccessStream.WriteAsync(memoryStream.ToArray().AsBuffer());
return await RunOcr(memoryRandomAccessStream);
}
}
finally
{
GC.Collect(0);
}
}
public async Task SaveBitmapAsync(string albumFolder, uint size, string songPath)
{
var songFile = await StorageFile.GetFileFromPathAsync(songPath);
using (var thumbnail = await songFile.GetThumbnailAsync(ThumbnailMode.MusicView, size) ??
await songFile.GetThumbnailAsync(ThumbnailMode.VideosView, size))
{
if (thumbnail == null)
return;
var reader = new DataReader(thumbnail);
var fileLength = (uint)thumbnail.Size;
await reader.LoadAsync(fileLength);
var buffer = reader.ReadBuffer(fileLength);
var memStream = new InMemoryRandomAccessStream();
await memStream.WriteAsync(buffer);
await memStream.FlushAsync();
memStream.Seek(0);
await ApplicationData.Current.LocalFolder.CreateFolderAsync(AlbumArtFolderName(albumFolder), CreationCollisionOption.OpenIfExists);
var albumArtFileName = AlbumArtFileName(albumFolder, size);
var outputFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(albumArtFileName, CreationCollisionOption.ReplaceExisting);
// http://social.msdn.microsoft.com/Forums/windowsapps/en-US/1dda3a15-d299-40e0-b668-ec690a683f6e/how-to-resize-an-image-as-storagefile?forum=winappswithcsharp
var decoder = await BitmapDecoder.CreateAsync(memStream);
var transform = new BitmapTransform { ScaledHeight = size, ScaledWidth = size };
var pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Rgba8,
BitmapAlphaMode.Straight,
transform,
ExifOrientationMode.RespectExifOrientation,
ColorManagementMode.DoNotColorManage);
using (var destinationStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, destinationStream);
encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, size, size, 96, 96, pixelData.DetachPixelData());
await encoder.FlushAsync();
}
}
}
private async System.Threading.Tasks.Task <bool> WriteWAVHeader()
{
if (internalStream != null)
{
byte[] buffer = this.CreateWAVHeaderBuffer((uint)(CD_RAW_SECTOR_SIZE * (EndSector - StartSector)));
if (buffer != null)
{
uint l = await internalStream.WriteAsync(buffer.AsBuffer());
if (l == buffer.Length)
{
WriteDataIndex = l;
return(true);
}
}
}
return(false);
}
private async Task LoadImages(IList<ContactModel> contacts)
{
foreach (var contact in contacts)
{
var bytes = await Controllers.MyContactsController.GetImage(contact.Email);
if (bytes != null && bytes.Length > 0)
{
using (var stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(bytes.AsBuffer());
var image = new BitmapImage();
stream.Seek(0);
image.SetSource(stream);
contact.Thumbnail = image;
}
}
}
}
/// <summary>
/// Load the images as a BitmapImage object asyncronously
/// </summary>
/// <returns>The as user interface image.</returns>
/// <param name="Item">Item.</param>
public static async Task<BitmapImage> ImageAsBitmapAsync(this Gravatar Item)
{
if (Item != null && Item.Image != null)
{
using (var stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(Item.Image.AsBuffer());
var image = new BitmapImage();
stream.Seek(0);
image.SetSource(stream);
return image;
}
}
return null;
}
public async Task<BitmapImage> GetFromUrl(string url)
{
var color = Color.FromArgb((byte)_random.Next(255), (byte)_random.Next(255), (byte)_random.Next(255), (byte)_random.Next(255));
byte[] pxl = new byte[4 * 80 * 80];
for (int i = 0; i < pxl.Length; i += 4)
{
pxl[i + 0] = color.B;
pxl[i + 1] = color.G;
pxl[i + 2] = color.R;
pxl[i + 3] = color.A;
}
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
var image = new BitmapImage();
await stream.WriteAsync(pxl.AsBuffer());
stream.Seek(0);
image.SetSource(stream);
return image;
}
}
private async void DownloadAndScale(string outfileName, string downloadUriString)
{
Uri downLoadingUri = new Uri(downloadUriString);
var client = new HttpClient();
using (var response = await client.GetAsync(downLoadingUri))
{
var buffer = await response.Content.ReadAsBufferAsync();
var memoryStream = new InMemoryRandomAccessStream();
await memoryStream.WriteAsync(buffer);
await memoryStream.FlushAsync();
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(memoryStream);
var pixelProvider = await decoder.GetPixelDataAsync();
var localFolder = Windows.Storage.KnownFolders.PicturesLibrary;
var scaledFile = await localFolder.CreateFileAsync(outfileName, CreationCollisionOption.GenerateUniqueName);
using (var scaledFileStream = await scaledFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
var encoder = await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync( BitmapEncoder.JpegEncoderId, scaledFileStream);
var pixels = pixelProvider.DetachPixelData();
encoder.SetPixelData(
decoder.BitmapPixelFormat,
decoder.BitmapAlphaMode,
decoder.PixelWidth,
decoder.PixelHeight,
decoder.DpiX,
decoder.DpiY,
pixels
);
await encoder.FlushAsync();
}
}
}
public override async void OnAppearing()
{
base.OnAppearing();
this.IsBusy = true;
var dialog = Database.Instance().GetDialog(dialogId);
var opponentId =
dialog.OccupantIds.Split(',').Select(Int32.Parse).First(id => id != App.QbProvider.UserId);
privateChatManager = App.QbProvider.GetXmppClient().GetPrivateChatManager(opponentId, dialogId);
privateChatManager.MessageReceived += OnMessageReceived;
DialogName = dialog.Name;
ImageSource = new BitmapImage(new Uri("ms-appx:///Assets/privateholder.png"));
this.opponentUsers = new List<User>();
var users = await App.QbProvider.GetUsersByIdsAsync(dialog.OccupantIds);
var opponentUser = users.FirstOrDefault(u => u.Id != App.QbProvider.UserId);
if (opponentUser != null)
{
this.opponentUsers.Add(opponentUser);
if (opponentUser.BlobId.HasValue)
{
var bytes = await App.QbProvider.GetImageAsync(opponentUser.BlobId.Value);
BitmapImage image = new BitmapImage();
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(bytes.AsBuffer());
stream.Seek(0);
await image.SetSourceAsync(stream);
}
}
}
await this.LoadMessages();
this.IsBusy = false;
}
/// <summary>
/// loads the character image as BitmapImage
/// </summary>
/// <param name="charID">the character ID</param>
/// <param name="size">the size of the image - needs to be an exponent of two!</param>
/// <returns>the character image</returns>
static async private System.Threading.Tasks.Task<BitmapImage> FetchImage(string charID, int size)
{
// build request string and load image data
string url = "https://image.eveonline.com/Character/" + charID + "_" + size.ToString() + ".jpg";
byte[] contentBytes = await new HttpClient().GetByteArrayAsync(url);
// stream image data and store in bitmap image
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(contentBytes.AsBuffer());
stream.Seek(0);
BitmapImage image = new BitmapImage();
image.SetSource(stream);
return image;
}
private async void LoadData() {
//load existing data
HttpWebRequest getrequest = (HttpWebRequest)HttpWebRequest.Create("http://mythingapi.azurewebsites.net/api/MyThings");
getrequest.Method = "GET";
getrequest.ContentType = "application/json;charset=utf-8";
var data = await getrequest.GetResponseAsync();
Stream mystream = data.GetResponseStream();
StreamReader sr = new StreamReader(mystream);
string returnval = sr.ReadToEnd();
existItemList = JsonConvert.DeserializeObject<List<MyThingObj>>(returnval);
if (existItemList.Count > 0)
{
this.Frame.DataContext = existItemList[0];
id.Text = existItemList[0].id.ToString();
itemName.Text = existItemList[0].name != null ? existItemList[0].name : string.Empty;
//rfid.Text = existItemList[0].rfid!=null? existItemList[0].rfid:string.Empty;
type.Text = existItemList[0].type != null ? existItemList[0].type:string.Empty;
Location.Text = "Location: " + existItemList[0].location;
if (existItemList[0].image != null)
{
BitmapImage img = new BitmapImage();
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(existItemList[0].image.AsBuffer());
stream.Seek(0);
await img.SetSourceAsync(stream);
}
image.Source = img as ImageSource;
}
}
}
public async Task<BitmapImage> ImgSrcFromBytes(byte[] bytes)
{
if (bytes == null || bytes.Length == 0) return null;
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(bytes.AsBuffer(0, bytes.Length));
stream.Seek(0);
BitmapImage image = new BitmapImage();
await image.SetSourceAsync(stream);
// this.CurrentImage.Source = image;
return image;
}
}
/// <summary>
/// 异步从网络下载图片
/// </summary>
/// <param name="outfileName">下载保存到本地的图片文件名</param>
/// <param name="downloadUriString">图片uri</param>
/// <param name="scaleSize">图片尺寸</param>
/// <returns></returns>
public static async Task DownloadAndScale(string outfileName, string downloadUriString, Size scaleSize)
{
try
{
Uri downLoadingUri = new Uri(downloadUriString);//创建uri对象
HttpClient client = new HttpClient();//实例化httpclient对象
using (var response = await client.GetAsync(downLoadingUri))
{
var buffer = await response.Content.ReadAsBufferAsync();//从返回的数据中读取buffer
var memoryStream = new InMemoryRandomAccessStream();
await memoryStream.WriteAsync(buffer);//将buffer写入memorystream
await memoryStream.FlushAsync();//刷新
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(memoryStream);//解密文件流
//确定图片大小
var bt = new Windows.Graphics.Imaging.BitmapTransform();
bt.ScaledWidth = (uint)scaleSize.Width;
bt.ScaledHeight = (uint)scaleSize.Height;
//得到像素数值
var pixelProvider = await decoder.GetPixelDataAsync(
decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, bt,
ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.ColorManageToSRgb);
//下面保存图片
// Now that we have the pixel data, get the destination file
var localFolder = ApplicationData.Current.LocalFolder;
//var resultsFolder = await localFolder.CreateFolderAsync("Results", CreationCollisionOption.OpenIfExists);
var scaledFile = await localFolder.CreateFileAsync(outfileName, CreationCollisionOption.ReplaceExisting);
using (var scaledFileStream = await scaledFile.OpenAsync(FileAccessMode.ReadWrite))
{
var encoder = await BitmapEncoder.CreateAsync(
BitmapEncoder.JpegEncoderId, scaledFileStream);
var pixels = pixelProvider.DetachPixelData();
encoder.SetPixelData(
decoder.BitmapPixelFormat,
decoder.BitmapAlphaMode,
(uint)scaleSize.Width,
(uint)scaleSize.Height,
decoder.DpiX,
decoder.DpiY,
pixels
);
await encoder.FlushAsync();
}
}
}
catch (Exception) { Debug.WriteLine("工具，图片异常"); }
}
/// <summary>
/// Helper that produces the contents corresponding to a Uri.
/// Uses the C# await pattern to coordinate async operations.
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
private async Task<IInputStream> GetContentAsync(Uri uri)
{
string path = uri.AbsolutePath;
string contents;
switch (path)
{
case "/default.html":
contents = await MainPage.LoadStringFromPackageFileAsync("stream_example.html");
contents = contents.Replace("%", Windows.ApplicationModel.Package.Current.Id.Name);
break;
case "/stream.css":
contents = "p { color: blue; }";
break;
default:
throw new Exception($"Could not resolve URI \"{uri}\"");
}
// Convert the string to a stream.
IBuffer buffer = CryptographicBuffer.ConvertStringToBinary(contents, BinaryStringEncoding.Utf8);
var stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(buffer);
return stream.GetInputStreamAt(0);
}
private async static void UriSourcePropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Debug.WriteLine("我被触发了");
StorageCachedImage image = d as StorageCachedImage;
string i = e.NewValue as string;
int k = i.IndexOf("image");
string imagePath = i.Substring(k + 7);
string uri = App.Uri + "public/images/" + imagePath;
Debug.WriteLine(uri);
Uri imageUri = new Uri(uri);
HttpClient client = new HttpClient();
var response = await client.GetAsync(imageUri);
var buffer = await response.Content.ReadAsBufferAsync();
var memoryStream = new InMemoryRandomAccessStream();
await memoryStream.WriteAsync(buffer);
await memoryStream.FlushAsync();
await image.SetSourceAsync(memoryStream);
}
