diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.cxx index 4377d593dd..81cac6c201 100644 --- a/src/mod/languages/mod_managed/freeswitch_wrap.cxx +++ b/src/mod/languages/mod_managed/freeswitch_wrap.cxx @@ -2092,6 +2092,50 @@ SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_CORE_SESSION_MAX_PRIVATES_get() { } +SWIGEXPORT double SWIGSTDCALL CSharp_JITTER_VARIANCE_THRESHOLD_get() { + double jresult ; + double result; + + result = (double) 400.0; + + jresult = result; + return jresult; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_IPDV_THRESHOLD_get() { + double jresult ; + double result; + + result = (double) 1.0; + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_LOST_BURST_ANALYZE_get() { + int jresult ; + int result; + + result = (int) 500; + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_LOST_BURST_CAPTURE_get() { + int jresult ; + int result; + + result = (int) 1024; + + jresult = result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_dtmf_t_digit_set(void * jarg1, char jarg2) { switch_dtmf_t *arg1 = (switch_dtmf_t *) 0 ; char arg2 ; @@ -3528,6 +3572,458 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_numbers_t_largest_jb_size_get(vo } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_last_proc_time_set(void * jarg1, long long jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int64_t arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (int64_t)jarg2; + if (arg1) (arg1)->last_proc_time = arg2; + +} + + +SWIGEXPORT long long SWIGSTDCALL CSharp_switch_rtp_numbers_t_last_proc_time_get(void * jarg1) { + long long jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int64_t result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (int64_t) ((arg1)->last_proc_time); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_jitter_n_set(void * jarg1, long long jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int64_t arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (int64_t)jarg2; + if (arg1) (arg1)->jitter_n = arg2; + +} + + +SWIGEXPORT long long SWIGSTDCALL CSharp_switch_rtp_numbers_t_jitter_n_get(void * jarg1) { + long long jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int64_t result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (int64_t) ((arg1)->jitter_n); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_jitter_add_set(void * jarg1, long long jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int64_t arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (int64_t)jarg2; + if (arg1) (arg1)->jitter_add = arg2; + +} + + +SWIGEXPORT long long SWIGSTDCALL CSharp_switch_rtp_numbers_t_jitter_add_get(void * jarg1) { + long long jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int64_t result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (int64_t) ((arg1)->jitter_add); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_jitter_addsq_set(void * jarg1, long long jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int64_t arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (int64_t)jarg2; + if (arg1) (arg1)->jitter_addsq = arg2; + +} + + +SWIGEXPORT long long SWIGSTDCALL CSharp_switch_rtp_numbers_t_jitter_addsq_get(void * jarg1) { + long long jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int64_t result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (int64_t) ((arg1)->jitter_addsq); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_variance_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->variance = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_variance_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->variance); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_min_variance_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->min_variance = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_min_variance_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->min_variance); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_max_variance_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->max_variance = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_max_variance_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->max_variance); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_std_deviation_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->std_deviation = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_std_deviation_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->std_deviation); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_lossrate_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->lossrate = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_lossrate_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->lossrate); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_burstrate_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->burstrate = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_burstrate_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->burstrate); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_mean_interval_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->mean_interval = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_mean_interval_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->mean_interval); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_loss_set(void * jarg1, void * jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int *arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (int *)jarg2; + { + size_t ii; + int *b = (int *) arg1->loss; + for (ii = 0; ii < (size_t)1024; ii++) b[ii] = *((int *) arg2 + ii); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_numbers_t_loss_get(void * jarg1) { + void * jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int *result = 0 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (int *)(int *) ((arg1)->loss); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_last_loss_set(void * jarg1, int jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->last_loss = arg2; + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_numbers_t_last_loss_get(void * jarg1) { + int jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (int) ((arg1)->last_loss); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_recved_set(void * jarg1, int jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->recved = arg2; + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_numbers_t_recved_get(void * jarg1) { + int jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (int) ((arg1)->recved); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_last_processed_seq_set(void * jarg1, int jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->last_processed_seq = arg2; + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_numbers_t_last_processed_seq_get(void * jarg1) { + int jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + int result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (int) ((arg1)->last_processed_seq); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_flaws_set(void * jarg1, void * jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + switch_size_t arg2 ; + switch_size_t *argp2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + argp2 = (switch_size_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_size_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->flaws = arg2; + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_numbers_t_flaws_get(void * jarg1) { + void * jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + switch_size_t result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = ((arg1)->flaws); + jresult = new switch_size_t((switch_size_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_last_flaw_set(void * jarg1, void * jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + switch_size_t arg2 ; + switch_size_t *argp2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + argp2 = (switch_size_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_size_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->last_flaw = arg2; + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_numbers_t_last_flaw_get(void * jarg1) { + void * jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + switch_size_t result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = ((arg1)->last_flaw); + jresult = new switch_size_t((switch_size_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_R_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->R = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_R_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->R); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_numbers_t_mos_set(void * jarg1, double jarg2) { + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->mos = arg2; + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtp_numbers_t_mos_get(void * jarg1) { + double jresult ; + switch_rtp_numbers_t *arg1 = (switch_rtp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtp_numbers_t *)jarg1; + result = (double) ((arg1)->mos); + jresult = result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_rtp_numbers_t() { void * jresult ; switch_rtp_numbers_t *result = 0 ; @@ -9393,19 +9889,21 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_media_bug_set_pre_buffer_framecoun } -SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_port_allocator_new(unsigned short jarg1, unsigned short jarg2, unsigned long jarg3, void * jarg4) { +SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_port_allocator_new(char * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned long jarg4, void * jarg5) { int jresult ; - switch_port_t arg1 ; + char *arg1 = (char *) 0 ; switch_port_t arg2 ; - switch_port_flag_t arg3 ; - switch_core_port_allocator_t **arg4 = (switch_core_port_allocator_t **) 0 ; + switch_port_t arg3 ; + switch_port_flag_t arg4 ; + switch_core_port_allocator_t **arg5 = (switch_core_port_allocator_t **) 0 ; switch_status_t result; - arg1 = (switch_port_t)jarg1; + arg1 = (char *)jarg1; arg2 = (switch_port_t)jarg2; - arg3 = (switch_port_flag_t)jarg3; - arg4 = (switch_core_port_allocator_t **)jarg4; - result = (switch_status_t)switch_core_port_allocator_new(arg1,arg2,arg3,arg4); + arg3 = (switch_port_t)jarg3; + arg4 = (switch_port_flag_t)jarg4; + arg5 = (switch_core_port_allocator_t **)jarg5; + result = (switch_status_t)switch_core_port_allocator_new((char const *)arg1,arg2,arg3,arg4,arg5); jresult = result; return jresult; } @@ -16570,6 +17068,18 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_true(char * jarg1) { } +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_switch_true_byte(char * jarg1) { + unsigned char jresult ; + char *arg1 = (char *) 0 ; + switch_byte_t result; + + arg1 = (char *)jarg1; + result = (switch_byte_t)switch_true_byte((char const *)arg1); + jresult = result; + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_false(char * jarg1) { int jresult ; char *arg1 = (char *) 0 ; @@ -40939,6 +41449,29 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_scheduler_task_task_id_get(vo } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_scheduler_task_hash_set(void * jarg1, unsigned long jarg2) { + switch_scheduler_task *arg1 = (switch_scheduler_task *) 0 ; + unsigned long arg2 ; + + arg1 = (switch_scheduler_task *)jarg1; + arg2 = (unsigned long)jarg2; + if (arg1) (arg1)->hash = arg2; + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_scheduler_task_hash_get(void * jarg1) { + unsigned long jresult ; + switch_scheduler_task *arg1 = (switch_scheduler_task *) 0 ; + unsigned long result; + + arg1 = (switch_scheduler_task *)jarg1; + result = (unsigned long) ((arg1)->hash); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_scheduler_task() { void * jresult ; switch_scheduler_task *result = 0 ; diff --git a/src/mod/languages/mod_managed/managed/swig.cs b/src/mod/languages/mod_managed/managed/swig.cs index 5f9fe31b50..a8f4553b40 100644 --- a/src/mod/languages/mod_managed/managed/swig.cs +++ b/src/mod/languages/mod_managed/managed/swig.cs @@ -1372,8 +1372,8 @@ public class freeswitch { return ret; } - public static switch_status_t switch_core_port_allocator_new(ushort start, ushort end, uint flags, SWIGTYPE_p_p_switch_core_port_allocator new_allocator) { - switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_port_allocator_new(start, end, flags, SWIGTYPE_p_p_switch_core_port_allocator.getCPtr(new_allocator)); + public static switch_status_t switch_core_port_allocator_new(string ip, ushort start, ushort end, uint flags, SWIGTYPE_p_p_switch_core_port_allocator new_allocator) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_port_allocator_new(ip, start, end, flags, SWIGTYPE_p_p_switch_core_port_allocator.getCPtr(new_allocator)); return ret; } @@ -3659,6 +3659,11 @@ public class freeswitch { return ret; } + public static byte switch_true_byte(string expr) { + byte ret = freeswitchPINVOKE.switch_true_byte(expr); + return ret; + } + public static int switch_false(string expr) { int ret = freeswitchPINVOKE.switch_false(expr); return ret; @@ -7023,6 +7028,10 @@ public class freeswitch { public static readonly int SWITCH_DTMF_LOG_LEN = freeswitchPINVOKE.SWITCH_DTMF_LOG_LEN_get(); public static readonly int SWITCH_MAX_TRANS = freeswitchPINVOKE.SWITCH_MAX_TRANS_get(); public static readonly int SWITCH_CORE_SESSION_MAX_PRIVATES = freeswitchPINVOKE.SWITCH_CORE_SESSION_MAX_PRIVATES_get(); + public static readonly double JITTER_VARIANCE_THRESHOLD = freeswitchPINVOKE.JITTER_VARIANCE_THRESHOLD_get(); + public static readonly double IPDV_THRESHOLD = freeswitchPINVOKE.IPDV_THRESHOLD_get(); + public static readonly int LOST_BURST_ANALYZE = freeswitchPINVOKE.LOST_BURST_ANALYZE_get(); + public static readonly int LOST_BURST_CAPTURE = freeswitchPINVOKE.LOST_BURST_CAPTURE_get(); public static readonly int SWITCH_MAX_STACKS = freeswitchPINVOKE.SWITCH_MAX_STACKS_get(); public static readonly int SWITCH_THREAD_STACKSIZE = freeswitchPINVOKE.SWITCH_THREAD_STACKSIZE_get(); public static readonly int SWITCH_SYSTEM_THREAD_STACKSIZE = freeswitchPINVOKE.SWITCH_SYSTEM_THREAD_STACKSIZE_get(); @@ -7771,6 +7780,18 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CORE_SESSION_MAX_PRIVATES_get")] public static extern int SWITCH_CORE_SESSION_MAX_PRIVATES_get(); + [DllImport("mod_managed", EntryPoint="CSharp_JITTER_VARIANCE_THRESHOLD_get")] + public static extern double JITTER_VARIANCE_THRESHOLD_get(); + + [DllImport("mod_managed", EntryPoint="CSharp_IPDV_THRESHOLD_get")] + public static extern double IPDV_THRESHOLD_get(); + + [DllImport("mod_managed", EntryPoint="CSharp_LOST_BURST_ANALYZE_get")] + public static extern int LOST_BURST_ANALYZE_get(); + + [DllImport("mod_managed", EntryPoint="CSharp_LOST_BURST_CAPTURE_get")] + public static extern int LOST_BURST_CAPTURE_get(); + [DllImport("mod_managed", EntryPoint="CSharp_switch_dtmf_t_digit_set")] public static extern void switch_dtmf_t_digit_set(HandleRef jarg1, char jarg2); @@ -8107,6 +8128,120 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_largest_jb_size_get")] public static extern IntPtr switch_rtp_numbers_t_largest_jb_size_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_last_proc_time_set")] + public static extern void switch_rtp_numbers_t_last_proc_time_set(HandleRef jarg1, long jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_last_proc_time_get")] + public static extern long switch_rtp_numbers_t_last_proc_time_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_jitter_n_set")] + public static extern void switch_rtp_numbers_t_jitter_n_set(HandleRef jarg1, long jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_jitter_n_get")] + public static extern long switch_rtp_numbers_t_jitter_n_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_jitter_add_set")] + public static extern void switch_rtp_numbers_t_jitter_add_set(HandleRef jarg1, long jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_jitter_add_get")] + public static extern long switch_rtp_numbers_t_jitter_add_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_jitter_addsq_set")] + public static extern void switch_rtp_numbers_t_jitter_addsq_set(HandleRef jarg1, long jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_jitter_addsq_get")] + public static extern long switch_rtp_numbers_t_jitter_addsq_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_variance_set")] + public static extern void switch_rtp_numbers_t_variance_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_variance_get")] + public static extern double switch_rtp_numbers_t_variance_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_min_variance_set")] + public static extern void switch_rtp_numbers_t_min_variance_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_min_variance_get")] + public static extern double switch_rtp_numbers_t_min_variance_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_max_variance_set")] + public static extern void switch_rtp_numbers_t_max_variance_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_max_variance_get")] + public static extern double switch_rtp_numbers_t_max_variance_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_std_deviation_set")] + public static extern void switch_rtp_numbers_t_std_deviation_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_std_deviation_get")] + public static extern double switch_rtp_numbers_t_std_deviation_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_lossrate_set")] + public static extern void switch_rtp_numbers_t_lossrate_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_lossrate_get")] + public static extern double switch_rtp_numbers_t_lossrate_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_burstrate_set")] + public static extern void switch_rtp_numbers_t_burstrate_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_burstrate_get")] + public static extern double switch_rtp_numbers_t_burstrate_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_mean_interval_set")] + public static extern void switch_rtp_numbers_t_mean_interval_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_mean_interval_get")] + public static extern double switch_rtp_numbers_t_mean_interval_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_loss_set")] + public static extern void switch_rtp_numbers_t_loss_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_loss_get")] + public static extern IntPtr switch_rtp_numbers_t_loss_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_last_loss_set")] + public static extern void switch_rtp_numbers_t_last_loss_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_last_loss_get")] + public static extern int switch_rtp_numbers_t_last_loss_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_recved_set")] + public static extern void switch_rtp_numbers_t_recved_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_recved_get")] + public static extern int switch_rtp_numbers_t_recved_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_last_processed_seq_set")] + public static extern void switch_rtp_numbers_t_last_processed_seq_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_last_processed_seq_get")] + public static extern int switch_rtp_numbers_t_last_processed_seq_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_flaws_set")] + public static extern void switch_rtp_numbers_t_flaws_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_flaws_get")] + public static extern IntPtr switch_rtp_numbers_t_flaws_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_last_flaw_set")] + public static extern void switch_rtp_numbers_t_last_flaw_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_last_flaw_get")] + public static extern IntPtr switch_rtp_numbers_t_last_flaw_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_R_set")] + public static extern void switch_rtp_numbers_t_R_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_R_get")] + public static extern double switch_rtp_numbers_t_R_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_mos_set")] + public static extern void switch_rtp_numbers_t_mos_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_numbers_t_mos_get")] + public static extern double switch_rtp_numbers_t_mos_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_rtp_numbers_t")] public static extern IntPtr new_switch_rtp_numbers_t(); @@ -9563,7 +9698,7 @@ class freeswitchPINVOKE { public static extern int switch_core_media_bug_set_pre_buffer_framecount(HandleRef jarg1, uint jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_core_port_allocator_new")] - public static extern int switch_core_port_allocator_new(ushort jarg1, ushort jarg2, uint jarg3, HandleRef jarg4); + public static extern int switch_core_port_allocator_new(string jarg1, ushort jarg2, ushort jarg3, uint jarg4, HandleRef jarg5); [DllImport("mod_managed", EntryPoint="CSharp_switch_core_port_allocator_request_port")] public static extern int switch_core_port_allocator_request_port(HandleRef jarg1, HandleRef jarg2); @@ -11197,6 +11332,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_true")] public static extern int switch_true(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_true_byte")] + public static extern byte switch_true_byte(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_false")] public static extern int switch_false(string jarg1); @@ -16876,6 +17014,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_scheduler_task_task_id_get")] public static extern uint switch_scheduler_task_task_id_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_scheduler_task_hash_set")] + public static extern void switch_scheduler_task_hash_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_scheduler_task_hash_get")] + public static extern uint switch_scheduler_task_hash_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_scheduler_task")] public static extern IntPtr new_switch_scheduler_task(); @@ -26726,6 +26870,7 @@ public enum switch_channel_flag_t { CF_SLA_INTERCEPT, CF_VIDEO_BREAK, CF_MEDIA_PAUSE, + CF_BYPASS_MEDIA_AFTER_HOLD, CF_FLAG_MAX } @@ -34755,7 +34900,9 @@ namespace FreeSWITCH.Native { [System.Flags] public enum switch_port_flag_enum_t { SPF_NONE = 0, SPF_ODD = (1 << 0), - SPF_EVEN = (1 << 1) + SPF_EVEN = (1 << 1), + SPF_ROBUST_TCP = (1 << 2), + SPF_ROBUST_UDP = (1 << 3) } } @@ -35596,6 +35743,201 @@ public class switch_rtp_numbers_t : IDisposable { } } + public long last_proc_time { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_last_proc_time_set(swigCPtr, value); + } + get { + long ret = freeswitchPINVOKE.switch_rtp_numbers_t_last_proc_time_get(swigCPtr); + return ret; + } + } + + public long jitter_n { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_jitter_n_set(swigCPtr, value); + } + get { + long ret = freeswitchPINVOKE.switch_rtp_numbers_t_jitter_n_get(swigCPtr); + return ret; + } + } + + public long jitter_add { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_jitter_add_set(swigCPtr, value); + } + get { + long ret = freeswitchPINVOKE.switch_rtp_numbers_t_jitter_add_get(swigCPtr); + return ret; + } + } + + public long jitter_addsq { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_jitter_addsq_set(swigCPtr, value); + } + get { + long ret = freeswitchPINVOKE.switch_rtp_numbers_t_jitter_addsq_get(swigCPtr); + return ret; + } + } + + public double variance { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_variance_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_variance_get(swigCPtr); + return ret; + } + } + + public double min_variance { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_min_variance_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_min_variance_get(swigCPtr); + return ret; + } + } + + public double max_variance { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_max_variance_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_max_variance_get(swigCPtr); + return ret; + } + } + + public double std_deviation { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_std_deviation_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_std_deviation_get(swigCPtr); + return ret; + } + } + + public double lossrate { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_lossrate_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_lossrate_get(swigCPtr); + return ret; + } + } + + public double burstrate { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_burstrate_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_burstrate_get(swigCPtr); + return ret; + } + } + + public double mean_interval { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_mean_interval_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_mean_interval_get(swigCPtr); + return ret; + } + } + + public SWIGTYPE_p_int loss { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_loss_set(swigCPtr, SWIGTYPE_p_int.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_rtp_numbers_t_loss_get(swigCPtr); + SWIGTYPE_p_int ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_int(cPtr, false); + return ret; + } + } + + public int last_loss { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_last_loss_set(swigCPtr, value); + } + get { + int ret = freeswitchPINVOKE.switch_rtp_numbers_t_last_loss_get(swigCPtr); + return ret; + } + } + + public int recved { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_recved_set(swigCPtr, value); + } + get { + int ret = freeswitchPINVOKE.switch_rtp_numbers_t_recved_get(swigCPtr); + return ret; + } + } + + public int last_processed_seq { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_last_processed_seq_set(swigCPtr, value); + } + get { + int ret = freeswitchPINVOKE.switch_rtp_numbers_t_last_processed_seq_get(swigCPtr); + return ret; + } + } + + public SWIGTYPE_p_switch_size_t flaws { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_flaws_set(swigCPtr, SWIGTYPE_p_switch_size_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_rtp_numbers_t_flaws_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public SWIGTYPE_p_switch_size_t last_flaw { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_last_flaw_set(swigCPtr, SWIGTYPE_p_switch_size_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_rtp_numbers_t_last_flaw_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public double R { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_R_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_R_get(swigCPtr); + return ret; + } + } + + public double mos { + set { + freeswitchPINVOKE.switch_rtp_numbers_t_mos_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtp_numbers_t_mos_get(swigCPtr); + return ret; + } + } + public switch_rtp_numbers_t() : this(freeswitchPINVOKE.new_switch_rtp_numbers_t(), true) { } @@ -35792,7 +36134,8 @@ namespace FreeSWITCH.Native { public enum switch_say_gender_t { SSG_MASCULINE, SSG_FEMININE, - SSG_NEUTER + SSG_NEUTER, + SSG_UTRUM } } @@ -36111,6 +36454,16 @@ public class switch_scheduler_task : IDisposable { } } + public uint hash { + set { + freeswitchPINVOKE.switch_scheduler_task_hash_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_scheduler_task_hash_get(swigCPtr); + return ret; + } + } + public switch_scheduler_task() : this(freeswitchPINVOKE.new_switch_scheduler_task(), true) { }