subprojects/gstreamer-sharp/sources/generated/Gst.Sdp/MIKEYPayload.cs

// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.

namespace Gst.Sdp {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;

#region Autogenerated code
	public partial class MIKEYPayload : Gst.MiniObject {

		public Gst.Sdp.MIKEYPayloadType Type {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("type"));
					return (Gst.Sdp.MIKEYPayloadType) (*raw_ptr);
				}
			}
			set {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("type"));
					*raw_ptr = (int) value;
				}
			}
		}

		public uint Len {
			get {
				unsafe {
					uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("len"));
					return (*raw_ptr);
				}
			}
			set {
				unsafe {
					uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("len"));
					*raw_ptr = value;
				}
			}
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_mikey_payload_get_type();

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = gst_mikey_payload_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_kemac_add_sub(IntPtr raw, IntPtr newpay);

		public bool KemacAddSub(Gst.Sdp.MIKEYPayload newpay) {
			newpay.Owned = false;
			bool raw_ret = gst_mikey_payload_kemac_add_sub(Handle, newpay == null ? IntPtr.Zero : newpay.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_mikey_payload_kemac_get_n_sub(IntPtr raw);

		public uint KemacGetNSub() {
			uint raw_ret = gst_mikey_payload_kemac_get_n_sub(Handle);
			uint ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_mikey_payload_kemac_get_sub(IntPtr raw, uint idx);

		public Gst.Sdp.MIKEYPayload KemacGetSub(uint idx) {
			IntPtr raw_ret = gst_mikey_payload_kemac_get_sub(Handle, idx);
			Gst.Sdp.MIKEYPayload ret = raw_ret == IntPtr.Zero ? null : (Gst.Sdp.MIKEYPayload) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Sdp.MIKEYPayload), false);
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_kemac_remove_sub(IntPtr raw, uint idx);

		public bool KemacRemoveSub(uint idx) {
			bool raw_ret = gst_mikey_payload_kemac_remove_sub(Handle, idx);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_kemac_set(IntPtr raw, int enc_alg, int mac_alg);

		public bool KemacSet(Gst.Sdp.MIKEYEncAlg enc_alg, Gst.Sdp.MIKEYMacAlg mac_alg) {
			bool raw_ret = gst_mikey_payload_kemac_set(Handle, (int) enc_alg, (int) mac_alg);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_key_data_set_interval(IntPtr raw, byte vf_len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)]byte[] vf_data, byte vt_len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)]byte[] vt_data);

		public bool KeyDataSetInterval(byte[] vf_data, byte[] vt_data) {
			byte vf_len = (byte)(vf_data == null ? 0 : vf_data.Length);
			byte vt_len = (byte)(vt_data == null ? 0 : vt_data.Length);
			bool raw_ret = gst_mikey_payload_key_data_set_interval(Handle, vf_len, vf_data, vt_len, vt_data);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_key_data_set_key(IntPtr raw, int key_type, ushort key_len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)]byte[] key_data);

		public bool KeyDataSetKey(Gst.Sdp.MIKEYKeyDataType key_type, byte[] key_data) {
			ushort key_len = (ushort)(key_data == null ? 0 : key_data.Length);
			bool raw_ret = gst_mikey_payload_key_data_set_key(Handle, (int) key_type, key_len, key_data);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_key_data_set_salt(IntPtr raw, ushort salt_len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)]byte[] salt_data);

		public bool KeyDataSetSalt(byte[] salt_data) {
			ushort salt_len = (ushort)(salt_data == null ? 0 : salt_data.Length);
			bool raw_ret = gst_mikey_payload_key_data_set_salt(Handle, salt_len, salt_data);
			bool ret = raw_ret;
			return ret;
		}

		public bool KeyDataSetSalt() {
			return KeyDataSetSalt (null);
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_key_data_set_spi(IntPtr raw, byte spi_len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)]byte[] spi_data);

		public bool KeyDataSetSpi(byte[] spi_data) {
			byte spi_len = (byte)(spi_data == null ? 0 : spi_data.Length);
			bool raw_ret = gst_mikey_payload_key_data_set_spi(Handle, spi_len, spi_data);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_pke_set(IntPtr raw, int C, ushort data_len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)]byte[] data);

		public bool PkeSet(Gst.Sdp.MIKEYCacheType C, byte[] data) {
			ushort data_len = (ushort)(data == null ? 0 : data.Length);
			bool raw_ret = gst_mikey_payload_pke_set(Handle, (int) C, data_len, data);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_rand_set(IntPtr raw, byte len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)]byte[] rand);

		public bool RandSet(byte[] rand) {
			byte len = (byte)(rand == null ? 0 : rand.Length);
			bool raw_ret = gst_mikey_payload_rand_set(Handle, len, rand);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_sp_add_param(IntPtr raw, byte type, byte len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)]byte[] val);

		public bool SpAddParam(byte type, byte[] val) {
			byte len = (byte)(val == null ? 0 : val.Length);
			bool raw_ret = gst_mikey_payload_sp_add_param(Handle, type, len, val);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_mikey_payload_sp_get_n_params(IntPtr raw);

		public uint SpGetNParams() {
			uint raw_ret = gst_mikey_payload_sp_get_n_params(Handle);
			uint ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_mikey_payload_sp_get_param(IntPtr raw, uint idx);

		public Gst.Sdp.MIKEYPayloadSPParam SpGetParam(uint idx) {
			IntPtr raw_ret = gst_mikey_payload_sp_get_param(Handle, idx);
			Gst.Sdp.MIKEYPayloadSPParam ret = Gst.Sdp.MIKEYPayloadSPParam.New (raw_ret);
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_sp_remove_param(IntPtr raw, uint idx);

		public bool SpRemoveParam(uint idx) {
			bool raw_ret = gst_mikey_payload_sp_remove_param(Handle, idx);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_sp_set(IntPtr raw, uint policy, int proto);

		public bool SpSet(uint policy, Gst.Sdp.MIKEYSecProto proto) {
			bool raw_ret = gst_mikey_payload_sp_set(Handle, policy, (int) proto);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_mikey_payload_t_set(IntPtr raw, int type, byte[] ts_value);

		public bool TSet(Gst.Sdp.MIKEYTSType type, byte[] ts_value) {
			bool raw_ret = gst_mikey_payload_t_set(Handle, (int) type, ts_value);
			bool ret = raw_ret;
			return ret;
		}

		public MIKEYPayload(IntPtr raw) : base(raw) {}

		[DllImport("gstsdp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_mikey_payload_new(int type);

		public MIKEYPayload (Gst.Sdp.MIKEYPayloadType type) : base (IntPtr.Zero)
		{
			Raw = gst_mikey_payload_new((int) type);
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("type"
							, Gst.MiniObject.abi_info.Fields
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.Sdp.MIKEYPayloadType))) // type
							, null
							, "len"
							, (long) Marshal.OffsetOf(typeof(GstMIKEYPayload_typeAlign), "type")
							, 0
							),
						new GLib.AbiField("len"
							, -1
							, (uint) Marshal.SizeOf(typeof(uint)) // len
							, "type"
							, null
							, (long) Marshal.OffsetOf(typeof(GstMIKEYPayload_lenAlign), "len")
							, 0
							),
					});

				return _abi_info;
			}
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstMIKEYPayload_typeAlign
		{
			sbyte f1;
			private Gst.Sdp.MIKEYPayloadType type;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstMIKEYPayload_lenAlign
		{
			sbyte f1;
			private uint len;
		}


		// End of the ABI representation.

#endregion
	}
}