/// <summary>
/// Query media informations.
/// </summary>
/// <param name="path">
/// A <see cref="String"/> that specify the media path.
/// </param>
/// <param name="criteria">
/// A <see cref="MediaCodecCriteria"/> that specify parameters for loading an media stream.
/// </param>
/// <returns>
/// A <see cref="ImageInfo"/> containing information about the specified media.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Exception thrown if <paramref name="stream"/> or <paramref name="criteria"/> is null.
/// </exception>
public ImageInfo QueryInfo(Stream stream, ImageCodecCriteria criteria)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (criteria == null)
{
throw new ArgumentNullException("criteria");
}
ImageInfo info = new ImageInfo();
using (Bitmap iBitmap = new Bitmap(stream)) {
PixelLayout iBitmapPixelType;
string containerFormat;
ConvertImageFormat(iBitmap.RawFormat, out containerFormat);
ConvertPixelFormat(iBitmap, out iBitmapPixelType);
info.ContainerFormat = containerFormat;
info.PixelType = iBitmapPixelType;
info.Width = (uint)iBitmap.Width;
info.Height = (uint)iBitmap.Height;
}
return(info);
}
/// <summary>
/// Save media to stream.
/// </summary>
/// <param name="stream">
/// A <see cref="IO.Stream"/> which stores the media data.
/// </param>
/// <param name="image">
/// A <see cref="Image"/> holding the data to be stored.
/// </param>
/// <param name="format">
/// A <see cref="String"/> that specify the media format to used for saving <paramref name="image"/>.
/// </param>
/// <param name="criteria">
/// A <see cref="MediaCodecCriteria"/> that specify parameters for loading an image stream.
/// </param>
/// <exception cref="ArgumentNullException">
/// Exception thrown if <paramref name="stream"/>, <paramref name="image"/> or <paramref name="criteria"/> is null.
/// </exception>
public void Save(Stream stream, Image image, string format, ImageCodecCriteria criteria)
{
System.Drawing.Imaging.ImageFormat bitmapFormat;
System.Drawing.Imaging.PixelFormat bitmapPixelFormat;
int iBitmapFlags;
ConvertImageFormat(format, out bitmapFormat);
ConvertPixelFormat(image.PixelLayout, out bitmapPixelFormat, out iBitmapFlags);
// Obtain source and destination data pointers
using (Bitmap bitmap = new Bitmap((int)image.Width, (int)image.Height, bitmapPixelFormat)) {
#region Copy Image To Bitmap
BitmapData iBitmapData = null;
IntPtr imageData = image.ImageBuffer;
try {
iBitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
// Copy Image data dst Bitmap
unsafe {
byte *hImageDataPtr = (byte *)imageData.ToPointer();
byte *iBitmapDataPtr = (byte *)iBitmapData.Scan0.ToPointer();
uint hImageDataStride = image.Stride;
uint iBitmapDataStride = (uint)iBitmapData.Stride;
// .NET Image Library stores bitmap scan line data in memory padded dst 4 bytes boundaries
// .NET Image Library expect a bottom up image, so invert the scan line order
iBitmapDataPtr = iBitmapDataPtr + ((image.Height - 1) * iBitmapDataStride);
for (uint line = 0; line < image.Height; line++, hImageDataPtr += hImageDataStride, iBitmapDataPtr -= iBitmapDataStride)
{
Memory.MemoryCopy(iBitmapDataPtr, hImageDataPtr, hImageDataStride);
}
}
} finally {
if (iBitmapData != null)
{
bitmap.UnlockBits(iBitmapData);
}
}
#endregion
#region Support Indexed Pixel Formats
if ((iBitmapFlags & (int)ImageFlags.ColorSpaceGray) != 0)
{
ColorPalette bitmapPalette = bitmap.Palette;
switch (bitmapPixelFormat)
{
case System.Drawing.Imaging.PixelFormat.Format8bppIndexed:
// Create grayscale palette
for (int i = 0; i <= 255; i++)
{
bitmapPalette.Entries[i] = Color.FromArgb(i, i, i);
}
break;
}
bitmap.Palette = bitmapPalette;
}
#endregion
// Save image with the specified format
ImageCodecInfo encoderInfo = Array.Find(ImageCodecInfo.GetImageEncoders(), delegate(ImageCodecInfo item) {
return(item.FormatID == bitmapFormat.Guid);
});
EncoderParameters encoderParams = null;
try {
EncoderParameters encoderInfoParamList = bitmap.GetEncoderParameterList(encoderInfo.Clsid);
EncoderParameter[] encoderInfoParams = encoderInfoParamList != null ? encoderInfoParamList.Param : null;
bool supportQuality = false;
int paramsCount = 0;
if (encoderInfoParams != null)
{
Array.ForEach(encoderInfoParams, delegate(EncoderParameter item) {
if (item.Encoder.Guid == Encoder.Quality.Guid)
{
supportQuality = true;
paramsCount++;
}
});
}
encoderParams = new EncoderParameters(paramsCount);
paramsCount = 0;
if (supportQuality)
{
encoderParams.Param[paramsCount++] = new EncoderParameter(Encoder.Quality, 100);
}
} catch (Exception) {
// Encoder does not support parameters
}
bitmap.Save(stream, encoderInfo, encoderParams);
}
}
/// <summary>
/// Save media to stream.
/// </summary>
/// <param name="path">
/// A <see cref="String"/> that specify the media path.
/// </param>
/// <param name="image">
/// A <see cref="Image"/> holding the data to be stored.
/// </param>
/// <param name="format">
/// A <see cref="String"/> that specify the media format to used for saving <paramref name="image"/>.
/// </param>
/// <param name="criteria">
/// A <see cref="MediaCodecCriteria"/> that specify parameters for loading an image stream.
/// </param>
/// <exception cref="ArgumentNullException">
/// Exception thrown if <paramref name="stream"/>, <paramref name="image"/> or <paramref name="criteria"/> is null.
/// </exception>
public void Save(string path, Image image, string format, ImageCodecCriteria criteria)
{
using (FileStream fs = new FileStream(path, FileMode.CreateNew, FileAccess.Write)) {
Save(fs, image, format, criteria);
}
}
/// <summary>
/// Internal method for creating Image from Bitmap.
/// </summary>
/// <param name="bitmap">
/// A <see cref="Drawing.Bitmap"/> to be converted into an <see cref="Image"/> instance.
/// </param>
/// <param name="criteria">
/// A <see cref="MediaCodecCriteria"/> that specify image conversion criteria.
/// </param>
/// <returns>
/// It returns a <see cref="Image"/> instance that's equivalent to <paramref name="bitmap"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Exception thrown if <paramref name="bitmap"/> or <see cref="criteria"/> is null.
/// </exception>
internal static Image LoadFromBitmap(Bitmap bitmap, ImageCodecCriteria criteria)
{
if (bitmap == null)
{
throw new ArgumentNullException("bitmap");
}
if (criteria == null)
{
throw new ArgumentNullException("criteria");
}
PixelLayout pType, pConvType;
// Allocate image raster
ConvertPixelFormat(bitmap, out pType);
// Check for hardware/software support
if (pType.IsSupportedInternalFormat() == false)
{
if (criteria.IsSet(ImageCodecCriteria.SoftwareSupport) && ((bool)criteria[ImageCodecCriteria.SoftwareSupport]))
{
// Pixel type not directly supported by hardware... try to guess suitable software conversion
throw new NotImplementedException(String.Format("pixel type {0} is not supported by hardware neither software", pType));
}
else
{
throw new InvalidOperationException(String.Format("pixel type {0} is not supported by hardware", pType));
}
}
else
{
pConvType = pType;
}
Image image = new Image(pType, (uint)bitmap.Width, (uint)bitmap.Height);
switch (bitmap.PixelFormat)
{
case System.Drawing.Imaging.PixelFormat.Format1bppIndexed:
case System.Drawing.Imaging.PixelFormat.Format4bppIndexed:
case System.Drawing.Imaging.PixelFormat.Format8bppIndexed:
if (Khronos.Platform.RunningMono)
{
// Bug 676362 - Bitmap Clone does not format return image to requested PixelFormat
// https://bugzilla.novell.com/show_bug.cgi?id=676362
//
// ATM no mono version has resolved the bug; current workaround is performing image
// sampling pixel by pixel, using internal conversion routines, even if it is very slow
LoadBitmapByPixel(bitmap, image);
}
else
{
LoadBitmapByClone(bitmap, image);
}
break;
default:
LoadBitmapByLockBits(bitmap, image);
break;
}
return(image);
}
/// <summary>
/// Load media from stream.
/// </summary>
/// <param name="stream">
/// A <see cref="Stream"/> where the media data is stored.
/// </param>
/// <param name="criteria">
/// A <see cref="MediaCodecCriteria"/> that specify parameters for loading an media stream.
/// </param>
/// <returns>
/// An <see cref="Image"/> holding the media data.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Exception thrown if <paramref name="stream"/> or <paramref name="criteria"/> is null.
/// </exception>
public Image Load(string path, ImageCodecCriteria criteria)
{
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read)) {
return(Load(fs, criteria));
}
}
/// <summary>
/// Load media from stream.
/// </summary>
/// <param name="stream">
/// A <see cref="Stream"/> where the media data is stored.
/// </param>
/// <param name="criteria">
/// A <see cref="MediaCodecCriteria"/> that specify parameters for loading an media stream.
/// </param>
/// <returns>
/// An <see cref="Image"/> holding the media data.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Exception thrown if <paramref name="stream"/> or <paramref name="criteria"/> is null.
/// </exception>
public Image Load(Stream stream, ImageCodecCriteria criteria)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (criteria == null)
{
throw new ArgumentNullException("criteria");
}
using (System.Drawing.Bitmap iBitmap = new System.Drawing.Bitmap(stream)) {
Image image;
PixelLayout pType, pConvType;
// Allocate image raster
ConvertPixelFormat(iBitmap, out pType);
// Check for hardware/software support
if (pType.IsSupportedInternalFormat() == false)
{
if (criteria.IsSet(ImageCodecCriteria.SoftwareSupport) && (bool)criteria[ImageCodecCriteria.SoftwareSupport])
{
// Pixel type not directly supported by hardware... try to guess suitable software conversion
pConvType = Pixel.GuessBestSupportedConvertion(pType);
if (pConvType == PixelLayout.None)
{
throw new InvalidOperationException("pixel type " + pType.ToString() + " is not supported by hardware neither software");
}
}
else
{
throw new InvalidOperationException("pixel type " + pType.ToString() + " is not supported by hardware");
}
}
else
{
pConvType = pType;
}
image = new Image();
image.Create(pType, (uint)iBitmap.Width, (uint)iBitmap.Height);
switch (iBitmap.PixelFormat)
{
case System.Drawing.Imaging.PixelFormat.Format1bppIndexed:
case System.Drawing.Imaging.PixelFormat.Format4bppIndexed:
case System.Drawing.Imaging.PixelFormat.Format8bppIndexed:
if (Platform.RunningMono)
{
// Bug 676362 - Bitmap Clone does not format return image to requested PixelFormat
// https://bugzilla.novell.com/show_bug.cgi?id=676362
//
// ATM no mono version has resolved the bug; current workaround is performing image
// sampling pixel by pixel, using internal conversion routines, even if it is very slow
LoadBitmapByPixel(iBitmap, image);
}
else
{
LoadBitmapByClone(iBitmap, image);
}
break;
default:
LoadBitmapByLockBits(iBitmap, image);
break;
}
// ConvertItemType image to supported format, if necessary
if ((pConvType != PixelLayout.None) && (pConvType != pType))
{
image = image.Convert(pConvType);
}
return(image);
}
}
