mono/mcs/class/System.Drawing/System.Drawing.Imaging/EncoderParameter.cs

//
// System.Drawing.Imaging.EncoderParameter.cs
//
// Author: 
//	Ravindra ([email protected])
//  Vladimir Vukicevic ([email protected])
//
// (C) 2004 Novell, Inc.  http://www.novell.com
//

//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Text;

using System.Runtime.InteropServices;

namespace System.Drawing.Imaging {

	[StructLayout(LayoutKind.Sequential)]
	public sealed class EncoderParameter : IDisposable {

		private Encoder encoder;
		private int valuesCount;
		private EncoderParameterValueType type;
		private IntPtr valuePtr;

		internal EncoderParameter ()
		{
		}

		public EncoderParameter (Encoder encoder, byte value)
		{
			this.encoder = encoder;
			this.valuesCount = 1;
			this.type = EncoderParameterValueType.ValueTypeByte;
			this.valuePtr = Marshal.AllocHGlobal (1);
			Marshal.WriteByte (this.valuePtr, value);
		}

		public EncoderParameter (Encoder encoder, byte[] value)
		{
			this.encoder = encoder;
			this.valuesCount = value.Length;
			this.type = EncoderParameterValueType.ValueTypeByte;
			this.valuePtr = Marshal.AllocHGlobal (1 * valuesCount);
			Marshal.Copy (value, 0, this.valuePtr, valuesCount);
		}

		public EncoderParameter (Encoder encoder, short value)
		{
			this.encoder = encoder;
			this.valuesCount = 1;
			this.type = EncoderParameterValueType.ValueTypeShort;
			this.valuePtr = Marshal.AllocHGlobal (2);
			Marshal.WriteInt16 (this.valuePtr, value);
		}

		public EncoderParameter (Encoder encoder, short[] value)
		{
			this.encoder = encoder;
			this.valuesCount = value.Length;
			this.type = EncoderParameterValueType.ValueTypeShort;
			this.valuePtr = Marshal.AllocHGlobal (2 * valuesCount);
			Marshal.Copy (value, 0, this.valuePtr, valuesCount);
		}


		public EncoderParameter (Encoder encoder, long value)
		{
			this.encoder = encoder;
			this.valuesCount = 1;
			this.type = EncoderParameterValueType.ValueTypeLong;
			this.valuePtr = Marshal.AllocHGlobal (4);
			Marshal.WriteInt32 (this.valuePtr, (int) value);
		}

		public EncoderParameter (Encoder encoder, long[] value)
		{
			this.encoder = encoder;
			this.valuesCount = value.Length;
			this.type = EncoderParameterValueType.ValueTypeLong;
			this.valuePtr = Marshal.AllocHGlobal (4 * valuesCount);
			int [] ivals = new int[value.Length];
			for (int i = 0; i < value.Length; i++) ivals[i] = (int) value[i];
			Marshal.Copy (ivals, 0, this.valuePtr, valuesCount);
		}

		public EncoderParameter (Encoder encoder, string value)
		{
			this.encoder = encoder;

			ASCIIEncoding ascii = new ASCIIEncoding ();
			int asciiByteCount = ascii.GetByteCount (value);
			byte[] bytes = new byte [asciiByteCount];
			ascii.GetBytes (value, 0, value.Length, bytes, 0);

			this.valuesCount = bytes.Length;
			this.type = EncoderParameterValueType.ValueTypeAscii;
			this.valuePtr = Marshal.AllocHGlobal (valuesCount);
			Marshal.Copy (bytes, 0, this.valuePtr, valuesCount);
		}

		public EncoderParameter (Encoder encoder, byte value, bool undefined)
		{
			this.encoder = encoder;
			this.valuesCount = 1;
			if (undefined)
				this.type = EncoderParameterValueType.ValueTypeUndefined;
			else
				this.type = EncoderParameterValueType.ValueTypeByte;
			this.valuePtr = Marshal.AllocHGlobal (1);
			Marshal.WriteByte (this.valuePtr, value);
		}

		public EncoderParameter (Encoder encoder, byte[] value, bool undefined)
		{
			this.encoder = encoder;
			this.valuesCount = value.Length;
			if (undefined)
				this.type = EncoderParameterValueType.ValueTypeUndefined;
			else
				this.type = EncoderParameterValueType.ValueTypeByte;
			this.valuePtr = Marshal.AllocHGlobal (valuesCount);
			Marshal.Copy (value, 0, this.valuePtr, valuesCount);
		}

		public EncoderParameter (Encoder encoder, int numerator, int denominator)
		{
			this.encoder = encoder;
			this.valuesCount = 1;
			this.type = EncoderParameterValueType.ValueTypeRational;
			this.valuePtr = Marshal.AllocHGlobal (8);
			int [] valuearray = { numerator, denominator };
			Marshal.Copy (valuearray, 0, this.valuePtr, valuearray.Length);
		}

		public EncoderParameter (Encoder encoder, int[] numerator, int[] denominator)
		{
			if (numerator.Length != denominator.Length)
				throw new ArgumentException ("Invalid parameter used.");

			this.encoder = encoder;
			this.valuesCount = numerator.Length;
			this.type = EncoderParameterValueType.ValueTypeRational;
			this.valuePtr = Marshal.AllocHGlobal (4 * valuesCount * 2);
			for (int i = 0; i < valuesCount; i++) {
				Marshal.WriteInt32 (valuePtr, i * 4, (int) numerator[i]);
				Marshal.WriteInt32 (valuePtr, (i + 1) * 4, (int) denominator[i]);
			}
		}

		public EncoderParameter (Encoder encoder, long rangebegin, long rangeend)
		{
			this.encoder = encoder;
			this.valuesCount = 1;
			this.type = EncoderParameterValueType.ValueTypeLongRange;
			this.valuePtr = Marshal.AllocHGlobal (8);
			int [] valuearray = { (int) rangebegin, (int) rangeend };
			Marshal.Copy (valuearray, 0, this.valuePtr, valuearray.Length);
		}

		public EncoderParameter (Encoder encoder, long[] rangebegin, long[] rangeend)
		{
			if (rangebegin.Length != rangeend.Length)
				throw new ArgumentException ("Invalid parameter used.");

			this.encoder = encoder;
			this.valuesCount = rangebegin.Length;
			this.type = EncoderParameterValueType.ValueTypeLongRange;

			this.valuePtr = Marshal.AllocHGlobal (4 * valuesCount * 2);
			IntPtr dest = this.valuePtr;
			for (int i = 0; i < valuesCount; i++) {
				Marshal.WriteInt32 (dest, i * 4, (int) rangebegin[i]);
				Marshal.WriteInt32 (dest, (i + 1) * 4, (int) rangeend[i]);
			}
		}

		public EncoderParameter (Encoder encoder, int numberOfValues, int type, int value)
		{
			this.encoder = encoder;
			this.valuePtr = (IntPtr) value;
			this.valuesCount = numberOfValues;
			this.type = (EncoderParameterValueType) type;
		}

		public EncoderParameter (Encoder encoder, int numerator1, int denominator1, int numerator2, int denominator2)
		{
			this.encoder = encoder;
			this.valuesCount = 1;
			this.type = EncoderParameterValueType.ValueTypeRationalRange;
			this.valuePtr = Marshal.AllocHGlobal (4 * 4);
			int [] valuearray = { numerator1, denominator1, numerator2, denominator2 };
			Marshal.Copy (valuearray, 0, this.valuePtr, 4);
		}

		public EncoderParameter (Encoder encoder, int[] numerator1, int[] denominator1, int[] numerator2, int[] denominator2)
		{
			if (numerator1.Length != denominator1.Length ||
			    numerator2.Length != denominator2.Length ||
			    numerator1.Length != numerator2.Length)
				throw new ArgumentException ("Invalid parameter used.");

			this.encoder = encoder;
			this.valuesCount = numerator1.Length;
			this.type = EncoderParameterValueType.ValueTypeRationalRange;

			this.valuePtr = Marshal.AllocHGlobal (4 * valuesCount * 4);
			IntPtr dest = this.valuePtr;
			for (int i = 0; i < valuesCount; i++) {
				Marshal.WriteInt32 (dest, i * 4, numerator1[i]);
				Marshal.WriteInt32 (dest, (i + 1) * 4, denominator1[i]);
				Marshal.WriteInt32 (dest, (i + 2) * 4, numerator2[i]);
				Marshal.WriteInt32 (dest, (i + 3) * 4, denominator2[i]);
			}
		}

		public Encoder Encoder {
			get {
				return encoder;
			}

			set {
				encoder = value;
			}
		}

		public int NumberOfValues {
			get {
				return valuesCount;
			}
		}

		public EncoderParameterValueType Type {
			get {
				return type;
			}
		}

		public EncoderParameterValueType ValueType {
			get {
				return type;
			}
		}

		void Dispose (bool disposing) {
			if (valuePtr != IntPtr.Zero) {
				Marshal.FreeHGlobal (valuePtr);
				valuePtr = IntPtr.Zero;
			}
		}

		public void Dispose () {
			Dispose (true);		
			GC.SuppressFinalize(this);
		}

		~EncoderParameter () {
			Dispose (false);
		}

		internal static int NativeSize () {
			return Marshal.SizeOf (typeof(GdipEncoderParameter));
		}

		internal void ToNativePtr (IntPtr epPtr) {
			GdipEncoderParameter ep = new GdipEncoderParameter ();
			ep.guid = this.encoder.Guid;
			ep.numberOfValues = (uint) this.valuesCount;
			ep.type = this.type;
			ep.value = this.valuePtr;
			Marshal.StructureToPtr (ep, epPtr, false);
		}

		internal static EncoderParameter FromNativePtr (IntPtr epPtr) {
			GdipEncoderParameter ep;
			ep = (GdipEncoderParameter) Marshal.PtrToStructure (epPtr, typeof(GdipEncoderParameter));

			Type valType;
			uint valCount;

			switch (ep.type) {
			case EncoderParameterValueType.ValueTypeAscii:
			case EncoderParameterValueType.ValueTypeByte:
			case EncoderParameterValueType.ValueTypeUndefined:
				valType = typeof(byte);
				valCount = ep.numberOfValues;
				break;
			case EncoderParameterValueType.ValueTypeShort:
				valType = typeof(short);
				valCount = ep.numberOfValues;
				break;
			case EncoderParameterValueType.ValueTypeLong:
				valType = typeof(int);
				valCount = ep.numberOfValues;
				break;
			case EncoderParameterValueType.ValueTypeLongRange:
			case EncoderParameterValueType.ValueTypeRational:
				valType = typeof(int);
				valCount = ep.numberOfValues * 2;
				break;
			case EncoderParameterValueType.ValueTypeRationalRange:
				valType = typeof(int);
				valCount = ep.numberOfValues * 4;
				break;
			default:
				return null;
			}

			EncoderParameter eparam = new EncoderParameter();
			eparam.encoder = new Encoder(ep.guid);
			eparam.valuesCount = (int) ep.numberOfValues;
			eparam.type = ep.type;
			eparam.valuePtr = Marshal.AllocHGlobal ((int)(valCount * Marshal.SizeOf(valType)));

			/* There's nothing in Marshal to do a memcpy() between two IntPtrs.  This sucks. */
			unsafe {
				byte *s = (byte *) ep.value;
				byte *d = (byte *) eparam.valuePtr;
				for (int i = 0; i < valCount * Marshal.SizeOf(valType); i++)
					*d++ = *s++;
			}

			return eparam;
		}
	}
}