|
public ReadAsync ( [ buffer, [ count, [ options ) : uint>.IAsyncOperationWithProgress |
||
| buffer | [ | |
| count | [ | |
| options | [ | |
| Résultat | uint>.IAsyncOperationWithProgress | |
public static async Task<IBuffer> SaveAsPngIntoBufferAsync(this Canvas canvas, double _scaleFactor, int dpiForImage = 200)
{
//string currentresolution = Window.Current.Bounds.Width * scaleFactor + "*" + Window.Current.Bounds.Height * scaleFactor;
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
await renderTargetBitmap.RenderAsync(canvas);
var pixels = await renderTargetBitmap.GetPixelsAsync();
using (IRandomAccessStream stream = new InMemoryRandomAccessStream())
{
var encoder = await
BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
byte[] bytes = pixels.ToArray();
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
encoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Ignore,
(uint)(canvas.ActualWidth * _scaleFactor), (uint)(canvas.ActualHeight * _scaleFactor),
dpiForImage, dpiForImage, bytes);
});
await encoder.FlushAsync();
stream.Seek(0);
var buffer = WindowsRuntimeBuffer.Create((int)stream.Size);
await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None);
return buffer;
}
}
private async void GetBijinPicture()
{
var date = DateTime.Now;
var url = "http://www.bijint.com/jp/tokei_images/" + date.ToString("HHmm") + ".jpg";
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/jp/");
using (var strm = await client.GetStreamAsync(new Uri(url)))
{
// BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、
// InMemoryRandomAccessStreamへソースストリームをコピーする
InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream();
var output = ims.GetOutputStreamAt(0);
await RandomAccessStream.CopyAsync(strm.AsInputStream(), output);
// BitmapImageへソースを設定し、Imageコントロールで表示させる
var bitmap = new BitmapImage();
bitmap.SetSource(ims);
image.Source = bitmap;
// Save用にbyte配列に保存
ims.Seek(0);
imageBuffer = new byte[ims.Size];
IBuffer ibuffer = imageBuffer.AsBuffer();
await ims.ReadAsync(ibuffer, (uint)ims.Size, InputStreamOptions.None);
}
}
public async static Task<Uri> ToQrDataUri(this ISdp sdp, int width, int height)
{
var qrCodeWriter = new QRCodeWriter();
var bitMatrix = qrCodeWriter.encode(sdp.ToString(), ZXing.BarcodeFormat.QR_CODE, width, height);
using (var canvasRenderTarget = new CanvasRenderTarget(CanvasDevice.GetSharedDevice(), 500, 500, 96))
{
using (var drawingSession = canvasRenderTarget.CreateDrawingSession())
{
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
drawingSession.DrawRectangle(x, y, 1, 1, bitMatrix.get(x, y) ? Color.FromArgb(0, 0, 0, 0) : Color.FromArgb(255, 255, 255, 255));
}
}
}
using (var inMemoryRandomAccessStream = new InMemoryRandomAccessStream())
{
await canvasRenderTarget.SaveAsync(inMemoryRandomAccessStream, CanvasBitmapFileFormat.Png);
inMemoryRandomAccessStream.Seek(0);
var buffer = new byte[inMemoryRandomAccessStream.Size];
await inMemoryRandomAccessStream.ReadAsync(buffer.AsBuffer(), (uint)inMemoryRandomAccessStream.Size, InputStreamOptions.None);
return new Uri($"data:image/png;base64,{Convert.ToBase64String(buffer)}");
}
}
}
private async void SaveSoftwareBitmapToFile(SoftwareBitmap softwareBitmap)
{
using (var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
// (IRandomAccessStream stream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
// Create an encoder with the desired format
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, memStream);
// Set the software bitmap
encoder.SetSoftwareBitmap(softwareBitmap);
// Set additional encoding parameters, if needed
encoder.BitmapTransform.ScaledWidth = 320;
encoder.BitmapTransform.ScaledHeight = 240;
//encoder.BitmapTransform.Rotation = Windows.Graphics.Imaging.BitmapRotation.Clockwise90Degrees;
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Fant;
encoder.IsThumbnailGenerated = true;
try
{
await encoder.FlushAsync();
// UploadImage
// An array containing the decoded image data, which could be modified before being displayed
IBuffer buff = new Windows.Storage.Streams.Buffer((uint)memStream.Size);
memStream.Seek(0);
IBuffer c = await memStream.ReadAsync(buff, buff.Capacity, InputStreamOptions.None);
//WindowsRuntimeBufferExtensions.ToArray http://cctvapi.azurewebsites.net
//await UploadImage("http://localhost:56407/Api/File/", buff.ToArray()) ; http://peopledetectionapiapp.azurewebsites.net/swagger/ui/index
//await UploadImage("http://cctvapi.azurewebsites.net/Api/File/", buff.ToArray());
await UploadImage("http://peopledetectionapiapp.azurewebsites.net/swagger/ui/index", buff.ToArray());
}
catch (Exception err)
{
switch (err.HResult)
{
case unchecked ((int)0x88982F81): //WINCODEC_ERR_UNSUPPORTEDOPERATION
// If the encoder does not support writing a thumbnail, then try again
// but disable thumbnail generation.
encoder.IsThumbnailGenerated = false;
break;
default:
throw err;
}
}
if (encoder.IsThumbnailGenerated == false)
{
await encoder.FlushAsync();
}
}
}
private async Task<byte[]> EncodeToBytes(VideoFrame frame)
{
byte[] array;
using (var stream = new InMemoryRandomAccessStream())
{
var encoder = await CreateBitmapEncoder(stream);
encoder.SetSoftwareBitmap(frame.SoftwareBitmap);
await encoder.FlushAsync();
array = new byte[stream.Size];
await stream.ReadAsync(array.AsBuffer(), (uint) stream.Size, InputStreamOptions.None);
}
return array;
}
private async void ViewFinder_OnTapped()
{
ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg();
var stream = new InMemoryRandomAccessStream();
await captureManager.CapturePhotoToStreamAsync(imageProperties, stream);
_bitmap = new WriteableBitmap(300, 300);
stream.Seek(0);
await _bitmap.SetSourceAsync(stream);
stream.Seek(0);
var buffer = new global::Windows.Storage.Streams.Buffer((uint)stream.Size);
stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None);
await captureManager.StopPreviewAsync();
}
public static async Task<string> ToBase64StringAsync(this WriteableBitmap writeableBitmap)
{
if (writeableBitmap == null)
{
return null;
}
using (var stream = new InMemoryRandomAccessStream())
{
await writeableBitmap.ToStreamAsJpeg(stream);
var bytes = new byte[stream.Size];
await stream.ReadAsync(bytes.AsBuffer(), (uint)stream.Size, InputStreamOptions.None);
return Convert.ToBase64String(bytes, 0, bytes.Length);
}
}
/// <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>
public static async Task<ImageInfo> ResizeAsync(this byte[] imageData, Size newSize, bool keepAspectRatio)
{
var result = new ImageInfo();
var decoder = await BitmapDecoder.CreateAsync(await imageData.AsRandomAccessStreamAsync());
var percentWidth = (double)newSize.Width / (double)decoder.PixelWidth;
var percentHeight = (double)newSize.Height / (double)decoder.PixelHeight;
if (keepAspectRatio)
{
result.Size = percentWidth < percentHeight
? new Size(newSize.Width, (int)(decoder.PixelHeight * percentWidth))
: new Size((int)(decoder.PixelWidth * percentHeight), newSize.Height);
}
else
{
result.Size = newSize;
}
var transform = new BitmapTransform { ScaledWidth = (uint)result.Size.Width, ScaledHeight = (uint)result.Size.Height };
var pixelData = await decoder.GetPixelDataAsync(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage);
using (var destinationStream = new InMemoryRandomAccessStream())
{
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, destinationStream);
encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, (uint)result.Size.Width, (uint)result.Size.Height, 96, 96, pixelData.DetachPixelData());
await encoder.FlushAsync();
var data = new byte[destinationStream.Size];
destinationStream.Seek(0);
await destinationStream.ReadAsync(data.AsBuffer(), (uint)destinationStream.Size, InputStreamOptions.None);
result.Data = data;
}
return result;
}
private async Task<bool> LoadImageFromHttpResponse(HttpResponseMessage response, Tile tile, BitmapSource image, string cacheKey)
{
using (var stream = new InMemoryRandomAccessStream())
{
using (var content = response.Content)
{
await content.WriteToStreamAsync(stream);
}
await stream.FlushAsync();
stream.Seek(0);
var loaded = await LoadImageFromStream(tile, image, stream);
if (loaded && cacheKey != null)
{
var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size);
stream.Seek(0);
await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None);
var maxAge = DefaultCacheExpiration;
if (response.Headers.CacheControl.MaxAge.HasValue &&
response.Headers.CacheControl.MaxAge.Value < maxAge)
{
maxAge = response.Headers.CacheControl.MaxAge.Value;
}
await Cache.SetAsync(cacheKey, buffer, DateTime.UtcNow.Add(maxAge));
}
return loaded;
}
}
protected async Task<byte[]> ConvertImageBufferToJpegBytes(IBuffer imageBuffer)
{
using (var stream = imageBuffer.AsStream().AsRandomAccessStream())
{
var decoder = await BitmapDecoder.CreateAsync(stream);
var pixels = await decoder.GetPixelDataAsync();
using (var output = new InMemoryRandomAccessStream())
{
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, output);
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore,
decoder.OrientedPixelWidth, decoder.OrientedPixelHeight, decoder.DpiX, decoder.DpiY, pixels.DetachPixelData());
});
await encoder.FlushAsync();
var buffer = WindowsRuntimeBuffer.Create((int)output.Size);
output.Seek(0);
await output.ReadAsync(buffer, (uint)output.Size, InputStreamOptions.None);
return buffer.ToArray();
}
}
}
private async static Task<byte[]> ImageToScaledPixels(BitmapDecoder decoder, uint newWidth)
{
using (var encoderStream = new InMemoryRandomAccessStream())
{
var encoder = await BitmapEncoder.CreateForTranscodingAsync(encoderStream, decoder);
var scaleFactor = decoder.PixelWidth / (double)newWidth;
uint newHeight = (uint)(decoder.PixelHeight / scaleFactor);
encoder.BitmapTransform.ScaledWidth = newWidth;
encoder.BitmapTransform.ScaledHeight = newHeight;
await encoder.FlushAsync();
byte[] pixels = new byte[encoderStream.Size];
await encoderStream.ReadAsync(pixels.AsBuffer(), (uint)pixels.Length, InputStreamOptions.None);
return pixels;
}
}
private async Task<byte[]> SaveSoftwareBitmapToBufferAsync(SoftwareBitmap softwareBitmap)
{
byte[] bytes = null;
try
{
IRandomAccessStream stream = new InMemoryRandomAccessStream();
{
// Create an encoder with the desired format
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, stream);
// Set the software bitmap
encoder.SetSoftwareBitmap(softwareBitmap);
// Set additional encoding parameters, if needed
//encoder.BitmapTransform.ScaledWidth = (uint)_width;
//encoder.BitmapTransform.ScaledHeight = (uint)_height;
//encoder.BitmapTransform.Rotation = Windows.Graphics.Imaging.BitmapRotation.Clockwise90Degrees;
//encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Fant;
encoder.IsThumbnailGenerated = false;
await encoder.FlushAsync();
bytes = new byte[stream.Size];
// This returns IAsyncOperationWithProgess, so you can add additional progress handling
await stream.ReadAsync(bytes.AsBuffer(), (uint)stream.Size, Windows.Storage.Streams.InputStreamOptions.None);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
return bytes;
}
private async Task<byte[]> GetImageAsByteAsync(Guid format, int quality, int desiredWidth, int desiredHeight)
{
if (internalImage == null || internalImage.Source == null)
return null;
var bitmap = internalImage.Source as WriteableBitmap;
if (bitmap == null)
return null;
byte[] pixels = null;
uint pixelsWidth = (uint)bitmap.PixelWidth;
uint pixelsHeight = (uint)bitmap.PixelHeight;
if (desiredWidth != 0 || desiredHeight != 0)
{
double widthRatio = (double)desiredWidth / (double)bitmap.PixelWidth;
double heightRatio = (double)desiredHeight / (double)bitmap.PixelHeight;
double scaleRatio = Math.Min(widthRatio, heightRatio);
if (desiredWidth == 0)
scaleRatio = heightRatio;
if (desiredHeight == 0)
scaleRatio = widthRatio;
uint aspectWidth = (uint)((double)bitmap.PixelWidth * scaleRatio);
uint aspectHeight = (uint)((double)bitmap.PixelHeight * scaleRatio);
using (var tempStream = new InMemoryRandomAccessStream())
{
byte[] tempPixels = await GetBytesFromBitmapAsync(bitmap);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, tempStream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied,
pixelsWidth, pixelsHeight, 96, 96, tempPixels);
await encoder.FlushAsync();
tempStream.Seek(0);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(tempStream);
BitmapTransform transform = new BitmapTransform()
{
ScaledWidth = aspectWidth,
ScaledHeight = aspectHeight,
InterpolationMode = BitmapInterpolationMode.Linear
};
PixelDataProvider pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied,
transform,
ExifOrientationMode.RespectExifOrientation,
ColorManagementMode.DoNotColorManage);
pixels = pixelData.DetachPixelData();
pixelsWidth = aspectWidth;
pixelsHeight = aspectHeight;
}
}
else
{
pixels = await GetBytesFromBitmapAsync(bitmap);
}
using (var stream = new InMemoryRandomAccessStream())
{
var encoder = await BitmapEncoder.CreateAsync(format, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied,
pixelsWidth, pixelsHeight, 96, 96, pixels);
await encoder.FlushAsync();
stream.Seek(0);
var bytes = new byte[stream.Size];
await stream.ReadAsync(bytes.AsBuffer(), (uint)stream.Size, InputStreamOptions.None);
return bytes;
}
}
/// <summary>
/// Takes a photo to a StorageFile and adds rotation metadata to it
/// </summary>
/// <returns></returns>
private async Task TakePhotoAsync()
{
// While taking a photo, keep the video button enabled only if the camera supports simultaneosly taking pictures and recording video
VideoButton.IsEnabled = _mediaCapture.MediaCaptureSettings.ConcurrentRecordAndPhotoSupported;
// Make the button invisible if it's disabled, so it's obvious it cannot be interacted with
VideoButton.Opacity = VideoButton.IsEnabled ? 1 : 0;
var stream = new InMemoryRandomAccessStream();
try
{
Debug.WriteLine("Taking photo...");
await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream);
Debug.WriteLine("Photo taken!");
byte[] bytes = new byte[stream.Size];
stream.Seek(0);
var buffer = await stream.ReadAsync(bytes.AsBuffer(), (uint)stream.Size, InputStreamOptions.None);
bytes = buffer.ToArray();
var photoOrientation = ConvertOrientationToPhotoOrientation(GetCameraOrientation());
await ReencodeAndSavePhotoAsync(stream, photoOrientation);
}
catch (Exception ex)
{
Debug.WriteLine("Exception when taking a photo: {0}", ex.ToString());
}
// Done taking a photo, so re-enable the button
VideoButton.IsEnabled = true;
VideoButton.Opacity = 1;
}
private async Task SendPhotoAsync()
{
nowTime = DateTime.Now;
if (nowTime.Subtract(preTime).TotalSeconds < 10) return;
if (_isSendingPhoto) return;
_isSendingPhoto = true;
preTime = DateTime.Now;
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
try
{
Debug.WriteLine("Taking photo...");
await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream);
Debug.WriteLine("Photo taken!");
byte[] bytes = new byte[stream.Size];
stream.Seek(0);
var buffer = await stream.ReadAsync(bytes.AsBuffer(), (uint)stream.Size, InputStreamOptions.None);
bytes = buffer.ToArray();
Debug.WriteLine("bytes ok!");
HttpWebResponse response = null;
HttpWebRequest request = null;
Stream outstream = null;
StreamReader sr = null;
request = WebRequest.Create(uploadAddress) as HttpWebRequest;
request.ContentType = "application/octet-stream";
request.Method = "POST";
outstream = await request.GetRequestStreamAsync();
await outstream.WriteAsync(bytes, 0, bytes.Length);
////发送请求并获取相应回应数据
response = await request.GetResponseAsync() as HttpWebResponse;
Stream instream = response.GetResponseStream();
Encoding encoding = Encoding.UTF8;
sr = new StreamReader(instream, encoding);
//返回结果网页（html）代码
string content = sr.ReadToEnd();
Debug.WriteLine("result :{0} ", content);
JsonArray jArray = JsonArray.Parse(content);
if (jArray != null & jArray.Count >= 1)
{
String stringa = jArray.GetStringAt(0);
if (!stringa.Equals("Invalid"))
{
string playContent = "Welcome";// "欢迎";
int totalNum = jArray.Count; int strangerNum = 0;
for (uint i = 0; i < totalNum; i++)
{
string tempString = jArray.GetStringAt(i);
if (tempString.Equals("Stranger")) strangerNum++;
else playContent += " "+tempString;
}
if (totalNum == strangerNum)
playContent += " " + strangerNum + " friends to my home";// "位朋友莅临寒舍";
else if (strangerNum == 0) playContent += " to my home";// "莅临寒舍";
else playContent += " and other " + strangerNum + " friends to my home"; // "以及其他"+strangerNum+ "位朋友莅临寒舍";
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { this.infoshowText.Text = playContent; PlayTTS(playContent);});
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception when taking a photo: {0}", ex.ToString());
}
_isSendingPhoto = false;
}
private async Task SendPhotoAsync()
{
nowTime = DateTime.Now;
if (nowTime.Subtract(preTime).TotalSeconds < 10) return;
if (_isSendingPhoto) return;
_isSendingPhoto = true;
// While taking a photo, keep the video button enabled only if the camera supports simultaneosly taking pictures and recording video
//VideoButton.IsEnabled = _mediaCapture.MediaCaptureSettings.ConcurrentRecordAndPhotoSupported;
preTime = DateTime.Now;
// Make the button invisible if it's disabled, so it's obvious it cannot be interacted with
//VideoButton.Opacity = VideoButton.IsEnabled ? 1 : 0;
//InMemoryRandomAccessStream MemoryStream
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
try
{
Debug.WriteLine("Taking photo...");
await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream);
Debug.WriteLine("Photo taken!");
byte[] bytes = new byte[stream.Size];
stream.Seek(0);
var buffer = await stream.ReadAsync(bytes.AsBuffer(), (uint)stream.Size, InputStreamOptions.None);
bytes = buffer.ToArray();
Debug.WriteLine("bytes ok!");
//string teststring = "[\"Stranger\",\"Stranger\"]";
//JsonArray jArray = JsonArray.Parse(teststring);
//String stringa = jArray.GetStringAt(0);
//await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { this.infoshowText.Text = stringa; });
//_isSendingPhoto = false;
//return ;
//string content = "欢迎王总莅临寒舍！";
//await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { this.infoshowText.Text = content; });
//await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { PlayTTS(content); });
//_isSendingPhoto = false;
//return ;
HttpWebResponse response = null;
HttpWebRequest request = null;
Stream outstream = null;
StreamReader sr = null;
string requestUri = "http://facedetectionoffice.azurewebsites.net/api/FaceDetection/FaceUpload?DeviceId=3d16334ca04a412388bae34d0dbf300f";
request = WebRequest.Create(requestUri) as HttpWebRequest;
request.ContentType = "application/octet-stream";
request.Method = "POST";
outstream = await request.GetRequestStreamAsync();
await outstream.WriteAsync(bytes, 0, bytes.Length);
////发送请求并获取相应回应数据
response = await request.GetResponseAsync() as HttpWebResponse;
Stream instream = response.GetResponseStream();
Encoding encoding = Encoding.UTF8;
sr = new StreamReader(instream, encoding);
//返回结果网页（html）代码
string content = sr.ReadToEnd();
Debug.WriteLine("result :{0} ", content);
JsonArray jArray = JsonArray.Parse(content);
if (jArray != null & jArray.Count >= 1)
{
String stringa = jArray.GetStringAt(0);
if (!stringa.Equals("Invalid"))
{
string playContent = "Welcome";// "欢迎";
int totalNum = jArray.Count; int strangerNum = 0;
for (uint i = 0; i < totalNum; i++)
{
string tempString = jArray.GetStringAt(i);
if (tempString.Equals("Stranger")) strangerNum++;
else playContent += " "+tempString;
}
if (totalNum == strangerNum)
playContent += " " + strangerNum + " friends to my home";// "位朋友莅临寒舍";
else if (strangerNum == 0) playContent += " to my home";// "莅临寒舍";
else playContent += " and other " + strangerNum + " friends to my home"; // "以及其他"+strangerNum+ "位朋友莅临寒舍";
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { this.infoshowText.Text = playContent; PlayTTS(playContent);});
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception when taking a photo: {0}", ex.ToString());
}
_isSendingPhoto = false;
// Done taking a photo, so re-enable the button
//VideoButton.IsEnabled = true;
//VideoButton.Opacity = 1;
}
private async Task LoadImageFromHttpResponse(HttpResponseMessage response, BitmapImage bitmap, string cacheKey)
{
if (response.IsSuccessStatusCode)
{
var stream = new InMemoryRandomAccessStream();
using (var content = response.Content)
{
await content.WriteToStreamAsync(stream);
}
await stream.FlushAsync();
stream.Seek(0);
await bitmap.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async () =>
{
try
{
await bitmap.SetSourceAsync(stream);
// cache image asynchronously, after successful decoding
var task = Task.Run(async () =>
{
var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size);
stream.Seek(0);
await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None);
stream.Dispose();
await Cache.SetAsync(cacheKey, buffer);
});
}
catch (Exception ex)
{
Debug.WriteLine("{0}: {1}", response.RequestMessage.RequestUri, ex.Message);
stream.Dispose();
}
});
}
else
{
Debug.WriteLine("{0}: {1}", response.RequestMessage.RequestUri, response.StatusCode);
}
}
public static async Task<byte[]> ResizeImageWindows(byte[] imageData, float width, float height)
{
byte[] resizedData;
using (var streamIn = new MemoryStream(imageData))
{
using (var imageStream = streamIn.AsRandomAccessStream())
{
var decoder = await BitmapDecoder.CreateAsync(imageStream);
var resizedStream = new InMemoryRandomAccessStream();
var encoder = await BitmapEncoder.CreateForTranscodingAsync(resizedStream, decoder);
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Linear;
encoder.BitmapTransform.ScaledHeight = (uint)height;
encoder.BitmapTransform.ScaledWidth = (uint)width;
await encoder.FlushAsync();
resizedStream.Seek(0);
resizedData = new byte[resizedStream.Size];
await resizedStream.ReadAsync(resizedData.AsBuffer(), (uint)resizedStream.Size, InputStreamOptions.None);
}
}
return resizedData;
}
public void PrintMicrophoneSample()
{
MediaCapture capture;
IRandomAccessStream stream;
const int BufferSize = 64000;
bool recording;
float volume = 100;
capture = new MediaCapture();
stream = new InMemoryRandomAccessStream();
var captureInitSettings2 = new MediaCaptureInitializationSettings();
captureInitSettings2.StreamingCaptureMode = StreamingCaptureMode.Audio;
capture.InitializeAsync(captureInitSettings2).AsTask().Wait();
capture.AudioDeviceController.VolumePercent = volume;
MediaEncodingProfile profile = new MediaEncodingProfile();
AudioEncodingProperties audioProperties = AudioEncodingProperties.CreatePcm(16000, 1, 16);
profile.Audio = audioProperties;
profile.Video = null;
profile.Container = new ContainerEncodingProperties() { Subtype = MediaEncodingSubtypes.Wave };
capture.StartRecordToStreamAsync(profile, stream).GetResults();
recording = true;
// waste time
for (int i = 0; i < 5; i++)
{
i = i * 232323 + 89;// WriteLine(i);
}
capture.StopRecordAsync().GetResults();
byte[] wav = new byte[stream.Size];
stream.Seek(0);
stream.ReadAsync(wav.AsBuffer(), (uint)stream.Size, InputStreamOptions.None).GetResults();
int sum = 0;
for(int i = 0; i < wav.Count(); i++)
{
sum += (int) wav[i];
}
WriteLine((double) wav.Count() / sum);
}
