From f2ca02b9220a88a018759932dd9608b2de8a91cf Mon Sep 17 00:00:00 2001
From: sr55 <sr55.hb@outlook.com>
Date: Fri, 21 Feb 2014 22:06:24 +0000
Subject: WinGui: Some tidy up and refactoring in the interop library. Few
 small internal namespace changes.

git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@6053 b64f7644-9d1e-0410-96f1-a4d463321fa5
---
 .../HandBrakeInterop/Helpers/InteropUtilities.cs   | 249 +++++++++++++++++++++
 .../HandBrakeInterop/Helpers/Languages.cs          |  51 +++++
 .../Helpers/MarshalingConstants.cs                 |  32 +++
 .../HandBrakeInterop/Helpers/NativeList.cs         | 125 +++++++++++
 .../HandBrakeInterop/Helpers/Utilities.cs          |  66 ++++++
 5 files changed, 523 insertions(+)
 create mode 100644 win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/InteropUtilities.cs
 create mode 100644 win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/Languages.cs
 create mode 100644 win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/MarshalingConstants.cs
 create mode 100644 win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/NativeList.cs
 create mode 100644 win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/Utilities.cs

(limited to 'win/CS/HandBrake.Interop/HandBrakeInterop/Helpers')

diff --git a/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/InteropUtilities.cs b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/InteropUtilities.cs
new file mode 100644
index 000000000..0019aa2d2
--- /dev/null
+++ b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/InteropUtilities.cs
@@ -0,0 +1,249 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="InteropUtilities.cs" company="HandBrake Project (http://handbrake.fr)">
+//   This file is part of the HandBrake source code - It may be used under the terms of the GNU General Public License.
+// </copyright>
+// <summary>
+//   Helper utilities for native interop.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace HandBrake.Interop.Helpers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using System.Text;
+
+    using HandBrake.Interop.HbLib;
+
+    /// <summary>
+	/// Helper utilities for native interop.
+	/// </summary>
+	public static class InteropUtilities
+	{
+		/// <summary>
+		/// Reads the given native structure pointer.
+		/// </summary>
+		/// <typeparam name="T">The type to convert the structure to.</typeparam>
+		/// <param name="structPtr">The pointer to the native structure.</param>
+		/// <returns>The converted structure.</returns>
+		public static T ReadStructure<T>(IntPtr structPtr)
+		{
+			return (T)Marshal.PtrToStructure(structPtr, typeof(T));
+		}
+
+		/// <summary>
+		/// Reads the given native UTF-8 string.
+		/// </summary>
+		/// <param name="stringPtr">The pointer to the string.</param>
+		/// <returns>The resulting string.</returns>
+		public static string ReadUtf8Ptr(IntPtr stringPtr)
+		{
+			var data = new List<byte>();
+			var ptr = stringPtr;
+			var offset = 0;
+			while (true)
+			{
+				byte ch = Marshal.ReadByte(ptr, offset++);
+				if (ch == 0)
+				{
+					break;
+				}
+
+				data.Add(ch);
+			}
+
+			return Encoding.UTF8.GetString(data.ToArray());
+		}
+
+		/// <summary>
+		/// Creates a pointer to a UTF-8 null-terminated string.
+		/// </summary>
+		/// <param name="str">
+		/// The string to encode.
+		/// </param>
+		/// <returns>
+		/// The <see cref="IntPtr"/>.
+		/// </returns>
+		public static IntPtr CreateUtf8Ptr(string str)
+		{
+			byte[] bytes = Encoding.UTF8.GetBytes(str);
+			IntPtr stringPtr = Marshal.AllocHGlobal(bytes.Length + 1);
+			var offset = 0;
+			foreach (byte b in bytes)
+			{
+				Marshal.WriteByte(stringPtr, offset, b);
+				offset++;
+			}
+
+			Marshal.WriteByte(stringPtr, offset, 0);
+			return stringPtr;
+		}
+
+		/// <summary>
+		/// Converts the given native HandBrake list to a managed list.
+		/// </summary>
+		/// <typeparam name="T">The type of structure in the list.</typeparam>
+		/// <param name="listPtr">The pointer to the native list.</param>
+		/// <returns>The converted managed list.</returns>
+		public static List<T> ToList<T>(this IntPtr listPtr)
+		{
+			List<T> returnList = new List<T>();
+			NativeList nativeList = new NativeList(listPtr);
+
+			for (int i = 0; i < nativeList.Count; i++)
+			{
+				IntPtr itemPtr = nativeList[i];
+				returnList.Add(ReadStructure<T>(itemPtr));
+			}
+
+			return returnList;
+		}
+
+		/// <summary>
+		/// Converts the HB list to a managed list of pointers.
+		/// </summary>
+		/// <param name="listPtr">The list to convert.</param>
+		/// <returns>The managed list of pointers.</returns>
+		public static List<IntPtr> ToIntPtrList(this IntPtr listPtr)
+		{
+			var returnList = new List<IntPtr>();
+			NativeList nativeList = new NativeList(listPtr);
+
+			for (int i = 0; i < nativeList.Count; i++)
+			{
+				IntPtr itemPtr = nativeList[i];
+				returnList.Add(itemPtr);
+			}
+
+			return returnList;
+		}
+
+		/// <summary>
+		/// Converts the given native array to a managed collection.
+		/// </summary>
+		/// <typeparam name="T">The type of item in the list.</typeparam>
+		/// <param name="arrayPtr">The pointer to the array.</param>
+		/// <param name="count">The number of items in the array.</param>
+		/// <returns>The converted collection.</returns>
+		public static IEnumerable<T> ConvertArray<T>(IntPtr arrayPtr, int count)
+		{
+			IntPtr currentItem = arrayPtr;
+
+			var result = new List<T>();
+			for (int i = 0; i < count; i++)
+			{
+				T nativeEncoder = ReadStructure<T>(currentItem);
+				result.Add(nativeEncoder);
+
+				currentItem = IntPtr.Add(currentItem, Marshal.SizeOf(typeof(T)));
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		/// Creates a native HandBrake list from the given managed list of pointers.
+		/// </summary>
+		/// <param name="list">The managed list to convert.</param>
+		/// <returns>The converted native list.</returns>
+		public static NativeList CreateIntPtrList(List<IntPtr> list)
+		{
+			NativeList returnList = NativeList.CreateList();
+
+			foreach (IntPtr ptr in list)
+			{
+				returnList.Add(ptr);
+			}
+
+			return returnList;
+		}
+
+		/// <summary>
+		/// Creates a native HandBrake list from the given managed list of structures.
+		/// </summary>
+		/// <typeparam name="T">The type of structures in the list.</typeparam>
+		/// <param name="list">The managed list to convert.</param>
+		/// <returns>The converted native list.</returns>
+		public static NativeList ConvertListBack<T>(List<T> list)
+		{
+			NativeList returnList = NativeList.CreateList();
+			foreach (T item in list)
+			{
+				IntPtr itemPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(T)));
+				returnList.AllocatedMemory.Add(itemPtr);
+				Marshal.StructureToPtr(item, itemPtr, false);
+
+				returnList.Add(itemPtr);
+			}
+
+			return returnList;
+		}
+
+		/// <summary>
+		/// Reads in a list of objects given an interator and a conversion function.
+		/// </summary>
+		/// <typeparam name="T1">The type of the struct given by the iterator.</typeparam>
+		/// <typeparam name="T2">The object type to convert to.</typeparam>
+		/// <param name="iterator">The iterator to use to build the list.</param>
+		/// <param name="converter">The converter to convert from the struct to the object.</param>
+		/// <returns>The list of objects.</returns>
+		public static List<T2> GetListFromIterator<T1, T2>(Func<IntPtr, IntPtr> iterator, Func<T1, T2> converter)
+		{
+			return ReadStructureListFromIterator<T1>(iterator).Select(converter).ToList();
+		} 
+
+		/// <summary>
+		/// Reads in a list of structs given an iterator.
+		/// </summary>
+		/// <typeparam name="T">The type of the struct.</typeparam>
+		/// <param name="iterator">The iterator to use to build the list.</param>
+		/// <returns>The list of structs.</returns>
+		public static List<T> ReadStructureListFromIterator<T>(Func<IntPtr, IntPtr> iterator)
+		{
+			var structureList = new List<T>();
+			IntPtr current = IntPtr.Zero;
+
+			current = iterator(current);
+			while (current != IntPtr.Zero)
+			{
+				T encoder = ReadStructure<T>(current);
+				structureList.Add(encoder);
+
+				current = iterator(current);
+			}
+
+			return structureList;
+		}
+
+		/// <summary>
+		/// Closes the given job.
+		/// </summary>
+		/// <param name="nativeJobPtr">The pointer to the job.</param>
+		public static void CloseJob(IntPtr nativeJobPtr)
+		{
+			// Create a point to the job pointer first.
+			IntPtr nativeJobPtrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)));
+
+			// Assign the new pointer to the job pointer and tell HB to clean the job up.
+			Marshal.WriteIntPtr(nativeJobPtrPtr, nativeJobPtr);
+			HBFunctions.hb_job_close(nativeJobPtrPtr);
+
+			// Free the pointer we used.
+			Marshal.FreeHGlobal(nativeJobPtrPtr);
+		}
+
+		/// <summary>
+		/// Frees all the memory locations in the given list.
+		/// </summary>
+		/// <param name="memoryList">The list of memory locations to free.</param>
+		public static void FreeMemory(List<IntPtr> memoryList)
+		{
+			foreach (IntPtr memoryLocation in memoryList)
+			{
+				Marshal.FreeHGlobal(memoryLocation);
+			}
+		}
+	}
+}
diff --git a/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/Languages.cs b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/Languages.cs
new file mode 100644
index 000000000..b89e190eb
--- /dev/null
+++ b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/Languages.cs
@@ -0,0 +1,51 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="Languages.cs" company="HandBrake Project (http://handbrake.fr)">
+//   This file is part of the HandBrake source code - It may be used under the terms of the GNU General Public License.
+// </copyright>
+// <summary>
+//   Contains utilities for converting language codes.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace HandBrake.Interop.Helpers
+{
+    using System.Collections.Generic;
+
+    using HandBrake.Interop.HbLib;
+    using HandBrake.Interop.Model;
+
+    /// <summary>
+	/// Contains utilities for converting language codes.
+	/// </summary>
+	public static class Languages
+	{
+		/// <summary>
+		/// The list of all languages.
+		/// </summary>
+		private static IList<Language> allLanguages; 
+
+		/// <summary>
+		/// Gets a list of all languages.
+		/// </summary>
+		public static IList<Language> AllLanguages
+		{
+			get
+			{
+			    return allLanguages
+			           ?? (allLanguages =
+			               InteropUtilities.GetListFromIterator<iso639_lang_t, Language>(HBFunctions.lang_get_next, Converters.Converters.NativeToLanguage));
+			}
+		}
+
+		/// <summary>
+		/// Gets the language object for the given code.
+		/// </summary>
+		/// <param name="code">The ISO-639-2 code for the language.</param>
+		/// <returns>Object that describes the language.</returns>
+		public static Language Get(string code)
+		{
+			iso639_lang_t language = InteropUtilities.ReadStructure<iso639_lang_t>(HBFunctions.lang_for_code2(code));
+			return Converters.Converters.NativeToLanguage(language);
+		}
+	}
+}
diff --git a/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/MarshalingConstants.cs b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/MarshalingConstants.cs
new file mode 100644
index 000000000..98ed5048f
--- /dev/null
+++ b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/MarshalingConstants.cs
@@ -0,0 +1,32 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="MarshalingConstants.cs" company="HandBrake Project (http://handbrake.fr)">
+//   This file is part of the HandBrake source code - It may be used under the terms of the GNU General Public License.
+// </copyright>
+// <summary>
+//   Defines the MarshalingConstants type.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace HandBrake.Interop.Helpers
+{
+    /// <summary>
+    /// The marshaling constants.
+    /// </summary>
+    public static class MarshalingConstants
+	{
+#if X64
+		public const int JobPaddingBytes = 49264;
+		public const int AudioPaddingBytes = 49208;
+#else
+	    /// <summary>
+	    /// Job Padding Bytes
+	    /// </summary>
+	    public const int JobPaddingBytes = 49216;
+
+	    /// <summary>
+	    /// Audio Padding Bytes
+	    /// </summary>
+	    public const int AudioPaddingBytes = 49180;
+#endif
+	}
+}
diff --git a/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/NativeList.cs b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/NativeList.cs
new file mode 100644
index 000000000..c77c58cb9
--- /dev/null
+++ b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/NativeList.cs
@@ -0,0 +1,125 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="NativeList.cs" company="HandBrake Project (http://handbrake.fr)">
+//   This file is part of the HandBrake source code - It may be used under the terms of the GNU General Public License.
+// </copyright>
+// <summary>
+//   Represents a HandBrake style native list.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace HandBrake.Interop.Helpers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Runtime.InteropServices;
+
+    using HandBrake.Interop.HbLib;
+
+    /// <summary>
+	/// Represents a HandBrake style native list.
+	/// </summary>
+	public class NativeList : IDisposable
+	{
+		/// <summary>
+		/// Initializes a new instance of the NativeList class.
+		/// </summary>
+		/// <param name="listPtr">The pointer to use for the list.</param>
+		public NativeList(IntPtr listPtr)
+		{
+			this.Ptr = listPtr;
+		}
+
+		/// <summary>
+		/// The list of native memory locations allocated for this list.
+		/// </summary>
+		private readonly List<IntPtr> allocatedMemory = new List<IntPtr>();
+
+		/// <summary>
+		/// Gets the pointer to the native list.
+		/// </summary>
+		public IntPtr Ptr { get; private set; }
+
+		/// <summary>
+		/// Gets the number of items in the list.
+		/// </summary>
+		public int Count
+		{
+			get
+			{
+				return HBFunctions.hb_list_count(this.Ptr);
+			}
+		}
+
+		/// <summary>
+		/// Gets the list of native memory locations allocated for this list.
+		/// </summary>
+		public List<IntPtr> AllocatedMemory
+		{
+			get
+			{
+				return this.allocatedMemory;
+			}
+		}
+
+		/// <summary>
+		/// Adds an item to the end of the list.
+		/// </summary>
+		/// <param name="item">The item to add.</param>
+		public void Add(IntPtr item)
+		{
+			HBFunctions.hb_list_add(this.Ptr, item);
+		}
+
+		/// <summary>
+		/// Inserts an item into the list.
+		/// </summary>
+		/// <param name="position">The index to insert the item at.</param>
+		/// <param name="item">The item to insert.</param>
+		public void Insert(int position, IntPtr item)
+		{
+			HBFunctions.hb_list_insert(this.Ptr, position, item);
+		}
+
+		/// <summary>
+		/// Removes an item from the list.
+		/// </summary>
+		/// <param name="item">The item to remove.</param>
+		public void Remove(IntPtr item)
+		{
+			HBFunctions.hb_list_rem(this.Ptr, item);
+		}
+
+		/// <summary>
+		/// Gets an item out of the list.
+		/// </summary>
+		/// <param name="i">Index in the list.</param>
+		/// <returns>The item at that index in the list.</returns>
+		public IntPtr this[int i]
+		{
+			get
+			{
+				return HBFunctions.hb_list_item(this.Ptr, i);
+			}
+		}
+
+		/// <summary>
+		/// Disposes resources associated with this object.
+		/// </summary>
+		public void Dispose()
+		{
+			IntPtr listPtrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)));
+			Marshal.WriteIntPtr(listPtrPtr, this.Ptr);
+			HBFunctions.hb_list_close(listPtrPtr);
+			Marshal.FreeHGlobal(listPtrPtr);
+		}
+
+		/// <summary>
+		/// Creates a new list in unmanaged memory.
+		/// </summary>
+		/// <returns>The created list.</returns>
+		public static NativeList CreateList()
+		{
+			return new NativeList(HBFunctions.hb_list_init());
+		}
+	}
+}
diff --git a/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/Utilities.cs b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/Utilities.cs
new file mode 100644
index 000000000..77106f72d
--- /dev/null
+++ b/win/CS/HandBrake.Interop/HandBrakeInterop/Helpers/Utilities.cs
@@ -0,0 +1,66 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="Utilities.cs" company="HandBrake Project (http://handbrake.fr)">
+//   This file is part of the HandBrake source code - It may be used under the terms of the GNU General Public License.
+// </copyright>
+// <summary>
+//   Defines the Utilities type.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace HandBrake.Interop.Helpers
+{
+    using HandBrake.Interop.Model.Encoding;
+
+    /// <summary>
+    /// The utilities.
+    /// </summary>
+    public static class Utilities
+	{
+        /// <summary>
+        /// Get the Greatest Common Factor
+        /// </summary>
+        /// <param name="a">
+        /// The a.
+        /// </param>
+        /// <param name="b">
+        /// The b.
+        /// </param>
+        /// <returns>
+        /// The greatest common factor
+        /// </returns>
+        public static int GreatestCommonFactor(int a, int b)
+		{
+			if (a == 0)
+			{
+				return b;
+			}
+
+			if (b == 0)
+			{
+				return a;
+			}
+
+			if (a > b)
+			{
+				return GreatestCommonFactor(a % b, b);
+			}
+            
+            return GreatestCommonFactor(a, b % a);
+		}
+
+		/// <summary>
+		/// Determines if the given audio encoder is a passthrough encoder choice.
+		/// </summary>
+		/// <param name="encoder">The audio encoder to examine.</param>
+		/// <returns>True if the encoder is passthrough.</returns>
+		public static bool IsPassthrough(AudioEncoder encoder)
+		{
+			return encoder == AudioEncoder.Ac3Passthrough ||
+                   encoder == AudioEncoder.DtsHDPassthrough ||
+                   encoder == AudioEncoder.DtsPassthrough ||
+                   encoder == AudioEncoder.Mp3Passthru || 
+                   encoder == AudioEncoder.AacPassthru ||
+                   encoder == AudioEncoder.Passthrough;
+		}
+	}
+}
-- 
cgit v1.2.3