Provides basic encoding functionality for Jpeg, png, and gif output. Allows adjustable Jpeg compression, but doesn't implement indexed PNG files or quantized GIF files. More...

Inheritance diagram for ImageResizer.Plugins.Basic.DefaultEncoder:

[legend]

Collaboration diagram for ImageResizer.Plugins.Basic.DefaultEncoder:

[legend]

Public Member Functions
	DefaultEncoder (ImageFormat outputFormat)

	DefaultEncoder (ImageFormat outputFormat, int jpegQuality)

	DefaultEncoder (ResizeSettings settings, object original)

virtual IEncoder	CreateIfSuitable (ResizeSettings settings, object original)
	If the encoder can handle the requirements specified by 'settings' and 'source', it should return an encoder instance. If not, it should return null. More...

bool	IsValidOutputFormat (ImageFormat f)
	Returns true if the this encoder supports the specified image format More...

void	Write (Image image, System.IO.Stream s)
	Writes the specified image to the stream using Quality and OutputFormat More...

virtual IEnumerable< string >	GetSupportedQuerystringKeys ()
	Returns the querystring keys used by DefaultEncoder (quality, format, and thumbnail) More...

IPlugin	Install (Configuration.Config c)

bool	Uninstall (Configuration.Config c)

IEnumerable< FileSignature >	GetSignatures ()
	Returns signatures for jpeg, bmp, gif, png, wmf, ico, and tif More...

Public Member Functions inherited from ImageResizer.Encoding.IEncoder
void	Write (Image i, Stream s)
	Encodes the image to the specified stream More...

Public Member Functions inherited from ImageResizer.Plugins.IPlugin
IPlugin	Install (Config c)
	Installs the plugin in the specified Config instance. The plugin must handle all the work of loading settings, registering the plugin etc. More...

bool	Uninstall (Config c)
	Uninstalls the plugin. Should reverse all changes made during Install More...

Static Public Member Functions
static ImageFormat	GetRequestedFormat (string format, ImageFormat defaultValue)
	Tries to parse an ImageFormat from the settings.Format value. If an unrecogized format is specified, returns null. If an unsupported format is specified, it is returned. If no format is specified, returns defaultValue. More...

static ImageFormat	GetOriginalFormat (object original)
	Attempts to determine the ImageFormat of the source image. First attempts to parse the path, if a string is present in original.Tag. (or if 'original' is a string) Falls back to using original.RawFormat. Returns null if both 'original' is null. RawFormat has a bad reputation, so this may return unexpected values, like MemoryBitmap or something in some situations. More...

static ImageFormat	GetImageFormatFromPhysicalPath (string path)
	Returns the ImageFormat enumeration value based on the extension in the specified physical path. Extensions can lie, just a guess. More...

static string	GetExtensionFromImageFormat (ImageFormat format)
	Returns an string instance from the specfied ImageFormat. First matching entry in imageExtensions is used. Returns null if not recognized. More...

static ImageFormat	GetImageFormatFromExtension (string ext)
	Returns an ImageFormat instance from the specfied file extension. Extensions lie sometimes, just a guess. returns null if not recognized. More...

static void	AddImageExtension (string extension, ImageFormat matchingFormat)

static string	GetContentTypeFromImageFormat (ImageFormat format)
	Supports Png, Jpeg, Gif, Bmp, and Tiff. Throws a ArgumentOutOfRangeException if not png, jpeg, gif, bmp, or tiff More...

static ImageCodecInfo	GetImageCodeInfo (string mimeType)
	Returns the first ImageCodeInfo instance with the specified mime type. Returns null if there are no matches. More...

static void	SaveJpeg (Image b, Stream target, int quality)
	Saves the specified image to the specified stream using jpeg compression of the specified quality. More...

static void	SavePng (Image img, Stream target)

static void	SaveBmp (Image img, Stream target)

static void	SaveGif (Image img, Stream target)

Properties
ImageFormat	OutputFormat `[get, set]`
	If you set this to anything other than Gif, Png, or Jpeg, it will throw an exception. Defaults to Jpeg More...

int	Quality `[get, set]`
	0..100 value. The Jpeg compression quality. 90 is the best setting. Not relevant in Png or Gif compression More...

bool	SupportsTransparency `[get]`
	Returns true if the desired output type supports transparency. More...

string	MimeType `[get]`
	Returns the default mime-type for the OutputFormat More...

string	Extension `[get]`
	Returns the default file extesnion for OutputFormat More...

Properties inherited from ImageResizer.Encoding.IEncoder
bool	SupportsTransparency `[get]`
	True if the output format will support transparency as it is currently configured. More...

string	MimeType `[get]`
	Returns the appropriate mime-time for the output format as currently configured. More...

string	Extension `[get]`
	Returns a file extension appropriate for the output format as currently configured, without a leading dot. More...

Detailed Description

Provides basic encoding functionality for Jpeg, png, and gif output. Allows adjustable Jpeg compression, but doesn't implement indexed PNG files or quantized GIF files.

Definition at line 18 of file DefaultEncoder.cs.

Member Function Documentation

virtual IEncoder ImageResizer.Plugins.Basic.DefaultEncoder.CreateIfSuitable	(	ResizeSettings	settings,
		object	original
	)

inlinevirtual

If the encoder can handle the requirements specified by 'settings' and 'source', it should return an encoder instance. If not, it should return null.

Parameters

settings	Request settings, like format, quality, colors, dither, etc.
original	May be a Drawing.Image instance, a path, or null. To provide both, set Image.tag to the path. Helps the encoder detect the original format if the format was not specified. May also be used for palette generation hinting by some encoders.

Returns

Implements ImageResizer.Encoding.IEncoder.

Reimplemented in ImageResizer.Plugins.WicEncoder.WicEncoderPlugin, and ImageResizer.Plugins.WpfBuilder.WpfEncoderPlugin.

Definition at line 51 of file DefaultEncoder.cs.

                                                                                            {
             ImageFormat requestedFormat = GetRequestedFormat(settings.Format, ImageFormat.Jpeg);
             if (requestedFormat == null || !IsValidOutputFormat(requestedFormat)) return null; //An unsupported format was explicitly specified.
             return new DefaultEncoder(settings, original);
         }

static string ImageResizer.Plugins.Basic.DefaultEncoder.GetContentTypeFromImageFormat ( ImageFormat format )

inlinestatic

Supports Png, Jpeg, Gif, Bmp, and Tiff. Throws a ArgumentOutOfRangeException if not png, jpeg, gif, bmp, or tiff

Parameters

format

Returns

Definition at line 261 of file DefaultEncoder.cs.

         {
             if (format == null) throw new ArgumentNullException();
 
             if (ImageFormat.Png.Equals(format))
                 return "image/png"; //Changed from image/x-png to image/png on May 14, 2011, per http://www.w3.org/Graphics/PNG/
             else if (ImageFormat.Jpeg.Equals(format))
                 return "image/jpeg";
             else if (ImageFormat.Gif.Equals(format))
                 return "image/gif";
             else if (ImageFormat.Bmp.Equals(format))
                 return "image/x-ms-bmp";
             else if (ImageFormat.Tiff.Equals(format))
                 return "image/tiff";
             else
             {
                 throw new ArgumentOutOfRangeException("Unsupported format " + format.ToString());
             }
 
         }

static string ImageResizer.Plugins.Basic.DefaultEncoder.GetExtensionFromImageFormat ( ImageFormat format )

inlinestatic

Returns an string instance from the specfied ImageFormat. First matching entry in imageExtensions is used. Returns null if not recognized.

Parameters

format

Returns

Definition at line 184 of file DefaultEncoder.cs.

         {
             lock (_syncExts) {
                 foreach (KeyValuePair<string, ImageFormat> p in imageExtensions) {
                     if (p.Value.Guid.Equals(format.Guid)) return p.Key;
                 }
             }
             return null;
         }

static ImageCodecInfo ImageResizer.Plugins.Basic.DefaultEncoder.GetImageCodeInfo ( string mimeType )

inlinestatic

Returns the first ImageCodeInfo instance with the specified mime type. Returns null if there are no matches.

Parameters

mimeType

Returns

Definition at line 287 of file DefaultEncoder.cs.

                                                                        {
             ImageCodecInfo[] info = ImageCodecInfo.GetImageEncoders();
             foreach (ImageCodecInfo ici in info)
                 if (ici.MimeType.Equals(mimeType, StringComparison.OrdinalIgnoreCase)) return ici;
             return null;
         }

static ImageFormat ImageResizer.Plugins.Basic.DefaultEncoder.GetImageFormatFromExtension ( string ext )

inlinestatic

Returns an ImageFormat instance from the specfied file extension. Extensions lie sometimes, just a guess. returns null if not recognized.

Parameters

ext

Returns

Definition at line 231 of file DefaultEncoder.cs.

         {
             if (string.IsNullOrEmpty(ext)) return null;
             lock (_syncExts) {
                 ext = ext.Trim(' ', '.').ToLowerInvariant();
                 if (!imageExtensions.ContainsKey(ext)) return null;
                 return imageExtensions[ext];
             }
         }

static ImageFormat ImageResizer.Plugins.Basic.DefaultEncoder.GetImageFormatFromPhysicalPath ( string path )

inlinestatic

Returns the ImageFormat enumeration value based on the extension in the specified physical path. Extensions can lie, just a guess.

Parameters

path

Returns

Definition at line 173 of file DefaultEncoder.cs.

         {
             return GetImageFormatFromExtension(System.IO.Path.GetExtension(path));
         }

static ImageFormat ImageResizer.Plugins.Basic.DefaultEncoder.GetOriginalFormat ( object original )

inlinestatic

Attempts to determine the ImageFormat of the source image. First attempts to parse the path, if a string is present in original.Tag. (or if 'original' is a string) Falls back to using original.RawFormat. Returns null if both 'original' is null. RawFormat has a bad reputation, so this may return unexpected values, like MemoryBitmap or something in some situations.

Parameters

original The source image that was loaded from a stream, or a string path

Returns

Definition at line 149 of file DefaultEncoder.cs.

                                                                      {
             if (original == null) return null;
             //Try to parse the original file extension first.
             string path = original as string;
             
             if (path == null && original is Image) path = ((Image)original).Tag as string;
 
             if (path == null && original is Image && ((Image)original).Tag is BitmapTag) path = ((BitmapTag)((Image)original).Tag).Path;
 
             //We have a path? Parse it!
             if (path != null) {
                 ImageFormat f = DefaultEncoder.GetImageFormatFromPhysicalPath(path);
                 if (f != null) return f; //From the path
             }
             //Ok, I guess it there (a) wasn't a path, or (b), it didn't have a recognizeable extension
             if (original is Image) return ((Image)original).RawFormat;
             return null;
         }

static ImageFormat ImageResizer.Plugins.Basic.DefaultEncoder.GetRequestedFormat	(	string	format,
		ImageFormat	defaultValue
	)

inlinestatic

Tries to parse an ImageFormat from the settings.Format value. If an unrecogized format is specified, returns null. If an unsupported format is specified, it is returned. If no format is specified, returns defaultValue.

Parameters

format
defaultValue

Returns

Definition at line 132 of file DefaultEncoder.cs.

                                                                                               {
             ImageFormat f = null;
             if (!string.IsNullOrEmpty(format)) {
                 f = DefaultEncoder.GetImageFormatFromExtension(format);
                 return f;
             }
             //Fallback. No encoder was explicitly specified, so let's try to infer it from the image data.
             return defaultValue;
 
         }

IEnumerable<FileSignature> ImageResizer.Plugins.Basic.DefaultEncoder.GetSignatures ( )

inline

Returns signatures for jpeg, bmp, gif, png, wmf, ico, and tif

Returns

Implements ImageResizer.Plugins.IFileSignatureProvider.

Definition at line 405 of file DefaultEncoder.cs.

         {
             //Source http://www.filesignatures.net/
             return new FileSignature[]{
                 new FileSignature(new byte[] {0xFF, 0xD8, 0xFF}, "jpg", "image/jpeg"),
                 new FileSignature(new byte[] {0x42, 0x4D}, "bmp", "image/x-ms-bmp"), //Can be a BMP or DIB
                 new FileSignature(new byte[] {0x47,0x49,0x46, 0x38}, "gif", "image/gif"),
                 new FileSignature(new byte[] {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, "png","image/png"),
                 new FileSignature(new byte[] {0xD7, 0xCD, 0xC6, 0x9A}, "wmf", "image/x-wmf"),
                 new FileSignature(new byte[] {0x00, 0x00,0x01, 0x00}, "ico", "image/x-icon"), //Can be a printer spool or an icon
                 new FileSignature(new byte[] {0x49, 0x20, 0x49}, "tif", "image/tiff"),
                 new FileSignature(new byte[] {0x49, 0x49, 0x2A, 0x00}, "tif", "image/tiff"),
                 new FileSignature(new byte[] {0x4D, 0x4D, 0x00, 0x2A}, "tif", "image/tiff"),
                 new FileSignature(new byte[] {0x4D, 0x4D, 0x00, 0x2B}, "tif", "image/tiff")
             };
         }

virtual IEnumerable<string> ImageResizer.Plugins.Basic.DefaultEncoder.GetSupportedQuerystringKeys ( )

inlinevirtual

Returns the querystring keys used by DefaultEncoder (quality, format, and thumbnail)

Returns

Implements ImageResizer.Plugins.IQuerystringPlugin.

Definition at line 387 of file DefaultEncoder.cs.

                                                                          {
             return new string[] { "quality", "format", "thumbnail" };
         }

bool ImageResizer.Plugins.Basic.DefaultEncoder.IsValidOutputFormat ( ImageFormat f )

inline

Returns true if the this encoder supports the specified image format

Parameters

f

Returns

Definition at line 73 of file DefaultEncoder.cs.

                                                        {
             return (ImageFormat.Gif.Equals(f) || ImageFormat.Png.Equals(f) || ImageFormat.Jpeg.Equals(f));
         }

static void ImageResizer.Plugins.Basic.DefaultEncoder.SaveJpeg	(	Image	b,
		Stream	target,
		int	quality
	)

inlinestatic

Saves the specified image to the specified stream using jpeg compression of the specified quality.

Parameters

b
quality	A number between 0 and 100. Defaults to 90 if passed a negative number. Numbers over 100 are truncated to 100. 90 is a very good setting.
target

Definition at line 303 of file DefaultEncoder.cs.

                                                                          {
             #region Encoder paramater notes
             //image/jpeg
             //  The parameter list requires 172 bytes.
             //  There are 4 EncoderParameter objects in the array.
             //    Parameter[0]
             //      The category is Transformation.
             //      The data type is Long.
             //      The number of values is 5.
             //    Parameter[1]
             //      The category is Quality.
             //      The data type is LongRange.
             //      The number of values is 1.
             //    Parameter[2]
             //      The category is LuminanceTable.
             //      The data type is Short.
             //      The number of values is 0.
             //    Parameter[3]
             //      The category is ChrominanceTable.
             //      The data type is Short.
             //      The number of values is 0.
 
 
             //  http://msdn.microsoft.com/en-us/library/ms533845(VS.85).aspx
             // http://msdn.microsoft.com/en-us/library/ms533844(VS.85).aspx
             // TODO: What about ICC profiles
             #endregion
             
             //Validate quality
             if (quality < 0) quality = 90; //90 is a very good default to stick with.
             if (quality > 100) quality = 100;
             //Prepare paramater for encoder
             using (EncoderParameters p = new EncoderParameters(1)) {
                 using (var ep = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)quality))
                 {
                     p.Param[0] = ep;
                     //save
                     b.Save(target, GetImageCodeInfo("image/jpeg"), p);
                 }
             }
         }

static void ImageResizer.Plugins.Basic.DefaultEncoder.SavePng	(	Image	img,
		Stream	target
	)

inlinestatic

Saves the image in png form. If Stream 'target' is not seekable, a temporary MemoryStream will be used to buffer the image data into the stream

Parameters

img
target

Definition at line 350 of file DefaultEncoder.cs.

         {
             if (!target.CanSeek) {
                 //Write to an intermediate, seekable memory stream (PNG compression requires it)
                 using (MemoryStream ms = new MemoryStream(4096)) {
                     img.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
                     ms.WriteTo(target);
                 }
             } else {
                 //image/png
                 //  The parameter list requires 0 bytes.
                 img.Save(target, System.Drawing.Imaging.ImageFormat.Png);
             }
         }

void ImageResizer.Plugins.Basic.DefaultEncoder.Write	(	Image	image,
		System.IO.Stream	s
	)

inline

Writes the specified image to the stream using Quality and OutputFormat

Parameters

image
s

Definition at line 92 of file DefaultEncoder.cs.

                                                            {
             if (ImageFormat.Jpeg.Equals(OutputFormat)) SaveJpeg(image, s, this.Quality);
             else if (ImageFormat.Png.Equals(OutputFormat)) SavePng(image, s);
             else if (ImageFormat.Gif.Equals(OutputFormat)) SaveGif(image, s);
         }

Property Documentation

string ImageResizer.Plugins.Basic.DefaultEncoder.Extension

get

Returns the default file extesnion for OutputFormat

Definition at line 116 of file DefaultEncoder.cs.

string ImageResizer.Plugins.Basic.DefaultEncoder.MimeType

get

Returns the default mime-type for the OutputFormat

Definition at line 110 of file DefaultEncoder.cs.

ImageFormat ImageResizer.Plugins.Basic.DefaultEncoder.OutputFormat

getset

If you set this to anything other than Gif, Png, or Jpeg, it will throw an exception. Defaults to Jpeg

Definition at line 61 of file DefaultEncoder.cs.

int ImageResizer.Plugins.Basic.DefaultEncoder.Quality

getset

0..100 value. The Jpeg compression quality. 90 is the best setting. Not relevant in Png or Gif compression

Definition at line 82 of file DefaultEncoder.cs.

bool ImageResizer.Plugins.Basic.DefaultEncoder.SupportsTransparency

get

Returns true if the desired output type supports transparency.

Definition at line 101 of file DefaultEncoder.cs.

The documentation for this class was generated from the following file:

C:/Users/nathanael/Documents/resizer/Core/Plugins/Basic/DefaultEncoder.cs

Public Member Functions

Static Public Member Functions

Properties

Detailed Description

Member Function Documentation

Property Documentation