Exemple #1
0
        /// <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 = new NativeList();
            int        intSize    = Marshal.SizeOf(typeof(IntPtr));

            IntPtr nativeListInternal = Marshal.AllocHGlobal(list.Count * intSize);

            returnList.AllocatedMemory.Add(nativeListInternal);
            for (int i = 0; i < list.Count; i++)
            {
                IntPtr itemPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(T)));
                returnList.AllocatedMemory.Add(itemPtr);
                Marshal.StructureToPtr(list[i], itemPtr, false);

                Marshal.WriteIntPtr(nativeListInternal, i * intSize, itemPtr);
            }

            hb_list_s nativeListStruct = new hb_list_s
            {
                items       = nativeListInternal,
                items_alloc = list.Count,
                items_count = list.Count
            };

            IntPtr nativeListStructPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(hb_list_s)));

            Marshal.StructureToPtr(nativeListStruct, nativeListStructPtr, false);

            returnList.ListPtr = nativeListStructPtr;
            return(returnList);
        }
        /// <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 = new NativeList();
            int        intSize    = Marshal.SizeOf(typeof(IntPtr));

            IntPtr nativeListInternal = Marshal.AllocHGlobal(list.Count * intSize);

            returnList.AllocatedMemory.Add(nativeListInternal);
            for (int i = 0; i < list.Count; i++)
            {
                Marshal.WriteIntPtr(nativeListInternal, i * intSize, list[i]);
            }

            hb_list_s nativeListStruct = new hb_list_s();

            nativeListStruct.items       = nativeListInternal;
            nativeListStruct.items_alloc = list.Count;
            nativeListStruct.items_count = list.Count;

            IntPtr nativeListStructPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(hb_list_s)));

            Marshal.StructureToPtr(nativeListStruct, nativeListStructPtr, false);

            returnList.ListPtr = nativeListStructPtr;
            return(returnList);
        }
Exemple #3
0
        /// <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>();
            hb_list_s itemList   = ReadStructure <hb_list_s>(listPtr);

            for (int i = 0; i < itemList.items_count; i++)
            {
                IntPtr itemPtr = Marshal.ReadIntPtr(itemList.items, i * Marshal.SizeOf(typeof(IntPtr)));
                returnList.Add(itemPtr);
            }

            return(returnList);
        }
        /// <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> ConvertList <T>(IntPtr listPtr)
        {
            List <T>  returnList = new List <T>();
            hb_list_s itemList   = ReadStructure <hb_list_s>(listPtr);

            for (int i = 0; i < itemList.items_count; i++)
            {
                IntPtr itemPtr = Marshal.ReadIntPtr(itemList.items, i * Marshal.SizeOf(typeof(IntPtr)));
                returnList.Add(ReadStructure <T>(itemPtr));
            }

            return(returnList);
        }
Exemple #5
0
        /// <summary>
        /// Creats a new, empty native HandBrake list.
        /// </summary>
        /// <param name="capacity">The capacity of the new list.</param>
        /// <returns>The new native list.</returns>
        public static NativeList CreateNativeList(int capacity)
        {
            NativeList returnList = new NativeList();
            int        intSize    = Marshal.SizeOf(typeof(IntPtr));

            IntPtr nativeListInternal = Marshal.AllocHGlobal(capacity * intSize);

            returnList.AllocatedMemory.Add(nativeListInternal);

            hb_list_s nativeListStruct = new hb_list_s {
                items = nativeListInternal, items_alloc = capacity, items_count = 0
            };

            IntPtr nativeListStructPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(hb_list_s)));

            Marshal.StructureToPtr(nativeListStruct, nativeListStructPtr, false);

            returnList.ListPtr = nativeListStructPtr;
            return(returnList);
        }