// </SnippetReadImageMetadata>
// <SnippetWriteImageMetadata>
private async void WriteImageMetadata(BitmapEncoder bitmapEncoder)
{
var propertySet = new Windows.Graphics.Imaging.BitmapPropertySet();
var orientationValue = new Windows.Graphics.Imaging.BitmapTypedValue(
1, // Defined as EXIF orientation = "normal"
Windows.Foundation.PropertyType.UInt16
);
propertySet.Add("System.Photo.Orientation", orientationValue);
try
{
await bitmapEncoder.BitmapProperties.SetPropertiesAsync(propertySet);
}
catch (Exception err)
{
switch (err.HResult)
{
case unchecked ((int)0x88982F41): // WINCODEC_ERR_PROPERTYNOTSUPPORTED
// The file format does not support this property.
break;
default:
throw err;
}
}
}
/// <summary>
/// Write the location metadata to the image file
/// </summary>
public async static Task WriteSurveyPhotoMetaData(StorageFile file, Geoposition pos, string surveyId = "")
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
var decoder = await BitmapDecoder.CreateAsync(stream);
var encoder = await BitmapEncoder.CreateForTranscodingAsync(stream, decoder);
// Write the gps data
var propertySet = new BitmapPropertySet();
var latitudeNumerator = new BitmapTypedValue(CoordDoubleToIntArray(pos.Coordinate.Latitude), PropertyType.Int32Array);
var latitudeRef = new BitmapTypedValue("N", PropertyType.String);
var longitudeNumerator = new BitmapTypedValue(CoordDoubleToIntArray(pos.Coordinate.Longitude), PropertyType.Int32Array);
var longitudeRef = new BitmapTypedValue("W", PropertyType.String);
propertySet.Add("System.GPS.LatitudeNumerator", latitudeNumerator);
propertySet.Add("System.GPS.LatitudeRef", latitudeRef);
propertySet.Add("System.GPS.LatitudeDenominator", new BitmapTypedValue(new [] { 1, 1, 10000 }, PropertyType.Int32Array));
propertySet.Add("System.GPS.LongitudeNumerator", longitudeNumerator);
propertySet.Add("System.GPS.LongitudeRef", longitudeRef);
propertySet.Add("System.GPS.LongitudeDenominator", new BitmapTypedValue(new[] { 1, 1, 10000 }, PropertyType.Int32Array));
// Write the surveyId data
if (!string.IsNullOrEmpty(surveyId))
{
var surveyIdTyped = new BitmapTypedValue(surveyId, Windows.Foundation.PropertyType.String);
propertySet.Add("System.Comment", surveyIdTyped);
}
await encoder.BitmapProperties.SetPropertiesAsync(propertySet);
await encoder.FlushAsync();
}
}
private BitmapPropertySet CreateBitmapPropertySet()
{
var propertySet = new BitmapPropertySet();
var qualityValue = new BitmapTypedValue(configuration.VideoQuality, PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
return propertySet;
}
private async void WriteImageMetadata(BitmapEncoder bitmapEncoder, BitmapPropertiesView inputProperties)
{
var propertySet = new Windows.Graphics.Imaging.BitmapPropertySet();
var requests = new System.Collections.Generic.List <string>();
requests.Add("System.Photo.Orientation");
var retrievedProps = await inputProperties.GetPropertiesAsync(requests);
if (retrievedProps.ContainsKey("System.Photo.Orientation"))
{
propertySet.Add("System.Photo.Orientation", retrievedProps["System.Photo.Orientation"]);
}
else
{
var orientationValue = new Windows.Graphics.Imaging.BitmapTypedValue(
1, // Defined as EXIF orientation = "normal"
Windows.Foundation.PropertyType.UInt16
);
propertySet.Add("System.Photo.Orientation", orientationValue);
}
if (date.Date != null)
{
var datetaken = new Windows.Graphics.Imaging.BitmapTypedValue(
date.Date,
Windows.Foundation.PropertyType.DateTime
);
propertySet.Add("System.Photo.DateTaken", datetaken);
}
var qualityValue = new Windows.Graphics.Imaging.BitmapTypedValue(
1.0, // Maximum quality
Windows.Foundation.PropertyType.Single
);
var location = new Windows.Graphics.Imaging.BitmapTypedValue(
1.0, // Maximum quality
Windows.Foundation.PropertyType.Single
);
propertySet.Add("ImageQuality", qualityValue);
try
{
await bitmapEncoder.BitmapProperties.SetPropertiesAsync(propertySet);
}
catch (Exception err)
{
switch (err.HResult)
{
case unchecked ((int)0x88982F41): // WINCODEC_ERR_PROPERTYNOTSUPPORTED
// The file format does not support the requested metadata.
break;
case unchecked ((int)0x88982F81): // WINCODEC_ERR_UNSUPPORTEDOPERATION
// The file format does not support any metadata.
break;
}
}
}
internal static async Task LoadTileImageInternalAsync(string imagePath)
{
string tileName = "dreaming";
uint MaxImageWidth =360;
uint MaxImageHeight = 600;
StorageFile origFile = await ApplicationData.Current.LocalFolder.GetFileAsync(imagePath);
// open file for the new tile image file
StorageFile tileFile = await Windows.Storage.KnownFolders.PicturesLibrary.CreateFileAsync(tileName, CreationCollisionOption.GenerateUniqueName);
using (IRandomAccessStream tileStream = await tileFile.OpenAsync(FileAccessMode.ReadWrite))
{
// get width and height from the original image
IRandomAccessStreamWithContentType stream = await origFile.OpenReadAsync();
ImageProperties properties = await origFile.Properties.GetImagePropertiesAsync();
uint width = properties.Width;
uint height = properties.Height;
// get proper decoder for the input file - jpg/png/gif
BitmapDecoder decoder = await GetProperDecoder(stream, origFile );
if (decoder == null) return; // should not happen
// get byte array of actual decoded image
PixelDataProvider data = await decoder.GetPixelDataAsync();
byte[] bytes = data.DetachPixelData();
// create encoder for saving the tile image
BitmapPropertySet propertySet = new BitmapPropertySet();
// create class representing target jpeg quality - a bit obscure, but it works
BitmapTypedValue qualityValue = new BitmapTypedValue(0.5, PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
// create the target jpeg decoder
BitmapEncoder be = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, tileStream, propertySet);
be.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, width, height, 96.0, 96.0, bytes);
// crop the image, if it's too big
if (width > MaxImageWidth || height > MaxImageHeight)
{
BitmapBounds bounds = new BitmapBounds();
if (width > MaxImageWidth)
{
bounds.Width = MaxImageWidth;
bounds.X = (width - MaxImageWidth) / 2;
}
else bounds.Width = width;
if (height > MaxImageHeight)
{
bounds.Height = MaxImageHeight;
bounds.Y = (height - MaxImageHeight) / 2;
}
else bounds.Height = height;
be.BitmapTransform.Bounds = bounds;
}
// save the target jpg to the file
await be.FlushAsync();
}
}
public static async Task WriteableBitmapToStorageFile(WriteableBitmap WB, FileFormat fileFormat, int compression, StorageFile file)
{
string FileName = "YourFile.";
Guid BitmapEncoderGuid = BitmapEncoder.JpegEncoderId;
switch (fileFormat)
{
case FileFormat.Jpeg:
FileName += "jpeg";
BitmapEncoderGuid = BitmapEncoder.JpegEncoderId;
break;
case FileFormat.Png:
FileName += "png";
BitmapEncoderGuid = BitmapEncoder.PngEncoderId;
break;
case FileFormat.Bmp:
FileName += "bmp";
BitmapEncoderGuid = BitmapEncoder.BmpEncoderId;
break;
case FileFormat.Tiff:
FileName += "tiff";
BitmapEncoderGuid = BitmapEncoder.TiffEncoderId;
break;
case FileFormat.Gif:
FileName += "gif";
BitmapEncoderGuid = BitmapEncoder.GifEncoderId;
break;
}
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
var propertySet = new Windows.Graphics.Imaging.BitmapPropertySet();
var qualityValue = new Windows.Graphics.Imaging.BitmapTypedValue(
1 - (compression / 100),
Windows.Foundation.PropertyType.Single
);
propertySet.Add("ImageQuality", qualityValue);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoderGuid, stream, propertySet);
Stream pixelStream = WB.PixelBuffer.AsStream();
byte[] pixels = new byte[pixelStream.Length];
await pixelStream.ReadAsync(pixels, 0, pixels.Length);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)WB.PixelWidth, (uint)WB.PixelHeight,
96.0,
96.0,
pixels);
await encoder.FlushAsync();
}
}
// </SnippetSaveSoftwareBitmapToFile>
private async void UseEncodingOptions(StorageFile outputFile)
{
using (IRandomAccessStream stream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
// <SnippetUseEncodingOptions>
var propertySet = new Windows.Graphics.Imaging.BitmapPropertySet();
var qualityValue = new Windows.Graphics.Imaging.BitmapTypedValue(
1.0, // Maximum quality
Windows.Foundation.PropertyType.Single
);
propertySet.Add("ImageQuality", qualityValue);
await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync(
Windows.Graphics.Imaging.BitmapEncoder.JpegEncoderId,
stream,
propertySet
);
// </SnippetUseEncodingOptions>
}
}
public static async Task<string> HttpPost(StorageFile inFile)
{
HttpClient httpClient = new HttpClient();
uint MaxImageWidth = 480;
uint MaxImageHeight = 800;
uint width;
uint height;
string posturi = Config.apiChatImage;
HttpMultipartFormDataContent fileContent = new HttpMultipartFormDataContent();
var inStream = await inFile.OpenReadAsync();
InMemoryRandomAccessStream outStream = new InMemoryRandomAccessStream();
BitmapDecoder decoder = await ImageHelp.GetProperDecoder(inStream,inFile);
if (decoder.OrientedPixelWidth > MaxImageWidth && decoder.OrientedPixelHeight > MaxImageHeight)
{
width = MaxImageWidth;
height = MaxImageHeight;
}
else
{
width = decoder.OrientedPixelWidth;
height = decoder.OrientedPixelHeight;
}
PixelDataProvider provider = await decoder.GetPixelDataAsync();
byte[] data = provider.DetachPixelData(); //获取像素数据的字节数组
BitmapPropertySet propertySet = new BitmapPropertySet();
BitmapTypedValue qualityValue = new BitmapTypedValue(0.5, PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, outStream, propertySet);//建立编码器
encoder.SetPixelData(decoder.BitmapPixelFormat,
decoder.BitmapAlphaMode,
decoder.OrientedPixelWidth,
decoder.OrientedPixelHeight,
decoder.DpiX,
decoder.DpiY,
data
);
encoder.BitmapTransform.ScaledWidth = width;
encoder.BitmapTransform.ScaledHeight = height;
await encoder.FlushAsync();
HttpStreamContent streamContent1 = new HttpStreamContent(outStream);
fileContent.Add(streamContent1, "pic", inFile.Name);
HttpResponseMessage response = await httpClient.PostAsync(new Uri(posturi), fileContent);
return await response.Content.ReadAsStringAsync();
}
public async Task<string> GetImageAsBase64Encoded()
{
// Adapted from
// http social.msdn.microsoft.com/Forums/wpapps/en-US/.../image-to-base64-encoding [Win Phone 7, 2010] and
// <same site> /sharing-a-writeablebitmap and
// www.charlespetzold.com/blog/2012/08/WritableBitmap-Pixel-Arrays-in-CSharp-and-CPlusPlus.html
// example in WebcamPage.xaml.cs
string results = "";
try
{
//using (Stream stream = App.CurrentPatient.ImageWriteableBitmap.PixelBuffer.AsStream())
using (Stream stream = ImageWriteableBitmap.PixelBuffer.AsStream()) //There are 4 bytes per pixel.
{
byte[] pixels = await ConvertStreamToByteArray(stream);
// Now render the object in a known format, e.g., jpeg:
//InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream();
IRandomAccessStream ms = new InMemoryRandomAccessStream();
// If calling from a synchronous function, add AsTask().ConfigureAwait(false) to avoid hanging UI thread
// If image as optionally cropped is over 1.5Mp, then apply aggressive compression to get it to that size (approximately)
double quality = 1.0; //Max quality, the default. For jpeg, 1.0 - quality = compression ratio
UInt64 totalPixels = (ulong)ImageWriteableBitmap.PixelWidth * (ulong)ImageWriteableBitmap.PixelHeight;
if (totalPixels > 1500000L)
quality = Math.Round(((double)1500000.0 / (double)totalPixels), 2, MidpointRounding.AwayFromZero); // for debug purposes, round quality to 2 fractional digits
// For encoding options, wee msdn.microsoft.com/en-us/library/windows/apps/jj218354.aspx "How to use encoding options".
var encodingOptions = new BitmapPropertySet();
var qualityValue = new BitmapTypedValue(quality, Windows.Foundation.PropertyType.Single);
encodingOptions.Add("ImageQuality", qualityValue);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, ms, encodingOptions); //.AsTask().ConfigureAwait(false);
/*
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, ms); */
encoder.SetPixelData(
BitmapPixelFormat.Bgra8, //Rgba8, //Bgra8,
BitmapAlphaMode.Straight, // .Ignore
(uint)ImageWriteableBitmap.PixelWidth,//(uint)App.CurrentPatient.ImageWriteableBitmap.PixelWidth,
(uint)ImageWriteableBitmap.PixelHeight,//(uint)App.CurrentPatient.ImageWriteableBitmap.PixelHeight,
96.0, 96.0, pixels);
await encoder.FlushAsync(); //.AsTask().ConfigureAwait(false);
byte[] jpgEncoded = await ConvertMemoryStreamToByteArray(ms);
results = Convert.ToBase64String(jpgEncoded);
await ms.FlushAsync(); // cleanup
}
}
catch (Exception ex)
{
Debug.WriteLine("Error when encoding image: " + ex.Message);
}
return results;
}
/// <summary>
/// Applies the user-provided scale and rotation operation to the original image file.
/// The "Transcoding" mode is used which preserves image metadata and performs other
/// optimizations when possible.
///
/// This method attempts to perform "soft" rotation using the EXIF orientation flag when possible,
/// but falls back to a hard rotation of the image pixels.
/// </summary>
private async void Save_Click(object sender, RoutedEventArgs e)
{
try
{
rootPage.NotifyUser("Saving file...", NotifyType.StatusMessage);
// Create a new encoder and initialize it with data from the original file.
// The encoder writes to an in-memory stream, we then copy the contents to the file.
// This allows the application to perform in-place editing of the file: any unedited data
// is copied to the destination, and the original file is overwritten
// with updated data.
StorageFile file = await m_futureAccess.GetFileAsync(m_fileToken);
using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.ReadWrite),
memStream = new InMemoryRandomAccessStream())
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);
// Use the native (no orientation applied) image dimensions because we want to handle
// orientation ourselves.
uint originalWidth = decoder.PixelWidth;
uint originalHeight = decoder.PixelHeight;
// Set the encoder's destination to the temporary, in-memory stream.
BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder);
// Scaling occurs before flip/rotation, therefore use the original dimensions
// (no orientation applied) as parameters for scaling.
// Dimensions are rounded down by BitmapEncoder to the nearest integer.
if (m_scaleFactor != 1.0)
{
encoder.BitmapTransform.ScaledWidth = (uint)(originalWidth * m_scaleFactor);
encoder.BitmapTransform.ScaledHeight = (uint)(originalHeight * m_scaleFactor);
// Fant is a relatively high quality interpolation mode.
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Fant;
}
// If the file format supports EXIF orientation ("System.Photo.Orientation") then
// update the orientation flag to reflect any user-specified rotation.
// Otherwise, perform a hard rotate using BitmapTransform.
if (m_disableExifOrientation == false)
{
BitmapPropertySet properties = new BitmapPropertySet();
ushort netExifOrientation = Helpers.ConvertToExifOrientationFlag(
Helpers.AddPhotoOrientation(m_userRotation, m_exifOrientation)
);
// BitmapProperties requires the application to explicitly declare the type
// of the property to be written - this is different from FileProperties which
// automatically coerces the value to the correct type. System.Photo.Orientation
// is defined as an unsigned 16 bit integer.
BitmapTypedValue orientationTypedValue = new BitmapTypedValue(
netExifOrientation,
Windows.Foundation.PropertyType.UInt16
);
properties.Add("System.Photo.Orientation", orientationTypedValue);
await encoder.BitmapProperties.SetPropertiesAsync(properties);
}
else
{
encoder.BitmapTransform.Rotation = Helpers.ConvertToBitmapRotation(m_userRotation);
}
// Attempt to generate a new thumbnail to reflect any rotation operation.
encoder.IsThumbnailGenerated = true;
try
{
await encoder.FlushAsync();
}
catch (Exception err)
{
switch (err.HResult)
{
case 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;
}
}
if (encoder.IsThumbnailGenerated == false)
{
await encoder.FlushAsync();
}
// Now that the file has been written to the temporary stream, copy the data to the file.
memStream.Seek(0);
fileStream.Seek(0);
fileStream.Size = 0;
await RandomAccessStream.CopyAsync(memStream, fileStream);
}
// Because the original file has been overwritten, reload it in the UI.
ResetSessionState();
await DisplayImageFileAsync(file);
rootPage.NotifyUser("Successfully saved file: " + file.Name, NotifyType.StatusMessage);
}
catch (Exception err)
{
if (err.HResult == WINCODEC_ERR_COMPONENTNOTFOUND)
{
// Some image formats (e.g. ICO) do not have encoders.
rootPage.NotifyUser("Error: this file format may not support editing.", NotifyType.ErrorMessage);
}
else
{
rootPage.NotifyUser("Error: " + err.Message, NotifyType.ErrorMessage);
}
ResetPersistedState();
ResetSessionState();
}
}
private async Task<Stream> ConvertToJpeg(IRandomAccessStream stream)
{
var decoder = await BitmapDecoder.CreateAsync(stream);
var pixels = await decoder.GetPixelDataAsync();
var outStream = new InMemoryRandomAccessStream();
// create encoder for saving the tile image
var propertySet = new BitmapPropertySet();
// create class representing target jpeg quality - a bit obscure, but it works
var qualityValue = new BitmapTypedValue(.7, PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, outStream);
encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore,
decoder.OrientedPixelWidth, decoder.OrientedPixelHeight,
decoder.DpiX, decoder.DpiY,
pixels.DetachPixelData());
await encoder.FlushAsync();
return outStream.AsStream();
}
/// <summary>
/// Encodes the specified bitmap data and outputs it to the specified
/// <c>BinaryWriter</c>. Bitmap data should be in BGRA format.
/// For internal use only.
/// </summary>
public async Task EncodeAsync(byte[] bytes, BinaryWriter writer)
{
#if NETFX_CORE
using (var jpegStream = new InMemoryRandomAccessStream())
{
var propertySet = new BitmapPropertySet();
var qualityValue = new BitmapTypedValue(this.JpegQuality / 100.0, PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, jpegStream, propertySet);
if (this.Width != this.OutputWidth)
{
encoder.BitmapTransform.ScaledWidth = (uint)this.OutputWidth;
encoder.BitmapTransform.ScaledHeight = (uint)this.OutputHeight;
}
encoder.SetPixelData(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
(uint)this.Width,
(uint)this.Height,
96,
96,
bytes);
await encoder.FlushAsync();
if (writer.BaseStream == null || writer.BaseStream.CanWrite == false)
return;
// Header
writer.Write(this.OutputWidth);
writer.Write(this.OutputHeight);
writer.Write((int)jpegStream.Size);
// Data
jpegStream.AsStreamForRead().CopyTo(writer.BaseStream);
}
#else
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,
bytes,
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);
}
});
#endif
}
public async Task CaptureFrame()
{
try
{
using (var ms = new InMemoryRandomAccessStream())
{
SoftwareBitmap bitmap = null;
var propertySet = new Windows.Graphics.Imaging.BitmapPropertySet();
var qualityValue = new Windows.Graphics.Imaging.BitmapTypedValue(
0.5, // Quality percentage.
Windows.Foundation.PropertyType.Single
);
propertySet.Add("ImageQuality", qualityValue);
var frameReference = this.CameraFrameReader.TryAcquireLatestFrame();
var frame = frameReference?.VideoMediaFrame?.SoftwareBitmap;
this.CameraFrameReader.AcquisitionMode = MediaFrameReaderAcquisitionMode.Realtime;
if (frame == null)
{
var surface = frameReference?.VideoMediaFrame?.Direct3DSurface;
if (surface != null)
{
bitmap = await SoftwareBitmap.CreateCopyFromSurfaceAsync(surface, BitmapAlphaMode.Ignore).AsTask().ConfigureAwait(false);
// JPEG Encoder no likey YUY2.
if (bitmap.BitmapPixelFormat != BitmapPixelFormat.Bgra8)
{
bitmap = SoftwareBitmap.Convert(bitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
}
}
}
else
{
bitmap = SoftwareBitmap.Convert(frame, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
}
if (bitmap == null)
{
return;
}
using (bitmap)
{
var jpegEncoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, ms, propertySet).AsTask().ConfigureAwait(false);
jpegEncoder.SetSoftwareBitmap(bitmap);
// No thumbnail for just "streaming".
//jpegEncoder.IsThumbnailGenerated = false;
try
{
await jpegEncoder.FlushAsync().AsTask().ConfigureAwait(false);
}
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.
jpegEncoder.IsThumbnailGenerated = false;
break;
default:
throw err;
}
}
if (ms.Size > 0)
{
// TODO: make this more efficient.
byte[] data = (byte[])Array.CreateInstance(typeof(byte), (int)ms.Size);
ms.AsStreamForRead().Read(data, 0, (int)ms.Size);
this.CapturedFrame = new Frame()
{
Data = data,
Format = "jpeg",
Width = (uint)bitmap.PixelWidth,
Height = (uint)bitmap.PixelHeight
};
}
}
}
}
catch (Exception e)
{
this.Log.Error(() => "Exception while capturing frame.", e);
}
}
public async void HttpPost(string uid, string uimage, string name, string content, List<string> imagePsthList, string songPath,string date,int type)
{
NotifyControl notify = new NotifyControl();
notify.Text = "亲,努力发送中...";
notify.Show();
HttpClient httpClient = new HttpClient();
uint MaxImageWidth = 480;
uint MaxImageHeight = 800;
uint width;
uint height;
try
{
string posturi = Config.apiDreamingPublish;
HttpMultipartFormDataContent fileContent = new HttpMultipartFormDataContent();
if (imagePsthList.Count > 0)
{
for (int i = 0; i < imagePsthList.Count; i++)
{
StorageFile inFile = await StorageFile.GetFileFromPathAsync(imagePsthList[i]);
var inStream = await inFile.OpenReadAsync();
InMemoryRandomAccessStream outStream = new InMemoryRandomAccessStream();
BitmapDecoder decoder = await ImageHelp.GetProperDecoder(inStream,inFile);
if (decoder == null) return;
if (decoder.OrientedPixelWidth > MaxImageWidth && decoder.OrientedPixelHeight > MaxImageHeight)
{
width = MaxImageWidth;
height = MaxImageHeight;
}
else
{
width = decoder.OrientedPixelWidth;
height = decoder.OrientedPixelHeight;
}
PixelDataProvider provider = await decoder.GetPixelDataAsync();
byte[] data = provider.DetachPixelData(); //获取像素数据的字节数组
BitmapPropertySet propertySet = new BitmapPropertySet();
BitmapTypedValue qualityValue = new BitmapTypedValue(0.5, PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, outStream, propertySet);//建立编码器
encoder.SetPixelData(decoder.BitmapPixelFormat,
decoder.BitmapAlphaMode,
decoder.OrientedPixelWidth,
decoder.OrientedPixelHeight,
decoder.DpiX,
decoder.DpiY,
data
);
encoder.BitmapTransform.ScaledWidth = width;
encoder.BitmapTransform.ScaledHeight = height;
await encoder.FlushAsync();
HttpStreamContent streamContent1 = new HttpStreamContent(outStream);
fileContent.Add(streamContent1, "pic", inFile.Name);
}
}
if (songPath != null)
{
StorageFile file1 = await StorageFile.GetFileFromPathAsync(songPath);
IRandomAccessStreamWithContentType stream1 = await file1.OpenReadAsync();
HttpStreamContent streamContent1 = new HttpStreamContent(stream1);
fileContent.Add(streamContent1, "song", file1.Name);
}
HttpStringContent stringContent = new HttpStringContent(content);
HttpStringContent stringName = new HttpStringContent(name);
HttpStringContent stringUid = new HttpStringContent(uid);
HttpStringContent stringUimage = new HttpStringContent(uimage);
HttpStringContent stringTime = new HttpStringContent(date);
HttpStringContent stringType = new HttpStringContent(type.ToString());
fileContent.Add(stringContent, "content");
fileContent.Add(stringUid, "phone");
fileContent.Add(stringUimage, "uimage");
fileContent.Add(stringName, "name");
fileContent.Add(stringTime, "time");
fileContent.Add(stringType, "type");
HttpResponseMessage response = await httpClient.PostAsync(new Uri(posturi), fileContent);
Init();
notify.Hide();
PostCommand.CanExecutes = true;
NavigationHelp.NavigateTo(typeof(AllDreaming));
}
catch (Exception ex)
{
HelpMethods.Msg(ex.Message.ToString());
}
}