private async void StreamSkeleton() { try { var reader = new DataReader( Client.InputStream ); reader.InputStreamOptions = InputStreamOptions.Partial; while ( IsConnected ) { await reader.LoadAsync( 4 ); var size = reader.ReadUInt32(); await reader.LoadAsync( size ); byte[] bytes = new byte[size]; reader.ReadBytes( bytes ); MemoryStream ms = new MemoryStream( bytes ); BinaryReader br = new BinaryReader(ms); SkeletonFrameData frame = br.ReadSkeletonFrame(); SkeletonFrameReadyEventArgs args = new SkeletonFrameReadyEventArgs { SkeletonFrame = frame }; SkeletonFrame = frame; Context.Send(delegate { if(SkeletonFrameReady != null) SkeletonFrameReady(this, args); }, null); } } catch(IOException) { Disconnect(); } }
private async void save_Video(object sender, RoutedEventArgs e) { // Adding try catch block in case of occurence of an exception try { // Creating object of FileSavePicker and adding few values to the properties of the object. FileSavePicker fs = new FileSavePicker(); fs.FileTypeChoices.Add("Video", new List<string>() { ".mp4",".3gp" }); fs.DefaultFileExtension = ".mp4"; fs.SuggestedFileName = "Video" + DateTime.Today.ToString(); fs.SuggestedStartLocation = PickerLocationId.VideosLibrary; // Using storagefile object defined earlier in above method to save the file using filesavepicker. fs.SuggestedSaveFile = sf; // Saving the file var s = await fs.PickSaveFileAsync(); if (s != null) { using (var dataReader = new DataReader(rs.GetInputStreamAt(0))) { await dataReader.LoadAsync((uint)rs.Size); byte[] buffer = new byte[(int)rs.Size]; dataReader.ReadBytes(buffer); await FileIO.WriteBytesAsync(s, buffer); } } } catch (Exception ex) { var messageDialog = new MessageDialog("Something went wrong."); await messageDialog.ShowAsync(); } }
private async void read_data() { ifListening = true; // int read_msg_counter = 2; using (var reader = new Windows.Storage.Streams.DataReader(streamSocket.InputStream)){ reader.InputStreamOptions = Windows.Storage.Streams.InputStreamOptions.ReadAhead; reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; reader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; await reader.LoadAsync(4); while (reader.UnconsumedBufferLength > 0) { // read_msg_counter--; int bytesToRerad = reader.ReadInt32(); // Debug.Log("bytes to read: " + bytesToRerad); if (bytesToRerad <= 0) { return; } await reader.LoadAsync(Convert.ToUInt32(bytesToRerad)); byte[] buffer = new byte[bytesToRerad]; reader.ReadBytes(buffer); processReceivedData(buffer, bytesToRerad); await reader.LoadAsync(4); } reader.DetachStream(); } ifListening = false; }
private async Task SaveBitmap(RenderTargetBitmap rtb, SoftwareBitmap swBmp) { FileSavePicker filePicker = new Windows.Storage.Pickers.FileSavePicker(); filePicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary; filePicker.FileTypeChoices.Add("JPG file", new List <string>() { ".jpg" }); StorageFile file = await filePicker.PickSaveFileAsync(); if (file != null) { using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { IBuffer buffer = await rtb.GetPixelsAsync(); Windows.Storage.Streams.DataReader dataReader = Windows.Storage.Streams.DataReader.FromBuffer(buffer); byte[] generatedImage = new byte[buffer.Length]; dataReader.ReadBytes(generatedImage); var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, stream); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)rtb.PixelWidth, (uint)rtb.PixelHeight, swBmp.DpiX, swBmp.DpiY, generatedImage); await encoder.FlushAsync(); } } }
/// <summary> /// Receive message through bluetooth. /// </summary> protected async Task<byte[]> ReceiveMessages(DataReader dataReader) { try { // Read the message. List<Byte> all = new List<byte>(); while (true) { var bytesAvailable = await dataReader.LoadAsync(1000); var byteArray = new byte[bytesAvailable]; dataReader.ReadBytes(byteArray); if (byteArray.Length > 0 && byteArray[0] != byte.MinValue) { if (OnDataRead != null) OnDataRead(byteArray); return byteArray; } Thread.Sleep(100); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } return null; }
private async Task<RfidReaderResult> Read() { RfidReaderResult retvalue = new RfidReaderResult(); var dataReader = new DataReader(_rfidReader.InputStream); try { SetStatus("Awaiting Data from RFID Reader"); var numBytesRecvd = await dataReader.LoadAsync(1024); retvalue.Result = new byte[numBytesRecvd]; if (numBytesRecvd > 0) { SetStatus("Data successfully read from RFID Reader"); dataReader.ReadBytes(retvalue.Result); retvalue.IsSuccessful = true; retvalue.Message = "Data successfully read from RFID Reader"; } } catch (Exception ex) { retvalue.IsSuccessful = false; retvalue.Message = ex.Message; } finally { if (dataReader != null) { dataReader.DetachStream(); dataReader = null; } } return retvalue; }
private async void ReceiveImage(StreamSocket socket) { UpdateStatus("Empfange Daten..."); // DataReader erzeugen, um arbeiten mit Bytes zu vereinfachen var reader = new DataReader(socket.InputStream); // Anzahl der Bytes abrufen, aus denen das Bild besteht // Anzahl = int = 4 Bytes => 4 Bytes vom Socket laden await reader.LoadAsync(4); int imageSize = reader.ReadInt32(); // Bytearray des Bildes laden await reader.LoadAsync((uint)imageSize); byte[] imageBytes = new byte[imageSize]; reader.ReadBytes(imageBytes); // Bytearray in Stream laden und anzeigen Dispatcher.BeginInvoke(() => { using (var ms = new MemoryStream(imageBytes)) { var image = new BitmapImage(); image.SetSource(ms); ReceivedImage.Source = image; } }); UpdateStatus("Bild empfangen."); // Ressourcen freigeben reader.Dispose(); }
byte [] LoadModel(Windows.Storage.StorageFolder folder, string path) { try { var task = folder.GetFileAsync(path).AsTask(); task.Wait(); var streamTask = task.Result.OpenReadAsync().AsTask(); streamTask.Wait(); using (var stream = streamTask.Result) { using (var reader = new Windows.Storage.Streams.DataReader(stream)) { var len = stream.Size; reader.LoadAsync((uint)len).AsTask().Wait(); byte[] content = new byte[len]; reader.ReadBytes(content); return(content); } } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); System.Diagnostics.Debug.WriteLine(ex.StackTrace); } return(null); }
private static async Task<byte[]> ConvertIRandomAccessStreamByte(IRandomAccessStream stream) { DataReader read = new DataReader(stream.GetInputStreamAt(0)); await read.LoadAsync((uint)stream.Size); byte[] temp = new byte[stream.Size]; read.ReadBytes(temp); return temp; }
public string Receive() { IInputStream istream = this.streamSocket.InputStream; var dataReader = new DataReader(istream); byte[] msgSizeByteArray = new byte[4]; dataReader.LoadAsync(4).AsTask().Wait(); dataReader.ReadBytes(msgSizeByteArray); int msgSize = Helpers.byteArrayToInt(msgSizeByteArray); byte[] msgByteArray = new byte[msgSize]; dataReader.LoadAsync((uint) msgSize).AsTask().Wait(); dataReader.ReadBytes(msgByteArray); string message = Helpers.byteArrayToString(msgByteArray); return message; }
/// <summary> /// Returns a byte array with the content of the stream. /// </summary> /// <param name="stream">stream to get bytes for</param> /// <returns>awaitable byte array</returns> public static async Task<byte[]> GetPhotoBits(IRandomAccessStream stream) { Debug.Assert(stream != null, "GetPhotoBits should not be called with a null stream."); var reader = new DataReader(stream.GetInputStreamAt(0)); var bytes = new byte[stream.Size]; await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(bytes); return bytes; }
private async void ColorThread() { try { var reader = new DataReader( Client.InputStream ); reader.InputStreamOptions = InputStreamOptions.Partial; reader.ByteOrder = ByteOrder.LittleEndian; while ( IsConnected ) { await reader.LoadAsync( 4 ); var size = reader.ReadUInt32(); await reader.LoadAsync( size ); byte[] bytes = new byte[size]; reader.ReadBytes( bytes ); MemoryStream ms = new MemoryStream( bytes ); BinaryReader br = new BinaryReader(ms); ColorFrameReadyEventArgs args = new ColorFrameReadyEventArgs(); ColorFrameData cfd = new ColorFrameData(); cfd.Format = (ImageFormat)br.ReadInt32(); cfd.ImageFrame = br.ReadColorImageFrame(); MemoryStream msData = new MemoryStream( bytes, (int)ms.Position, (int)(ms.Length - ms.Position) ); if (cfd.Format == ImageFormat.Raw) { cfd.RawImage = ms.ToArray(); } else { InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream(); DataWriter dw = new DataWriter(ras.GetOutputStreamAt(0)); dw.WriteBytes(msData.ToArray()); await dw.StoreAsync(); // Set to the image BitmapImage bImg = new BitmapImage(); bImg.SetSource(ras); cfd.BitmapImage = bImg; } ColorFrame = cfd; args.ColorFrame = cfd; if (ColorFrameReady != null) { ColorFrameReady(this, args); } } } catch(IOException) { Disconnect(); } }
/// <summary> /// Uploads an activity. /// </summary> /// <param name="file">The path to the activity file on your local hard disk.</param> /// <param name="dataFormat">The format of the file.</param> /// <param name="activityType">The type of the activity.</param> /// <returns>The status of the upload.</returns> public async Task<UploadStatus> UploadActivityAsync(StorageFile file, DataFormat dataFormat, ActivityType activityType = ActivityType.Ride) { String format = String.Empty; switch (dataFormat) { case DataFormat.Fit: format = "fit"; break; case DataFormat.FitGZipped: format = "fit.gz"; break; case DataFormat.Gpx: format = "gpx"; break; case DataFormat.GpxGZipped: format = "gpx.gz"; break; case DataFormat.Tcx: format = "tcx"; break; case DataFormat.TcxGZipped: format = "tcx.gz"; break; } HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", Authentication.AccessToken)); MultipartFormDataContent content = new MultipartFormDataContent(); byte[] fileBytes = null; using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (DataReader reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } var byteArrayContent = new ByteArrayContent(fileBytes); content.Add(byteArrayContent, "file", file.Name); HttpResponseMessage result = await client.PostAsync( String.Format("https://www.strava.com/api/v3/uploads?data_type={0}&activity_type={1}", format, activityType.ToString().ToLower()), content); String json = await result.Content.ReadAsStringAsync(); return Unmarshaller<UploadStatus>.Unmarshal(json); }
public async static Task<Byte[]> GetByteFromFileAsync(this IRandomAccessStream stream) { using (var dataReader = new DataReader(stream)) { var bytes = new byte[stream.Size]; await dataReader.LoadAsync((uint)stream.Size); dataReader.ReadBytes(bytes); return bytes; } }
public static async Task <byte[]> AsByteArrayAsync(this IRandomAccessStream iRandomAccessStream) { IRandomAccessStream fileStream = iRandomAccessStream; var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); byte[] pixels = new byte[fileStream.Size]; reader.ReadBytes(pixels); return(pixels); }
public static async Task<byte[]> IRandomAccessStreamToByteArr(IRandomAccessStream irStream) { DataReader reader = new Windows.Storage.Streams.DataReader(irStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)irStream.Size); byte[] pixels = new byte[irStream.Size]; reader.ReadBytes(pixels); return pixels; }
public async Task<byte[]> GetPhotoBytesAsync(StorageFile file) { IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read); var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); byte[] pixels = new byte[fileStream.Size]; reader.ReadBytes(pixels); return pixels; }
public async Task RenderThumbnailAsync(StorageFile thumb, int scaleWidht, int scaleHeight) { ImageStream inputStream = await composition.GetThumbnailAsync(TimeSpan.Zero, scaleWidht, scaleHeight, VideoFramePrecision.NearestFrame); using (DataReader reader = new DataReader(inputStream.GetInputStreamAt(0))) { await reader.LoadAsync((uint)inputStream.Size); byte[] buffer = new byte[(uint)inputStream.Size]; reader.ReadBytes(buffer); await FileIO.WriteBytesAsync(thumb, buffer); } }
private async void UpdateButton_Click(object sender, RoutedEventArgs e) { MyThingObj data = new MyThingObj(); byte[] fileBytes = null; if (file != null) { using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (DataReader reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } } else { data.image = existItemList[0].image; } data.rfid = rfid.Text; data.name = itemName.Text; data.image = fileBytes; data.lastUpdatedAt = DateTime.Now; data.createdAt = existItemList[0].createdAt; data.type = type.Text; data.status = "1"; data.location = existItemList[0].location; data.id = int.Parse(id.Text); HttpWebRequest Addrequest = (HttpWebRequest)WebRequest.Create("http://mythingapi.azurewebsites.net/api/MyThings/"+id.Text); Addrequest.Method = "PUT"; Addrequest.ContentType = "application/json;charset=utf-8"; Addrequest.Accept = "application/json;charset=utf-8"; Addrequest.BeginGetRequestStream((ar) => { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] bytes = encoding.GetBytes(JsonConvert.SerializeObject(data)); Stream arStream = Addrequest.EndGetRequestStream(ar); arStream.Write(bytes, 0, bytes.Length); Addrequest.BeginGetResponse((arRes) => { HttpWebResponse thingresponse = (HttpWebResponse)Addrequest.EndGetResponse(arRes); }, Addrequest); }, Addrequest); }
public static async Task <byte[]> GetBytesFromStorageFile(StorageFile file) { IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read); var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); byte[] pixels = new byte[fileStream.Size]; reader.ReadBytes(pixels); return(pixels); }
public static async Task<byte[]> ReadFromFile(IStorageFile file) { var stream = await file.OpenAsync(FileAccessMode.Read); var reader = new DataReader(stream.GetInputStreamAt(0)); var streamSize = (uint) stream.Size; await reader.LoadAsync(streamSize); var buffer = new byte[streamSize]; reader.ReadBytes(buffer); return buffer; }
public static async Task <byte[]> GetBytesAsync(this storage.StorageFile file) { sStream.IRandomAccessStream fileStream = await file.OpenAsync(storage.FileAccessMode.Read); var reader = new sStream.DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); byte[] bytes = new byte[fileStream.Size]; reader.ReadBytes(bytes); return(bytes); }
private async Task SaveVideo(IRandomAccessStream videoStream) { StorageFile videoFile = await ApplicationData.Current.LocalFolder.CreateFileAsync("MyCam.mp4"); using (DataReader reader = new DataReader(videoStream.GetInputStreamAt(0))) { await reader.LoadAsync((uint)videoStream.Size); byte[] data = new byte[(int)videoStream.Size]; reader.ReadBytes(data); await FileIO.WriteBytesAsync(videoFile, data); } }
private async Task<uint> OpenFile(string fileName) { StorageFolder myStorageFolder = KnownFolders.DocumentsLibrary; myFile = await myStorageFolder.GetFileAsync("ECHelper Files\\" + fileName+".ech"); readStream = await myFile.OpenAsync(FileAccessMode.Read); fileReader = new DataReader(readStream); count = await fileReader.LoadAsync((uint)readStream.Size); data = new byte[count]; fileReader.ReadBytes(data); return count; }
public async static Task<byte[]> getBytes(Stream stream) { IInputStream inputStream = stream.AsInputStream(); DataReader dataReader = new DataReader(inputStream); await dataReader.LoadAsync((uint)stream.Length); byte[] buffer = new byte[(int)stream.Length]; dataReader.ReadBytes(buffer); return buffer; }
private async void PickAFileButton_Click(object sender, RoutedEventArgs e) { FileOpenPicker openPicker = new FileOpenPicker(); // openPicker.ViewMode = PickerViewMode.Thumbnail; openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary; openPicker.FileTypeFilter.Add(".jpg"); openPicker.FileTypeFilter.Add(".jpeg"); openPicker.FileTypeFilter.Add(".png"); StorageFile file = await openPicker.PickSingleFileAsync(); Login.MasterPage.Loading(true, this); // Ensure a file was selected if (file != null) { bool islogin = WinAppLibrary.Utilities.SPDocument.IsLogin ? true : await (new WinAppLibrary.Utilities.SPDocument()).SignInSharepoint(Login.UserAccount.SPURL, Login.UserAccount.SPUser, Login.UserAccount.SPPassword); if (islogin) { try { // Ensure the stream is disposed once the image is loaded using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { var reader = new DataReader(fileStream.GetInputStreamAt(0)); var bytes = new byte[fileStream.Size]; await reader.LoadAsync((uint)fileStream.Size); reader.ReadBytes(bytes); var stream = new MemoryStream(bytes); await (new WinAppLibrary.Utilities.SPDocument()).SaveJpegContent(Login.UserAccount.SPURL + "/" + WinAppLibrary.Utilities.SPCollectionName.Drawing + "/", "131016AssemblyIWP_test.jpg", stream); // Set the image source to the selected bitmap BitmapImage bitmapImage = new BitmapImage(); //bitmapImage.DecodePixelHeight = decodePixelHeight; //bitmapImage.DecodePixelWidth = decodePixelWidth; await bitmapImage.SetSourceAsync(fileStream); Img3D.Source = bitmapImage; } } catch (Exception ex) { } } else WinAppLibrary.Utilities.Helper.SimpleMessage("Your account for sharepoint is not valid. Please login again.", "Caution!"); Login.MasterPage.Loading(false, this); } }
public async Task<byte[]> ToArrayAsync(StorageFile storageFile) { var stream = await storageFile.OpenReadAsync(); using (var dataReader = new DataReader(stream)) { var bytes = new byte[stream.Size]; await dataReader.LoadAsync((uint)stream.Size); dataReader.ReadBytes(bytes); return bytes; } }
public static async Task<byte[]> ConvertImagetoByte(StorageFile image) { IRandomAccessStream fileStream = await image.OpenAsync(FileAccessMode.Read); var reader = new DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); var pixels = new byte[fileStream.Size]; reader.ReadBytes(pixels); return pixels; }
//public IAsyncOperation<string> CapturePicture() //{ // return getStringHelper().AsAsyncOperation(); //} //private async Task<string> getStringHelper() //{ // var dialog = new CameraCaptureUI(); // var file = await dialog.CaptureFileAsync(CameraCaptureUIMode.Photo); // // Do something useful w/ the file // byte[] imageStream = await ToByteArrayAsync(file); // string base64String = Convert.ToBase64String(imageStream); // return base64String; //} private static async Task<byte[]> ToByteArrayAsync(StorageFile file) { using (IRandomAccessStream stream = await file.OpenReadAsync()) { using (DataReader reader = new DataReader(stream.GetInputStreamAt(0))) { await reader.LoadAsync((uint)stream.Size); byte[] Bytes = new byte[stream.Size]; reader.ReadBytes(Bytes); return Bytes; } } }
/// <summary> /// Get a byte[] from the serial port. /// </summary> /// <returns>The byte[] that has been sent by the other application</returns> protected byte[] GetBytes(DataReader dataReader) { //var d = dataReader.LoadAsync(1024); var buffer = new byte[1024]; while (dataReader.UnconsumedBufferLength > 0) { dataReader.ReadBytes(buffer); } return buffer; }
private async void DepthThread() { try { short[] depthShort = null; var reader = new DataReader( Client.InputStream ); reader.InputStreamOptions = InputStreamOptions.Partial; while ( IsConnected ) { await reader.LoadAsync( 4 ); var size = reader.ReadUInt32(); await reader.LoadAsync( size ); byte[] bytes = new byte[size]; reader.ReadBytes( bytes ); MemoryStream ms = new MemoryStream( bytes ); BinaryReader br = new BinaryReader( ms ); DepthFrameData dfd = new DepthFrameData(); dfd.PlayerIndexBitmask = br.ReadInt32(); dfd.PlayerIndexBitmaskWidth = br.ReadInt32(); DepthImageFrame frame = br.ReadDepthImageFrame(); dfd.ImageFrame = frame; int dataLength = (int)(ms.Length - ms.Position); if ( depthShort == null || depthShort.Length != dataLength / 2 ) depthShort = new short[dataLength / 2]; Buffer.BlockCopy( bytes, (int)br.BaseStream.Position, depthShort, 0, dataLength ); dfd.DepthData = depthShort; DepthFrame = dfd; DepthFrameReadyEventArgs args = new DepthFrameReadyEventArgs(); args.DepthFrame = dfd; Context.Send( delegate { if ( DepthFrameReady != null ) DepthFrameReady( this, args ); }, null ); } } catch ( IOException ) { Disconnect(); } }
//stream to base64 public static async Task<string> streamToString(IRandomAccessStream fileStream) { string Base64String = ""; var reader = new DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); byte[] byteArray = new byte[fileStream.Size]; reader.ReadBytes(byteArray); Base64String = Convert.ToBase64String(byteArray); //string s = ByteToString(byteArray); return Base64String; }
internal async void InitPreviewImage() { if (this.Source == null) { return; } using (var fileStream = await this.Source.OpenReadAsync()) { InMemoryRandomAccessStream memoryStream = new InMemoryRandomAccessStream(); using (var readStream = fileStream.GetInputStreamAt(0)) { var reader = new Windows.Storage.Streams.DataReader(readStream); await reader.LoadAsync((uint)fileStream.Size); byte[] bytes = new byte[fileStream.Size]; reader.ReadBytes(bytes); var writeStream = memoryStream.GetOutputStreamAt(0).AsStreamForWrite(); writeStream.WriteAsync(bytes, 0, (int)fileStream.Size); await writeStream.FlushAsync(); } this.modifiedBitmapStream = memoryStream.CloneStream(); this.previewBitmapStream = this.modifiedBitmapStream; } var decoder = await BitmapDecoder.CreateAsync(this.previewBitmapStream); // this.originalBitmapStream = await this.Source.OpenReadAsync(); // this.previewBitmapStream = await this.Source.OpenReadAsync(); var properties = await this.Source.Properties.GetImagePropertiesAsync(); System.Threading.SynchronizationContext.Current.Post((args) => { System.Threading.SynchronizationContext.Current.Post((args2) => { this.previewBitmap = new WriteableBitmap((int)properties.Width, (int)properties.Height); this.originalBitmap = new WriteableBitmap((int)properties.Width, (int)properties.Height); this.previewBitmap.SetSource(this.modifiedBitmapStream); this.originalBitmap.SetSource(this.modifiedBitmapStream); this.previewBitmap.Invalidate(); this.originalBitmap.Invalidate(); this.ModifiedImage = this.previewBitmap; }, null); }, null); }
private static async Task<byte[]> ReadFile(StorageFile file) { byte[] fileBytes = null; using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (DataReader reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } return fileBytes; }
public async Task<byte[]> ImageInitialize(IRandomAccessStream stream) { var size = stream.Size; byte[] bytes = new byte[size]; var reader = new DataReader(stream.GetInputStreamAt(0)); await reader.LoadAsync((uint)size); reader.ReadBytes(bytes); return bytes; }
public async Task WaitForData() { var mainPageViewModel = MainPageViewModel.GetInstance(); using (var dr = new DataReader(ServerProxy.TcpSocket.InputStream)) { while (mainPageViewModel.ConnectionStatus) { var stringHeader = await dr.LoadAsync(4); if (stringHeader == 0) { mainPageViewModel.ConnectionStatus = false; return; } int messageLength = dr.ReadInt32(); uint numBytes = await dr.LoadAsync((uint)messageLength); var packetBaseBuffer = new byte[numBytes]; dr.ReadBytes(packetBaseBuffer); var packetBase = new PacketBase(); using (var stream = new MemoryStream(packetBaseBuffer)) { try { var reader = new BinaryReader(stream); packetBase.Read(reader); } catch (Exception e) { #if DEBUG throw; #endif } } var incomingMessage = IncomingMessageFactory.GetMessage( packetBase.Data as PacketV1); incomingMessage.HandleMessage(); } } }
public static async Task<byte[]> ReadFile(StorageFile file) { byte[] fileBytes; using (var stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (var reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } return fileBytes; }
public static async Task <byte[]> AsByteArrayAsync(this StorageFile file, string ReplaceLocalFileNameWithExtension, uint ImageWidthHeight) { var imgThumbnail = await file.GetThumbnailAsync(ThumbnailMode.PicturesView, ImageWidthHeight, ThumbnailOptions.ResizeThumbnail); BitmapImage bitmapImage = new BitmapImage(); bitmapImage.DecodePixelHeight = (int)ImageWidthHeight; bitmapImage.DecodePixelWidth = (int)ImageWidthHeight; bitmapImage.SetSource(imgThumbnail); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(imgThumbnail.CloneStream()); SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(); var LocalFolder = ApplicationData.Current.LocalFolder; StorageFile file_Save = await LocalFolder.CreateFileAsync(ReplaceLocalFileNameWithExtension, CreationCollisionOption.ReplaceExisting); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(Windows.Graphics.Imaging.BitmapEncoder.JpegEncoderId, await file_Save.OpenAsync(FileAccessMode.ReadWrite)); encoder.SetSoftwareBitmap(softwareBitmap); encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Linear; encoder.BitmapTransform.ScaledHeight = ImageWidthHeight; encoder.BitmapTransform.ScaledWidth = ImageWidthHeight; encoder.BitmapTransform.Bounds = new BitmapBounds() { Width = ImageWidthHeight, Height = ImageWidthHeight, }; await encoder.FlushAsync(); IRandomAccessStream fileStream = await file_Save.OpenAsync(FileAccessMode.ReadWrite); var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); byte[] pixels = new byte[fileStream.Size]; reader.ReadBytes(pixels); return(pixels); }
private async void LoadImage(object sender, RoutedEventArgs e) { FileOpenPicker open = new FileOpenPicker(); open.SuggestedStartLocation = PickerLocationId.PicturesLibrary; open.ViewMode = PickerViewMode.Thumbnail; // Filter to include a sample subset of file types open.FileTypeFilter.Clear(); open.FileTypeFilter.Add(".bmp"); open.FileTypeFilter.Add(".png"); open.FileTypeFilter.Add(".jpeg"); open.FileTypeFilter.Add(".jpg"); StorageFile file = await open.PickSingleFileAsync(); if (file != null) { // Ensure the stream is disposed once the image is loaded using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { // Set the image source to the selected bitmap /* BitmapImage bitmapImage = new BitmapImage(); * bitmapImage.DecodePixelHeight = 250; * bitmapImage.DecodePixelWidth = 250; * * await bitmapImage.SetSourceAsync(fileStream); * _image = bitmapImage;*/ var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); byte[] pixels = new byte[fileStream.Size]; reader.ReadBytes(pixels); _image = pixels; } } }
protected override void saveImage(com.codename1.ui.Image image, java.io.OutputStream response, string format, float quality) { CanvasBitmapFileFormat fileFormat = CanvasBitmapFileFormat.Png; if (format.Equals(FORMAT_JPEG)) { fileFormat = CanvasBitmapFileFormat.Jpeg; } CodenameOneImage img = (CodenameOneImage)image.getImage(); CanvasBitmap cb = img.image; InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream(); cb.SaveAsync(ms, fileFormat, quality).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();; ms.Seek(0); byte[] buf = new byte[ms.Size]; var dr = new Windows.Storage.Streams.DataReader(ms); dr.LoadAsync((uint)ms.Size).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();; dr.ReadBytes(buf); response.write(buf); }
public override void save(java.io.InputStream image, java.io.OutputStream response, string format, int width, int height, float quality) { CanvasBitmapFileFormat fileFormat = CanvasBitmapFileFormat.Png; if (format.Equals(FORMAT_JPEG)) { fileFormat = CanvasBitmapFileFormat.Jpeg; } CodenameOneImage img = (CodenameOneImage)SilverlightImplementation.instance.createImage(image); CodenameOneImage scaledImage = (CodenameOneImage)SilverlightImplementation.instance.scale(img, width, height); InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream(); scaledImage.image.SaveAsync(ms, fileFormat, quality).AsTask().ConfigureAwait(false).GetAwaiter().GetResult(); ms.Seek(0); byte[] buf = new byte[ms.Size]; var dr = new Windows.Storage.Streams.DataReader(ms); dr.LoadAsync((uint)ms.Size).AsTask().ConfigureAwait(false).GetAwaiter().GetResult(); dr.ReadBytes(buf); response.write(buf); }
private void OnDataReadCompletion(uint bytesRead, Streams.DataReader reader) { if (reader == null) { return; } uint unreadLength = reader.UnconsumedBufferLength; if (unreadLength == 0) { return; } byte[] buffer = new byte[unreadLength]; reader.ReadBytes(buffer); StringBuilder stringBuffer = new StringBuilder(); stringBuffer.Append(Encoding.UTF8.GetString(buffer, 0, buffer.Length)); Debug.WriteLine("Configuration Brute: " + stringBuffer.ToString()); var packet = new ConfigurationPacket { Timestamp = DateTime.UtcNow.Ticks, Data = buffer }; if (UpdateConfiguration(packet)) { if (_DroneClient.RequestedState == RequestedState.GetConfiguration) { _DroneClient.RequestedState = RequestedState.None; } ConfigurationViewModelHelper.UpdateConfigurationSections(_DroneClient.ConfigurationSectionsViewModel, _DroneClient.Configuration); } }
async void beginexecblock() { if ((await Windows.Storage.ApplicationData.Current.RoamingFolder.GetFilesAsync()).Count == 0) { await ApplicationData.Current.RoamingFolder.CreateFileAsync("testfile.txt"); ApplicationData.Current.SignalDataChanged(); Windows.UI.Popups.MessageDialog tdlg = new Windows.UI.Popups.MessageDialog("Roaming file creation success", "Sync status"); await tdlg.ShowAsync(); } try { DateTime started = DateTime.Now; RenderContext mtext = new RenderContext(); maincontext = mtext; StorageFolder folder = Windows.ApplicationModel.Package.Current.InstalledLocation; StorageFile file = await folder.GetFileAsync("DXInteropLib\\VertexShader.cso"); var stream = (await file.OpenAsync(FileAccessMode.Read)); Windows.Storage.Streams.DataReader mreader = new Windows.Storage.Streams.DataReader(stream.GetInputStreamAt(0)); byte[] dgram = new byte[file.Size]; await mreader.LoadAsync((uint)dgram.Length); mreader.ReadBytes(dgram); file = await folder.GetFileAsync("DXInteropLib\\PixelShader.cso"); stream = await file.OpenAsync(FileAccessMode.Read); mreader = new Windows.Storage.Streams.DataReader(stream.GetInputStreamAt(0)); byte[] mgram = new byte[file.Size]; await mreader.LoadAsync((uint)file.Size); mreader.ReadBytes(mgram); try { defaultshader = mtext.CreateShader(dgram, mgram); mtext.InitializeLayout(dgram); defaultshader.Apply(); mtext.OnRenderFrame += onrenderframe; } catch (Exception er) { Windows.UI.Popups.MessageDialog mdlg = new Windows.UI.Popups.MessageDialog(er.ToString(), "Fatal error"); mdlg.ShowAsync().Start(); } IStorageFile[] files = (await folder.GetFilesAsync()).ToArray(); bool founddata = false; foreach (IStorageFile et in files) { if (et.FileName.Contains("rawimage.dat")) { stream = await et.OpenAsync(FileAccessMode.Read); founddata = true; } } int width; int height; byte[] rawdata; if (!founddata) { file = await folder.GetFileAsync("TestProgram\\test.png"); stream = await file.OpenAsync(FileAccessMode.Read); var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(stream); var pixeldata = await decoder.GetPixelDataAsync(Windows.Graphics.Imaging.BitmapPixelFormat.Rgba8, Windows.Graphics.Imaging.BitmapAlphaMode.Straight, new Windows.Graphics.Imaging.BitmapTransform(), Windows.Graphics.Imaging.ExifOrientationMode.IgnoreExifOrientation, Windows.Graphics.Imaging.ColorManagementMode.DoNotColorManage); width = (int)decoder.PixelWidth; height = (int)decoder.PixelHeight; rawdata = pixeldata.DetachPixelData(); file = await folder.CreateFileAsync("rawimage.dat"); stream = (await file.OpenAsync(FileAccessMode.ReadWrite)); var realstream = stream.GetOutputStreamAt(0); DataWriter mwriter = new DataWriter(realstream); mwriter.WriteInt32(width); mwriter.WriteInt32(height); mwriter.WriteBytes(rawdata); await mwriter.StoreAsync(); await realstream.FlushAsync(); } else { DataReader treader = new DataReader(stream.GetInputStreamAt(0)); await treader.LoadAsync((uint)stream.Size); rawdata = new byte[stream.Size - (sizeof(int) * 2)]; width = treader.ReadInt32(); height = treader.ReadInt32(); treader.ReadBytes(rawdata); } Texture2D mtex = maincontext.createTexture2D(rawdata, width, height); List <VertexPositionNormalTexture> triangle = new List <VertexPositionNormalTexture>(); triangle.Add(new VertexPositionNormalTexture(new Vector3(-.5f, -.5f, 0), new Vector3(1, 1, 1), new Vector2(0, 0))); triangle.Add(new VertexPositionNormalTexture(new Vector3(0, 0.5f, 0), new Vector3(1, 1, 1), new Vector2(1, 0))); triangle.Add(new VertexPositionNormalTexture(new Vector3(.5f, -0.5f, 0), new Vector3(1, 1, 1), new Vector2(1, 1))); byte[] gpudata = VertexPositionNormalTexture.Serialize(triangle.ToArray()); VertexBuffer mbuffer = maincontext.createVertexBuffer(gpudata, VertexPositionNormalTexture.Size); mbuffer.Apply(VertexPositionNormalTexture.Size); vertcount = 3; Windows.UI.Popups.MessageDialog tdlg = new Windows.UI.Popups.MessageDialog("Unit tests successfully completed\nShader creation: Success\nTexture load: Success\nVertex buffer creation: Success\nTime:" + (DateTime.Now - started).ToString(), "Results"); tdlg.ShowAsync().Start(); } catch (Exception er) { Windows.UI.Popups.MessageDialog tdlg = new Windows.UI.Popups.MessageDialog(er.ToString(), "Fatal error"); tdlg.ShowAsync().Start(); } }