void DisplayJPG()
{
var jpgData = LoadResource(images[selectedIndex]);
var decoder = new JpegDecoder();
var jpg = decoder.DecodeJpeg(jpgData);
int x = 0;
int y = 0;
byte r, g, b;
for (int i = 0; i < jpg.Length; i += 3)
{
r = jpg[i];
g = jpg[i + 1];
b = jpg[i + 2];
graphics.DrawPixel(x, y, Color.FromRgb(r, g, b));
x++;
if (x % decoder.Width == 0)
{
y++;
x = 0;
}
}
graphics.Show();
}
void DisplayJPG(int weatherCode, int xOffset, int yOffset)
{
var jpgData = LoadResource(weatherCode);
var decoder = new JpegDecoder();
var jpg = decoder.DecodeJpeg(jpgData);
int x = 0;
int y = 0;
byte r, g, b;
for (int i = 0; i < jpg.Length; i += 3)
{
r = jpg[i];
g = jpg[i + 1];
b = jpg[i + 2];
graphics.DrawPixel(x + xOffset, y + yOffset, Color.FromRgb(r, g, b));
x++;
if (x % decoder.Width == 0)
{
y++;
x = 0;
}
}
}
// 调整图片文件大小
private void ResizeImage()
{
UploadStatus = UploadStatus.Resizing;
using (Stream fileStream = m_file.OpenRead())
{
// 利用FluxJpeg解码
DecodedJpeg jpegIn = new JpegDecoder(fileStream).Decode();
if (ImageResizer.ResizeNeeded(jpegIn.Image, ImageSize))
{
// 调整
DecodedJpeg jpegOut = new DecodedJpeg(
new ImageResizer(jpegIn.Image).Resize(ImageSize, ResamplingFilters.NearestNeighbor)
, jpegIn.MetaHeaders); // 获取EXIF详细信息
// 编码
m_resizeStream = new MemoryStream();
new JpegEncoder(jpegOut, 90, m_resizeStream).Encode();
// 显示
m_resizeStream.Seek(0, SeekOrigin.Begin);
FileLength = m_resizeStream.Length;
}
}
}
public JpegArithmeticSequentialScanDecoder(JpegDecoder decoder, JpegFrameHeader frameHeader) : base(decoder)
{
_frameHeader = frameHeader;
// Compute maximum sampling factor
int maxHorizontalSampling = 1;
int maxVerticalSampling = 1;
foreach (JpegFrameComponentSpecificationParameters currentFrameComponent in frameHeader.Components !)
{
maxHorizontalSampling = Math.Max(maxHorizontalSampling, currentFrameComponent.HorizontalSamplingFactor);
maxVerticalSampling = Math.Max(maxVerticalSampling, currentFrameComponent.VerticalSamplingFactor);
}
_maxHorizontalSampling = maxHorizontalSampling;
_maxVerticalSampling = maxVerticalSampling;
_restartInterval = decoder.GetRestartInterval();
_mcusPerLine = (frameHeader.SamplesPerLine + 8 * maxHorizontalSampling - 1) / (8 * maxHorizontalSampling);
_mcusPerColumn = (frameHeader.NumberOfLines + 8 * maxVerticalSampling - 1) / (8 * maxVerticalSampling);
_levelShift = 1 << (frameHeader.SamplePrecision - 1);
// Pre-allocate the JpegDecodeComponent instances
_components = new JpegArithmeticDecodingComponent[frameHeader.NumberOfComponents];
for (int i = 0; i < _components.Length; i++)
{
_components[i] = new JpegArithmeticDecodingComponent();
}
}
void UpdateImage(int index, int xOffSet, int yOffSet)
{
var jpgData = LoadResource($"level_{index}.jpg");
var decoder = new JpegDecoder();
var jpg = decoder.DecodeJpeg(jpgData);
int x = 0;
int y = 0;
byte r, g, b;
graphics.DrawRectangle(0, 0, 240, 208, Color.White, true);
for (int i = 0; i < jpg.Length; i += 3)
{
r = jpg[i];
g = jpg[i + 1];
b = jpg[i + 2];
graphics.DrawPixel(x + xOffSet, y + yOffSet, Color.FromRgb(r, g, b));
x++;
if (x % decoder.Width == 0)
{
y++;
x = 0;
}
}
graphics.Show();
}
private static void testAdobeJPG()
{
JpegDecoder jpegLibraryDecoder = new JpegDecoder();
byte[] rawTileBuffer = File.ReadAllBytes("sof3.jpg");
int tileWidth = 256;
int tileHeight = 240;
byte[] tileBuff = new byte[tileWidth * tileHeight * 2];
ReadOnlyMemory <byte> rawTileReadOnlyMemory;
rawTileReadOnlyMemory = new ReadOnlyMemory <byte>(rawTileBuffer);
jpegLibraryDecoder.SetInput(rawTileReadOnlyMemory);
//jpegLibraryDecoder.SetFrameHeader()
jpegLibraryDecoder.Identify(); // fails to identify. missing markers or whatever: Failed to decode JPEG data at offset 91149. No marker found.'
jpegLibraryDecoder.SetOutputWriter(new JpegDecode.JpegBufferOutputWriterGreaterThan8Bit(tileWidth / 2, tileHeight, jpegLibraryDecoder.Precision, 2, tileBuff, 16));
jpegLibraryDecoder.Decode();
File.WriteAllBytes("sof3-decodetest.raw", tileBuff);
}
public static byte[] DecodeJpeg(Stream sourceStream)
{
// Decode JPEG from stream
var decoder = new JpegDecoder(sourceStream);
var jpegDecoded = decoder.Decode();
var img = jpegDecoded.Image;
img.ChangeColorSpace(ColorSpace.Rgb);
// Init Buffer
int w = img.Width;
int h = img.Height;
var result = new byte[w * h * 4];
byte[][][] pixelsFromJpeg = img.Raster;
// Copy FluxJpeg buffer into WriteableBitmap
int i = 0;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
result[i++] = pixelsFromJpeg[2][x][y]; // B
result[i++] = pixelsFromJpeg[1][x][y]; // G
result[i++] = pixelsFromJpeg[0][x][y]; // R
result[i++] = 0xFF;
}
}
return(result);
}
public static async Task <byte[]> ResizeImageTizen(byte[] imageData, float width, float height)
{
using (JpegDecoder jpegDecoder = new JpegDecoder())
{
Size newImageSize = new Size((int)width, (int)height);
IEnumerable <BitmapFrame> image = await jpegDecoder.DecodeAsync(imageData);
Size oldImageSize = image.First().Size;
byte[] rawImageData = image.First().Buffer;
using (MediaPacket mediaPacket = MediaPacket.Create(new VideoMediaFormat(MediaFormatVideoMimeType.Rgba, oldImageSize)))
{
mediaPacket.VideoPlanes[0].Buffer.CopyFrom(rawImageData, 0, rawImageData.Length);
using (ImageTransformer imageTransformer = new ImageTransformer())
{
using (MediaPacket newMediaPacket = await imageTransformer.TransformAsync(mediaPacket, new ResizeTransform(newImageSize)))
{
IMediaBuffer buffer = newMediaPacket.VideoPlanes[0].Buffer;
byte[] newRawImageData = new byte[buffer.Length];
buffer.CopyTo(newRawImageData, 0, buffer.Length);
using (var jpegEncoder = new JpegEncoder())
{
jpegEncoder.Quality = 100;
jpegEncoder.SetResolution(newImageSize);
using (MemoryStream ms = new MemoryStream())
{
await jpegEncoder.EncodeAsync(newRawImageData, ms);
return(ms.ToArray());
}
}
}
}
}
}
}
public JpegHuffmanLosslessScanDecoder(JpegDecoder decoder, JpegFrameHeader frameHeader) : base(decoder)
{
_frameHeader = frameHeader;
// Compute maximum sampling factor
int maxHorizontalSampling = 1;
int maxVerticalSampling = 1;
foreach (JpegFrameComponentSpecificationParameters currentFrameComponent in frameHeader.Components !)
{
maxHorizontalSampling = Math.Max(maxHorizontalSampling, currentFrameComponent.HorizontalSamplingFactor);
maxVerticalSampling = Math.Max(maxVerticalSampling, currentFrameComponent.VerticalSamplingFactor);
}
_restartInterval = decoder.GetRestartInterval();
_mcusPerLine = (frameHeader.SamplesPerLine + maxHorizontalSampling - 1) / maxHorizontalSampling;
_mcusPerColumn = (frameHeader.NumberOfLines + maxVerticalSampling - 1) / maxVerticalSampling;
JpegBlockOutputWriter?outputWriter = decoder.GetOutputWriter();
if (outputWriter is null)
{
ThrowInvalidDataException("Output writer is not set.");
}
_allocator = new JpegPartialScanlineAllocator(outputWriter, decoder.MemoryPool);
_allocator.Allocate(frameHeader);
// Pre-allocate the JpegDecodeComponent instances
_components = new JpegHuffmanDecodingComponent[frameHeader.NumberOfComponents];
for (int i = 0; i < _components.Length; i++)
{
_components[i] = new JpegHuffmanDecodingComponent();
}
}
void Resize()
{
Status = FileUploadStatus.Resizing;
try
{
Stream fileStream = file.OpenRead();
using (fileStream)
{
// Decode
DecodedJpeg jpegIn = new JpegDecoder(fileStream).Decode();
if (!ImageResizer.ResizeNeeded(jpegIn.Image, ImageSize))
{
return;
}
else
{
// Resize
DecodedJpeg jpegOut = new DecodedJpeg(
new ImageResizer(jpegIn.Image)
.Resize(ImageSize, ResamplingFilters.NearestNeighbor),
jpegIn.MetaHeaders); // Retain EXIF details
// Encode
resizeStream = new MemoryStream();
new JpegEncoder(jpegOut, 90, resizeStream).Encode();
// Display
resizeStream.Seek(0, SeekOrigin.Begin);
FileLength = resizeStream.Length;
}
}
}
catch { };
}
void DisplayJPG(int x, int y)
{
var jpgData = LoadResource("meadow.jpg");
var decoder = new JpegDecoder();
var jpg = decoder.DecodeJpeg(jpgData);
int imageX = 0;
int imageY = 0;
byte r, g, b;
for (int i = 0; i < jpg.Length; i += 3)
{
r = jpg[i];
g = jpg[i + 1];
b = jpg[i + 2];
graphics.DrawPixel(imageX + x, imageY + y, Color.FromRgb(r, g, b));
imageX++;
if (imageX % decoder.Width == 0)
{
imageY++;
imageX = 0;
}
}
display.Show();
}
public IImageInfo Identify()
{
using var memoryStream = new MemoryStream(this.jpegBytes);
var decoder = new JpegDecoder();
return(decoder.Identify(Configuration.Default, memoryStream));
}
public void TestJpegLibrary()
{
var decoder = new JpegDecoder();
decoder.SetInput(_inputBytes);
decoder.Identify();
int width = decoder.Width;
int height = decoder.Height;
Rgba32[] rgba = new Rgba32[width * height];
byte[] ycbcr = ArrayPool <byte> .Shared.Rent(3 *rgba.Length);
try
{
var outputWriter = new JpegBufferOutputWriter(decoder.Width, decoder.Height, 3, ycbcr);
decoder.SetOutputWriter(outputWriter);
decoder.Decode();
JpegYCbCrToRgbConverter.Shared.ConvertYCbCr8ToRgba32(ycbcr, MemoryMarshal.AsBytes(rgba.AsSpan()), decoder.Width * decoder.Height);
}
finally
{
ArrayPool <byte> .Shared.Return(ycbcr);
}
}
/// <summary>
///
/// </summary>
/// <param name="ContentType"></param>
public void SetDecoder(string ContentType)
{
IImageDecoder imageDecoder = null;
switch (ContentType)
{
case _Png: // PNG 格式上传会出错，原因未知，所以曲线救国（已经解决）
imageDecoder = new PngDecoder()
{
};
break;
case _Bmp:
imageDecoder = new BmpDecoder();
break;
case _Gif:
imageDecoder = new GifDecoder();
break;
case _Jpg:
imageDecoder = new JpegDecoder();
break;
default: // 前面已经验证过，因此走不到这里，不需要处理
break;
}
ImageDecoder = imageDecoder;
}
public void Decompress(TiffDecompressionContext context, ReadOnlyMemory <byte> input, Memory <byte> output)
{
// Copy frame header
JpegFrameHeader frameHeader = _frameHeader;
frameHeader = new JpegFrameHeader(frameHeader.SamplePrecision, (ushort)context.ImageSize.Height, (ushort)context.ImageSize.Width, frameHeader.NumberOfComponents, frameHeader.Components);
var decoder = new JpegDecoder();
decoder.StartOfFrame = JpegMarker.StartOfFrame0;
decoder.MemoryPool = context.MemoryPool;
decoder.SetFrameHeader(frameHeader);
decoder.SetRestartInterval(_restartInterval);
foreach (ComponentInfo componentInfo in _components)
{
decoder.SetQuantizationTable(componentInfo.QuantizationTable);
decoder.SetHuffmanTable(componentInfo.DcTable);
decoder.SetHuffmanTable(componentInfo.AcTable);
}
var outputWriter = new JpegBuffer8BitOutputWriter(context.ImageSize.Width, context.SkippedScanlines, context.SkippedScanlines + context.RequestedScanlines, decoder.NumberOfComponents, output);
decoder.SetOutputWriter(outputWriter);
var reader = new JpegReader(input);
decoder.ProcessScan(ref reader, _scanHeader);
}
public JpegArithmeticProgressiveScanDecoder(JpegDecoder decoder, JpegFrameHeader frameHeader) : base(decoder)
{
_frameHeader = frameHeader;
// Compute maximum sampling factor
int maxHorizontalSampling = 1;
int maxVerticalSampling = 1;
foreach (JpegFrameComponentSpecificationParameters currentFrameComponent in frameHeader.Components !)
{
maxHorizontalSampling = Math.Max(maxHorizontalSampling, currentFrameComponent.HorizontalSamplingFactor);
maxVerticalSampling = Math.Max(maxVerticalSampling, currentFrameComponent.VerticalSamplingFactor);
}
_mcusPerLine = (frameHeader.SamplesPerLine + 8 * maxHorizontalSampling - 1) / (8 * maxHorizontalSampling);
_mcusPerColumn = (frameHeader.NumberOfLines + 8 * maxVerticalSampling - 1) / (8 * maxVerticalSampling);
_levelShift = 1 << (frameHeader.SamplePrecision - 1);
JpegBlockOutputWriter?outputWriter = decoder.GetOutputWriter();
if (outputWriter is null)
{
ThrowInvalidDataException("Output writer is not set.");
}
_outputWriter = outputWriter;
_allocator = new JpegBlockAllocator(decoder.MemoryPool);
_allocator.Allocate(frameHeader);
// Pre-allocate the JpegDecodeComponent instances
_components = new JpegArithmeticDecodingComponent[frameHeader.NumberOfComponents];
for (int i = 0; i < _components.Length; i++)
{
_components[i] = new JpegArithmeticDecodingComponent();
}
}
protected void DisplayJPG()
{
var jpgData = LoadResource("meadow.jpg");
var decoder = new JpegDecoder();
var jpg = decoder.DecodeJpeg(jpgData);
int x = 0;
int y = 0;
byte r, g, b;
for (int i = 0; i < jpg.Length; i += 3)
{
r = jpg[i];
g = jpg[i + 1];
b = jpg[i + 2];
graphics.DrawPixel(x + 55, y + 40, Color.FromRgb(r, g, b));
x++;
if (x % decoder.Width == 0)
{
y++;
x = 0;
}
}
display.Show();
}
public void JpegEncoderDecoderTest()
{
// Encode and decode a basic raster structure.
var colorModel = new ColorModel();
colorModel.ColorSpace = ColorSpace.YCbCr;
colorModel.Opaque = true;
byte[][][] originalRaster = GetRaster();
var image = new Image(colorModel, originalRaster);
var stream = new MemoryStream();
var encoder = new JpegEncoder(image, 50, stream);
encoder.Encode();
stream.Seek(0, SeekOrigin.Begin);
var decoder = new JpegDecoder(stream);
DecodedJpeg decodedImage = decoder.Decode();
// Check that the returned raster structure looks something like what we passed in.
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < width; j++)
{
for (int k = 0; k < height; k++)
{
// Tune this.
int diff = Math.Abs(decodedImage.Image.Raster[i][j][k] - originalRaster[i][j][k]);
Assert.IsTrue(diff < 5);
}
}
}
ClientLogger.Debug("Finished JpegEncoderDecoder test.");
}
static Image Resize(string pathIn, int edge)
{
JpegDecoder decoder = new JpegDecoder(File.Open(pathIn, FileMode.Open));
DecodedJpeg jpeg = decoder.Decode();
ImageResizer resizer = new ImageResizer(jpeg.Image);
return(resizer.ResizeToScale(edge, ResamplingFilters.LowpassAntiAlias));
}
public void DecodeJpeg(string fileName, int executionCount)
{
var decoder = new JpegDecoder()
{
IgnoreMetadata = true
};
this.DecodeJpegBenchmarkImpl(fileName, decoder, executionCount);
}
public static Image FromFile(string filename)
{
//TODO: review here
//should not depend on the extension
string fileext = IO.Path.GetExtension(filename).ToLower();
switch (fileext)
{
default:
throw new NotSupportedException();
case ".jpg":
{
JpegDecoder jpegDec = new JpegDecoder();
ImageTools.ExtendedImage outputImg = new ImageTools.ExtendedImage();
using (System.IO.FileStream fs = new IO.FileStream(filename, IO.FileMode.Open))
{
jpegDec.Decode(outputImg, fs);
}
//return bitmap
return(new Bitmap(outputImg.PixelWidth, outputImg.PixelHeight, outputImg.Pixels,
outputImg.DensityXInt32, outputImg.DensityYInt32));
}
case ".gif":
{
GifDecoder gifDec = new GifDecoder();
ImageTools.ExtendedImage outputImg = new ImageTools.ExtendedImage();
using (System.IO.FileStream fs = new IO.FileStream(filename, IO.FileMode.Open))
{
gifDec.Decode(outputImg, fs);
}
//return bitmap
return(new Bitmap(outputImg.PixelWidth, outputImg.PixelHeight, outputImg.Pixels,
outputImg.DensityXInt32, outputImg.DensityYInt32));
}
case ".png":
{
ImageTools.IO.Png.PngDecoder pngDecoder = new PngDecoder();
//HjgPngDecoder pngDecoder = new HjgPngDecoder();
//PngDecoder pngDecoder = new PngDecoder();
ImageTools.ExtendedImage outputImg = new ImageTools.ExtendedImage();
using (System.IO.FileStream fs = new IO.FileStream(filename, IO.FileMode.Open))
{
pngDecoder.Decode(outputImg, fs);
}
Bitmap bmp = new Bitmap(outputImg.PixelWidth,
outputImg.PixelHeight, outputImg.Pixels,
outputImg.DensityXInt32, outputImg.DensityYInt32);
bmp.PixelFormat = Imaging.PixelFormat.Format32bppArgb;
return(bmp);
}
}
return(null);
}
private JpegDecoder LoadJpegDecoder()
{
var decoder = new JpegDecoder();
if (_jpegTables?.Length > 0)
{
decoder.LoadTables(_jpegTables);
}
return(decoder);
}
private static MemoryStream JpegDecode(MemoryStream jpegData)
{
var byteStream = new MemoryStream();
JpegDecoder d = new JpegDecoder();
var img = d.Decode(new Configuration(new JpegConfigurationModule()), jpegData);
img.SaveAsBmp(byteStream, new SixLabors.ImageSharp.Formats.Bmp.BmpEncoder());
//using SixLabors.ImageSharp.Image image = SixLabors.ImageSharp.Image.Load(jpegData, new JpegDecoder());
// image.SaveAsBmp(byteStream);
return(byteStream);
}
public void Identify_DetectsCorrectColorType(string imagePath, JpegColorType expectedColorType)
{
var testFile = TestFile.Create(imagePath);
using (var stream = new MemoryStream(testFile.Bytes, false))
{
IImageInfo image = JpegDecoder.Identify(Configuration.Default, stream);
JpegMetadata meta = image.Metadata.GetJpegMetadata();
Assert.Equal(expectedColorType, meta.ColorType);
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog()
{
Filter = "Image files (*.jpg)|*.jpg"
};
if (ofd.ShowDialog() != true)
{
return;
}
Stream fileStream = ofd.File.OpenRead();
// Display input image
Stream inStream = new MemoryStream(new BinaryReader(fileStream).ReadBytes((int)fileStream.Length));
BitmapImage imageIn = new BitmapImage();
imageIn.SetSource(inStream);
InputImage.Source = imageIn;
// Rewind
fileStream.Seek(0, SeekOrigin.Begin);
using (fileStream)
{
// Decode
DecodedJpeg jpegIn = new JpegDecoder(fileStream).Decode();
if (!ImageResizer.ResizeNeeded(jpegIn.Image, 320))
{
OutputImage.Source = null;
OutputText.Text = "No resize necessary.";
return;
}
// Resize
DecodedJpeg jpegOut = new DecodedJpeg(
new ImageResizer(jpegIn.Image)
.Resize(320, ResamplingFilters.NearestNeighbor),
jpegIn.MetaHeaders); // Retain EXIF details
// Encode
MemoryStream outStream = new MemoryStream();
new JpegEncoder(jpegOut, 90, outStream).Encode();
// Display
outStream.Seek(0, SeekOrigin.Begin);
BitmapImage image = new BitmapImage();
image.SetSource(outStream);
OutputImage.Source = image;
}
}
public void Identify_VerifyQuality(string imagePath, int quality)
{
var testFile = TestFile.Create(imagePath);
using (var stream = new MemoryStream(testFile.Bytes, false))
{
var decoder = new JpegDecoder();
IImageInfo image = decoder.Identify(Configuration.Default, stream);
JpegMetadata meta = image.Metadata.GetJpegMetadata();
Assert.Equal(quality, meta.Quality);
}
}
public void Decode_VerifyQuality(string imagePath, int quality)
{
var testFile = TestFile.Create(imagePath);
using (var stream = new MemoryStream(testFile.Bytes, false))
{
using (Image image = JpegDecoder.Decode(Configuration.Default, stream))
{
JpegMetadata meta = image.Metadata.GetJpegMetadata();
Assert.Equal(quality, meta.Quality);
}
}
}
public static Task <int> DebugDump(FileInfo source, string output, CancellationToken cancellationToken)
{
if (source is null || source.Length == 0)
{
Console.WriteLine("Input file are not specified.");
return(Task.FromResult(1));
}
if (string.IsNullOrEmpty(output))
{
output = source.FullName;
}
byte[] input = File.ReadAllBytes(source.FullName);
var decoder = new JpegDecoder();
decoder.SetInput(input);
decoder.Identify();
int numberOfComponents = decoder.NumberOfComponents;
if (numberOfComponents > 4)
{
throw new NotSupportedException("Number of components greater than 4 is not supported.");
}
ushort[] buffer = new ushort[decoder.Width * decoder.Height * 4];
var outputWriter = new JpegExtendingOutputWriter(decoder.Width, decoder.Height, 4, decoder.Precision, buffer);
decoder.SetOutputWriter(outputWriter);
decoder.Decode();
// We use RGBA PNG image to store 4 components.
// Its content may be Grayscale, YCbCr or others.
Rgba32[] pixels = new Rgba32[decoder.Width * decoder.Height];
Array.Fill(pixels, new Rgba32(255, 255, 255, 255));
using var image = Image.WrapMemory(pixels.AsMemory(), decoder.Width, decoder.Height);
// high bits
CopyHighBits(buffer, pixels, numberOfComponents);
image.Save(output + ".high.png");
// apply prediction
ApplyPrediction(buffer);
// low bits
CopyLowBits(buffer, pixels, numberOfComponents);
image.Save(output + ".low-diff.png");
return(Task.FromResult(0));
}
public void Identify_VerifyRatio(string imagePath, int xResolution, int yResolution, PixelResolutionUnit resolutionUnit)
{
var testFile = TestFile.Create(imagePath);
using (var stream = new MemoryStream(testFile.Bytes, false))
{
var decoder = new JpegDecoder();
IImageInfo image = decoder.Identify(Configuration.Default, stream);
ImageMetadata meta = image.Metadata;
Assert.Equal(xResolution, meta.HorizontalResolution);
Assert.Equal(yResolution, meta.VerticalResolution);
Assert.Equal(resolutionUnit, meta.ResolutionUnits);
}
}
public void Decode_IgnoreMetadataIsTrue_ExifProfileIgnored()
{
var options = new JpegDecoder()
{
IgnoreMetadata = true
};
var testFile = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan);
using (Image <Rgba32> image = testFile.CreateImage(options))
{
Assert.Null(image.MetaData.ExifProfile);
}
}