From acdb1ca58299c12b3d73648901354cfd4220a64a Mon Sep 17 00:00:00 2001 From: Jeff Lenk Date: Sun, 17 May 2015 13:45:52 -0500 Subject: [PATCH] FS-7488 windows fix build error --- .../mod_managed/freeswitch_wrap.2010.cxx | 538 +++++++++++++++++- .../mod_managed/managed/swig.2010.cs | 389 ++++++++++++- 2 files changed, 901 insertions(+), 26 deletions(-) diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx index 6edc41deb3..cefe4b07a7 100644 --- a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx +++ b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx @@ -3918,6 +3918,402 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_peer_ssrc_get( } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_rpt_ts_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->last_rpt_ts = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_rpt_ts_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->last_rpt_ts); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_ssrc_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->ssrc = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_ssrc_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->ssrc); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_csrc_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->csrc = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_csrc_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->csrc); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_pkt_tsdiff_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->last_pkt_tsdiff = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_pkt_tsdiff_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->last_pkt_tsdiff); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_inter_jitter_set(void * jarg1, double jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + double arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->inter_jitter = arg2; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_switch_rtcp_numbers_t_inter_jitter_get(void * jarg1) { + double jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + double result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (double) ((arg1)->inter_jitter); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_rpt_ext_seq_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->last_rpt_ext_seq = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_rpt_ext_seq_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->last_rpt_ext_seq); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_rpt_cycle_set(void * jarg1, unsigned short jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->last_rpt_cycle = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_rpt_cycle_get(void * jarg1) { + unsigned short jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint16_t) ((arg1)->last_rpt_cycle); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_period_pkt_count_set(void * jarg1, unsigned short jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->period_pkt_count = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_switch_rtcp_numbers_t_period_pkt_count_get(void * jarg1) { + unsigned short jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint16_t) ((arg1)->period_pkt_count); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_pkt_count_set(void * jarg1, unsigned short jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->pkt_count = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_switch_rtcp_numbers_t_pkt_count_get(void * jarg1) { + unsigned short jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint16_t) ((arg1)->pkt_count); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_rtcp_rtp_count_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->rtcp_rtp_count = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_rtcp_rtp_count_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->rtcp_rtp_count); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_high_ext_seq_recv_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->high_ext_seq_recv = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_high_ext_seq_recv_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->high_ext_seq_recv); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_cycle_set(void * jarg1, unsigned short jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->cycle = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_switch_rtcp_numbers_t_cycle_get(void * jarg1) { + unsigned short jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint16_t) ((arg1)->cycle); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_bad_seq_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->bad_seq = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_bad_seq_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->bad_seq); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_base_seq_set(void * jarg1, unsigned short jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->base_seq = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_switch_rtcp_numbers_t_base_seq_get(void * jarg1) { + unsigned short jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint16_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint16_t) ((arg1)->base_seq); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_cum_lost_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->cum_lost = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_cum_lost_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->cum_lost); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_recv_lsr_local_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->last_recv_lsr_local = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_recv_lsr_local_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->last_recv_lsr_local); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_recv_lsr_peer_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->last_recv_lsr_peer = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_last_recv_lsr_peer_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->last_recv_lsr_peer); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtcp_numbers_t_init_set(void * jarg1, unsigned long jarg2) { + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->init = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtcp_numbers_t_init_get(void * jarg1) { + unsigned long jresult ; + switch_rtcp_numbers_t *arg1 = (switch_rtcp_numbers_t *) 0 ; + uint32_t result; + + arg1 = (switch_rtcp_numbers_t *)jarg1; + result = (uint32_t) ((arg1)->init); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_rtcp_numbers_t() { void * jresult ; switch_rtcp_numbers_t *result = 0 ; @@ -12457,17 +12853,19 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_codec_init_with_bitrate(void * jar } -SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_codec_copy(void * jarg1, void * jarg2, void * jarg3) { +SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_codec_copy(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { int jresult ; switch_codec_t *arg1 = (switch_codec_t *) 0 ; switch_codec_t *arg2 = (switch_codec_t *) 0 ; - switch_memory_pool_t *arg3 = (switch_memory_pool_t *) 0 ; + switch_codec_settings_t *arg3 = (switch_codec_settings_t *) 0 ; + switch_memory_pool_t *arg4 = (switch_memory_pool_t *) 0 ; switch_status_t result; arg1 = (switch_codec_t *)jarg1; arg2 = (switch_codec_t *)jarg2; - arg3 = (switch_memory_pool_t *)jarg3; - result = (switch_status_t)switch_core_codec_copy(arg1,arg2,arg3); + arg3 = (switch_codec_settings_t *)jarg3; + arg4 = (switch_memory_pool_t *)jarg4; + result = (switch_status_t)switch_core_codec_copy(arg1,arg2,(switch_codec_settings const *)arg3,arg4); jresult = result; return jresult; } @@ -13762,6 +14160,18 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_core_mime_ext2type(char * jarg1) { } +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_core_mime_type2ext(char * jarg1) { + char * jresult ; + char *arg1 = (char *) 0 ; + char *result = 0 ; + + arg1 = (char *)jarg1; + result = (char *)switch_core_mime_type2ext((char const *)arg1); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_mime_add_type(char * jarg1, char * jarg2) { int jresult ; char *arg1 = (char *) 0 ; @@ -14681,6 +15091,22 @@ SWIGEXPORT int SWIGSTDCALL CSharp__switch_cache_db_get_db_handle_dsn(void * jarg } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_cache_db_create_schema(void * jarg1, char * jarg2, void * jarg3) { + int jresult ; + switch_cache_db_handle_t *arg1 = (switch_cache_db_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + char **arg3 = (char **) 0 ; + switch_status_t result; + + arg1 = (switch_cache_db_handle_t *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char **)jarg3; + result = (switch_status_t)switch_cache_db_create_schema(arg1,arg2,arg3); + jresult = result; + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_switch_cache_db_execute_sql2str(void * jarg1, char * jarg2, char * jarg3, unsigned long jarg4, void * jarg5) { char * jresult ; switch_cache_db_handle_t *arg1 = (switch_cache_db_handle_t *) 0 ; @@ -16783,6 +17209,16 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_console_execute(char * jarg1, int jarg2 } +SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_URL_UNSAFE_get() { + char * jresult ; + char *result = 0 ; + +result = (char *)("\r\n #%&+:;<=>?@[\\]^`{|}\""); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_toupper(unsigned long jarg1) { unsigned long jresult ; uint32_t arg1 ; @@ -17409,6 +17845,18 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_is_number(char * jarg1) { } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_is_leading_number(char * jarg1) { + int jresult ; + char *arg1 = (char *) 0 ; + switch_bool_t result; + + arg1 = (char *)jarg1; + result = (switch_bool_t)switch_is_leading_number((char const *)arg1); + jresult = result; + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_switch_find_parameter(char * jarg1, char * jarg2, void * jarg3) { char * jresult ; char *arg1 = (char *) 0 ; @@ -17641,6 +18089,18 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_build_uri(char * jarg1, void * jarg2, c } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_errno_is_break(int jarg1) { + int jresult ; + int arg1 ; + int result; + + arg1 = (int)jarg1; + result = (int)switch_errno_is_break(arg1); + jresult = result; + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_switch_priority_name(int jarg1) { char * jresult ; switch_priority_t arg1 ; @@ -18158,6 +18618,18 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_util_quote_shell_arg_pool(char * jar } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_needs_url_encode(char * jarg1) { + int jresult ; + char *arg1 = (char *) 0 ; + int result; + + arg1 = (char *)jarg1; + result = (int)switch_needs_url_encode((char const *)arg1); + jresult = result; + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_switch_url_encode(char * jarg1, char * jarg2, unsigned long jarg3) { char * jresult ; char *arg1 = (char *) 0 ; @@ -22597,30 +23069,52 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_timer_diff_get(void * jarg1) { } -SWIGEXPORT void SWIGSTDCALL CSharp_switch_timer_tick_set(void * jarg1, void * jarg2) { +SWIGEXPORT void SWIGSTDCALL CSharp_switch_timer_start_set(void * jarg1, void * jarg2) { switch_timer *arg1 = (switch_timer *) 0 ; - switch_size_t arg2 ; - switch_size_t *argp2 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; arg1 = (switch_timer *)jarg1; - argp2 = (switch_size_t *)jarg2; + argp2 = (switch_time_t *)jarg2; if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_size_t", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); return ; } arg2 = *argp2; + if (arg1) (arg1)->start = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_timer_start_get(void * jarg1) { + void * jresult ; + switch_timer *arg1 = (switch_timer *) 0 ; + switch_time_t result; + + arg1 = (switch_timer *)jarg1; + result = ((arg1)->start); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_timer_tick_set(void * jarg1, unsigned long long jarg2) { + switch_timer *arg1 = (switch_timer *) 0 ; + uint64_t arg2 ; + + arg1 = (switch_timer *)jarg1; + arg2 = (uint64_t)jarg2; if (arg1) (arg1)->tick = arg2; } -SWIGEXPORT void * SWIGSTDCALL CSharp_switch_timer_tick_get(void * jarg1) { - void * jresult ; +SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_switch_timer_tick_get(void * jarg1) { + unsigned long long jresult ; switch_timer *arg1 = (switch_timer *) 0 ; - switch_size_t result; + uint64_t result; arg1 = (switch_timer *)jarg1; - result = ((arg1)->tick); - jresult = new switch_size_t((const switch_size_t &)result); + result = (uint64_t) ((arg1)->tick); + jresult = result; return jresult; } @@ -32109,6 +32603,22 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_channel_device_state2str(int jarg1) } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_pass_sdp(void * jarg1, void * jarg2, char * jarg3) { + int jresult ; + switch_channel_t *arg1 = (switch_channel_t *) 0 ; + switch_channel_t *arg2 = (switch_channel_t *) 0 ; + char *arg3 = (char *) 0 ; + switch_status_t result; + + arg1 = (switch_channel_t *)jarg1; + arg2 = (switch_channel_t *)jarg2; + arg3 = (char *)jarg3; + result = (switch_status_t)switch_channel_pass_sdp(arg1,arg2,(char const *)arg3); + jresult = result; + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_buffer_create(void * jarg1, void * jarg2, void * jarg3) { int jresult ; switch_memory_pool_t *arg1 = (switch_memory_pool_t *) 0 ; diff --git a/src/mod/languages/mod_managed/managed/swig.2010.cs b/src/mod/languages/mod_managed/managed/swig.2010.cs index 3b9815e11e..7bef61ffbb 100644 --- a/src/mod/languages/mod_managed/managed/swig.2010.cs +++ b/src/mod/languages/mod_managed/managed/swig.2010.cs @@ -2195,8 +2195,8 @@ public class freeswitch { return ret; } - public static switch_status_t switch_core_codec_copy(switch_codec codec, switch_codec new_codec, SWIGTYPE_p_apr_pool_t pool) { - switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_copy(switch_codec.getCPtr(codec), switch_codec.getCPtr(new_codec), SWIGTYPE_p_apr_pool_t.getCPtr(pool)); + public static switch_status_t switch_core_codec_copy(switch_codec codec, switch_codec new_codec, switch_codec_settings codec_settings, SWIGTYPE_p_apr_pool_t pool) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_copy(switch_codec.getCPtr(codec), switch_codec.getCPtr(new_codec), switch_codec_settings.getCPtr(codec_settings), SWIGTYPE_p_apr_pool_t.getCPtr(pool)); return ret; } @@ -2665,6 +2665,11 @@ public class freeswitch { return ret; } + public static string switch_core_mime_type2ext(string type) { + string ret = freeswitchPINVOKE.switch_core_mime_type2ext(type); + return ret; + } + public static switch_status_t switch_core_mime_add_type(string type, string ext) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_mime_add_type(type, ext); return ret; @@ -2886,6 +2891,11 @@ public class freeswitch { return ret; } + public static switch_status_t switch_cache_db_create_schema(SWIGTYPE_p_switch_cache_db_handle dbh, string sql, ref string err) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_cache_db_create_schema(SWIGTYPE_p_switch_cache_db_handle.getCPtr(dbh), sql, ref err); + return ret; + } + public static string switch_cache_db_execute_sql2str(SWIGTYPE_p_switch_cache_db_handle dbh, string sql, string str, uint len, ref string err) { string ret = freeswitchPINVOKE.switch_cache_db_execute_sql2str(SWIGTYPE_p_switch_cache_db_handle.getCPtr(dbh), sql, str, len, ref err); return ret; @@ -3677,6 +3687,11 @@ public class freeswitch { return ret; } + public static switch_bool_t switch_is_leading_number(string str) { + switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_is_leading_number(str); + return ret; + } + public static string switch_find_parameter(string str, string param, SWIGTYPE_p_apr_pool_t pool) { string ret = freeswitchPINVOKE.switch_find_parameter(str, param, SWIGTYPE_p_apr_pool_t.getCPtr(pool)); return ret; @@ -3745,6 +3760,11 @@ public class freeswitch { return ret; } + public static int switch_errno_is_break(int errcode) { + int ret = freeswitchPINVOKE.switch_errno_is_break(errcode); + return ret; + } + public static string switch_priority_name(switch_priority_t priority) { string ret = freeswitchPINVOKE.switch_priority_name((int)priority); return ret; @@ -3928,6 +3948,11 @@ public class freeswitch { return ret; } + public static int switch_needs_url_encode(string s) { + int ret = freeswitchPINVOKE.switch_needs_url_encode(s); + return ret; + } + public static string switch_url_encode(string url, string buf, uint len) { string ret = freeswitchPINVOKE.switch_url_encode(url, buf, len); return ret; @@ -4835,6 +4860,11 @@ public class freeswitch { return ret; } + public static switch_status_t switch_channel_pass_sdp(SWIGTYPE_p_switch_channel from_channel, SWIGTYPE_p_switch_channel to_channel, string sdp) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_pass_sdp(SWIGTYPE_p_switch_channel.getCPtr(from_channel), SWIGTYPE_p_switch_channel.getCPtr(to_channel), sdp); + return ret; + } + public static switch_status_t switch_buffer_create(SWIGTYPE_p_apr_pool_t pool, SWIGTYPE_p_p_switch_buffer buffer, SWIGTYPE_p_switch_size_t max_len) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_buffer_create(SWIGTYPE_p_apr_pool_t.getCPtr(pool), SWIGTYPE_p_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_switch_size_t.getCPtr(max_len)); if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); @@ -7170,6 +7200,7 @@ public class freeswitch { public static readonly int MESSAGE_STRING_ARG_MAX = freeswitchPINVOKE.MESSAGE_STRING_ARG_MAX_get(); public static readonly int CACHE_DB_LEN = freeswitchPINVOKE.CACHE_DB_LEN_get(); public static readonly int SWITCH_CMD_CHUNK_LEN = freeswitchPINVOKE.SWITCH_CMD_CHUNK_LEN_get(); + public static readonly string SWITCH_URL_UNSAFE = freeswitchPINVOKE.SWITCH_URL_UNSAFE_get(); public static readonly int SWITCH_SMAX = freeswitchPINVOKE.SWITCH_SMAX_get(); public static readonly int SWITCH_SMIN = freeswitchPINVOKE.SWITCH_SMIN_get(); public static readonly int NO_EVENT_CHANNEL_ID = freeswitchPINVOKE.NO_EVENT_CHANNEL_ID_get(); @@ -8358,6 +8389,114 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_peer_ssrc_get")] public static extern uint switch_rtcp_numbers_t_peer_ssrc_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_rpt_ts_set")] + public static extern void switch_rtcp_numbers_t_last_rpt_ts_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_rpt_ts_get")] + public static extern uint switch_rtcp_numbers_t_last_rpt_ts_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_ssrc_set")] + public static extern void switch_rtcp_numbers_t_ssrc_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_ssrc_get")] + public static extern uint switch_rtcp_numbers_t_ssrc_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_csrc_set")] + public static extern void switch_rtcp_numbers_t_csrc_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_csrc_get")] + public static extern uint switch_rtcp_numbers_t_csrc_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_pkt_tsdiff_set")] + public static extern void switch_rtcp_numbers_t_last_pkt_tsdiff_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_pkt_tsdiff_get")] + public static extern uint switch_rtcp_numbers_t_last_pkt_tsdiff_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_inter_jitter_set")] + public static extern void switch_rtcp_numbers_t_inter_jitter_set(HandleRef jarg1, double jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_inter_jitter_get")] + public static extern double switch_rtcp_numbers_t_inter_jitter_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_rpt_ext_seq_set")] + public static extern void switch_rtcp_numbers_t_last_rpt_ext_seq_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_rpt_ext_seq_get")] + public static extern uint switch_rtcp_numbers_t_last_rpt_ext_seq_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_rpt_cycle_set")] + public static extern void switch_rtcp_numbers_t_last_rpt_cycle_set(HandleRef jarg1, ushort jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_rpt_cycle_get")] + public static extern ushort switch_rtcp_numbers_t_last_rpt_cycle_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_period_pkt_count_set")] + public static extern void switch_rtcp_numbers_t_period_pkt_count_set(HandleRef jarg1, ushort jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_period_pkt_count_get")] + public static extern ushort switch_rtcp_numbers_t_period_pkt_count_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_pkt_count_set")] + public static extern void switch_rtcp_numbers_t_pkt_count_set(HandleRef jarg1, ushort jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_pkt_count_get")] + public static extern ushort switch_rtcp_numbers_t_pkt_count_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_rtcp_rtp_count_set")] + public static extern void switch_rtcp_numbers_t_rtcp_rtp_count_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_rtcp_rtp_count_get")] + public static extern uint switch_rtcp_numbers_t_rtcp_rtp_count_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_high_ext_seq_recv_set")] + public static extern void switch_rtcp_numbers_t_high_ext_seq_recv_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_high_ext_seq_recv_get")] + public static extern uint switch_rtcp_numbers_t_high_ext_seq_recv_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_cycle_set")] + public static extern void switch_rtcp_numbers_t_cycle_set(HandleRef jarg1, ushort jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_cycle_get")] + public static extern ushort switch_rtcp_numbers_t_cycle_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_bad_seq_set")] + public static extern void switch_rtcp_numbers_t_bad_seq_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_bad_seq_get")] + public static extern uint switch_rtcp_numbers_t_bad_seq_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_base_seq_set")] + public static extern void switch_rtcp_numbers_t_base_seq_set(HandleRef jarg1, ushort jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_base_seq_get")] + public static extern ushort switch_rtcp_numbers_t_base_seq_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_cum_lost_set")] + public static extern void switch_rtcp_numbers_t_cum_lost_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_cum_lost_get")] + public static extern uint switch_rtcp_numbers_t_cum_lost_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_recv_lsr_local_set")] + public static extern void switch_rtcp_numbers_t_last_recv_lsr_local_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_recv_lsr_local_get")] + public static extern uint switch_rtcp_numbers_t_last_recv_lsr_local_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_recv_lsr_peer_set")] + public static extern void switch_rtcp_numbers_t_last_recv_lsr_peer_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_last_recv_lsr_peer_get")] + public static extern uint switch_rtcp_numbers_t_last_recv_lsr_peer_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_init_set")] + public static extern void switch_rtcp_numbers_t_init_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtcp_numbers_t_init_get")] + public static extern uint switch_rtcp_numbers_t_init_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_rtcp_numbers_t")] public static extern IntPtr new_switch_rtcp_numbers_t(); @@ -10468,7 +10607,7 @@ class freeswitchPINVOKE { public static extern int switch_core_codec_init_with_bitrate(HandleRef jarg1, string jarg2, string jarg3, uint jarg4, int jarg5, int jarg6, uint jarg7, uint jarg8, HandleRef jarg9, HandleRef jarg10); [DllImport("mod_managed", EntryPoint="CSharp_switch_core_codec_copy")] - public static extern int switch_core_codec_copy(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); + public static extern int switch_core_codec_copy(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, HandleRef jarg4); [DllImport("mod_managed", EntryPoint="CSharp_switch_core_codec_parse_fmtp")] public static extern int switch_core_codec_parse_fmtp(string jarg1, string jarg2, uint jarg3, HandleRef jarg4); @@ -10752,6 +10891,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_core_mime_ext2type")] public static extern string switch_core_mime_ext2type(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_mime_type2ext")] + public static extern string switch_core_mime_type2ext(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_mime_add_type")] public static extern int switch_core_mime_add_type(string jarg1, string jarg2); @@ -10992,6 +11134,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp__switch_cache_db_get_db_handle_dsn")] public static extern int _switch_cache_db_get_db_handle_dsn(HandleRef jarg1, string jarg2, string jarg3, string jarg4, int jarg5); + [DllImport("mod_managed", EntryPoint="CSharp_switch_cache_db_create_schema")] + public static extern int switch_cache_db_create_schema(HandleRef jarg1, string jarg2, ref string jarg3); + [DllImport("mod_managed", EntryPoint="CSharp_switch_cache_db_execute_sql2str")] public static extern string switch_cache_db_execute_sql2str(HandleRef jarg1, string jarg2, string jarg3, uint jarg4, ref string jarg5); @@ -11487,6 +11632,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_console_execute")] public static extern int switch_console_execute(string jarg1, int jarg2, HandleRef jarg3); + [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_URL_UNSAFE_get")] + public static extern string SWITCH_URL_UNSAFE_get(); + [DllImport("mod_managed", EntryPoint="CSharp_switch_toupper")] public static extern uint switch_toupper(uint jarg1); @@ -11622,6 +11770,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_is_number")] public static extern int switch_is_number(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_is_leading_number")] + public static extern int switch_is_leading_number(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_find_parameter")] public static extern string switch_find_parameter(string jarg1, string jarg2, HandleRef jarg3); @@ -11661,6 +11812,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_build_uri")] public static extern int switch_build_uri(string jarg1, HandleRef jarg2, string jarg3, string jarg4, HandleRef jarg5, int jarg6); + [DllImport("mod_managed", EntryPoint="CSharp_switch_errno_is_break")] + public static extern int switch_errno_is_break(int jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_priority_name")] public static extern string switch_priority_name(int jarg1); @@ -11769,6 +11923,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_util_quote_shell_arg_pool")] public static extern string switch_util_quote_shell_arg_pool(string jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_needs_url_encode")] + public static extern int switch_needs_url_encode(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_url_encode")] public static extern string switch_url_encode(string jarg1, string jarg2, uint jarg3); @@ -12846,11 +13003,17 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_timer_diff_get")] public static extern IntPtr switch_timer_diff_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_timer_start_set")] + public static extern void switch_timer_start_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_timer_start_get")] + public static extern IntPtr switch_timer_start_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_timer_tick_set")] - public static extern void switch_timer_tick_set(HandleRef jarg1, HandleRef jarg2); + public static extern void switch_timer_tick_set(HandleRef jarg1, ulong jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_timer_tick_get")] - public static extern IntPtr switch_timer_tick_get(HandleRef jarg1); + public static extern ulong switch_timer_tick_get(HandleRef jarg1); [DllImport("mod_managed", EntryPoint="CSharp_new_switch_timer")] public static extern IntPtr new_switch_timer(); @@ -15276,6 +15439,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_device_state2str")] public static extern string switch_channel_device_state2str(int jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_pass_sdp")] + public static extern int switch_channel_pass_sdp(HandleRef jarg1, HandleRef jarg2, string jarg3); + [DllImport("mod_managed", EntryPoint="CSharp_switch_buffer_create")] public static extern int switch_buffer_create(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); @@ -27648,6 +27814,7 @@ public enum switch_channel_flag_t { CF_WINNER, CF_CONTROLLED, CF_PROXY_MODE, + CF_PROXY_OFF, CF_SUSPEND, CF_EVENT_PARSE, CF_GEN_RINGBACK, @@ -29395,7 +29562,8 @@ namespace FreeSWITCH.Native { SCF_CORE_NON_SQLITE_DB_REQ = (1 << 20), SCF_DEBUG_SQL = (1 << 21), SCF_API_EXPANSION = (1 << 22), - SCF_SESSION_THREAD_POOL = (1 << 23) + SCF_SESSION_THREAD_POOL = (1 << 23), + SCF_DIALPLAN_TIMESTAMPS = (1 << 24) } } @@ -29728,6 +29896,7 @@ public enum switch_core_session_message_types_t { SWITCH_MESSAGE_INDICATE_STUN_ERROR, SWITCH_MESSAGE_INDICATE_MEDIA_RENEG, SWITCH_MESSAGE_INDICATE_KEEPALIVE, + SWITCH_MESSAGE_INDICATE_HARD_MUTE, SWITCH_MESSAGE_REFER_EVENT, SWITCH_MESSAGE_ANSWER_EVENT, SWITCH_MESSAGE_PROGRESS_EVENT, @@ -31461,7 +31630,9 @@ namespace FreeSWITCH.Native { ED_MUX_READ = (1 << 0), ED_MUX_WRITE = (1 << 1), ED_DTMF = (1 << 2), - ED_COPY_DISPLAY = (1 << 3) + ED_COPY_DISPLAY = (1 << 3), + ED_BRIDGE_READ = (1 << 4), + ED_BRIDGE_WRITE = (1 << 5) } } @@ -36127,7 +36298,9 @@ namespace FreeSWITCH.Native { SMF_HOLD_BLEG = (1 << 5), SMF_IMMEDIATE = (1 << 6), SMF_EXEC_INLINE = (1 << 7), - SMF_PRIORITY = (1 << 8) + SMF_PRIORITY = (1 << 8), + SMF_REPLYONLY_A = (1 << 9), + SMF_REPLYONLY_B = (1 << 10) } } @@ -36478,6 +36651,186 @@ public class switch_rtcp_numbers_t : IDisposable { } } + public uint last_rpt_ts { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_last_rpt_ts_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_last_rpt_ts_get(swigCPtr); + return ret; + } + } + + public uint ssrc { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_ssrc_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_ssrc_get(swigCPtr); + return ret; + } + } + + public uint csrc { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_csrc_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_csrc_get(swigCPtr); + return ret; + } + } + + public uint last_pkt_tsdiff { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_last_pkt_tsdiff_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_last_pkt_tsdiff_get(swigCPtr); + return ret; + } + } + + public double inter_jitter { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_inter_jitter_set(swigCPtr, value); + } + get { + double ret = freeswitchPINVOKE.switch_rtcp_numbers_t_inter_jitter_get(swigCPtr); + return ret; + } + } + + public uint last_rpt_ext_seq { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_last_rpt_ext_seq_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_last_rpt_ext_seq_get(swigCPtr); + return ret; + } + } + + public ushort last_rpt_cycle { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_last_rpt_cycle_set(swigCPtr, value); + } + get { + ushort ret = freeswitchPINVOKE.switch_rtcp_numbers_t_last_rpt_cycle_get(swigCPtr); + return ret; + } + } + + public ushort period_pkt_count { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_period_pkt_count_set(swigCPtr, value); + } + get { + ushort ret = freeswitchPINVOKE.switch_rtcp_numbers_t_period_pkt_count_get(swigCPtr); + return ret; + } + } + + public ushort pkt_count { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_pkt_count_set(swigCPtr, value); + } + get { + ushort ret = freeswitchPINVOKE.switch_rtcp_numbers_t_pkt_count_get(swigCPtr); + return ret; + } + } + + public uint rtcp_rtp_count { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_rtcp_rtp_count_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_rtcp_rtp_count_get(swigCPtr); + return ret; + } + } + + public uint high_ext_seq_recv { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_high_ext_seq_recv_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_high_ext_seq_recv_get(swigCPtr); + return ret; + } + } + + public ushort cycle { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_cycle_set(swigCPtr, value); + } + get { + ushort ret = freeswitchPINVOKE.switch_rtcp_numbers_t_cycle_get(swigCPtr); + return ret; + } + } + + public uint bad_seq { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_bad_seq_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_bad_seq_get(swigCPtr); + return ret; + } + } + + public ushort base_seq { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_base_seq_set(swigCPtr, value); + } + get { + ushort ret = freeswitchPINVOKE.switch_rtcp_numbers_t_base_seq_get(swigCPtr); + return ret; + } + } + + public uint cum_lost { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_cum_lost_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_cum_lost_get(swigCPtr); + return ret; + } + } + + public uint last_recv_lsr_local { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_last_recv_lsr_local_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_last_recv_lsr_local_get(swigCPtr); + return ret; + } + } + + public uint last_recv_lsr_peer { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_last_recv_lsr_peer_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_last_recv_lsr_peer_get(swigCPtr); + return ret; + } + } + + public uint init { + set { + freeswitchPINVOKE.switch_rtcp_numbers_t_init_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_rtcp_numbers_t_init_get(swigCPtr); + return ret; + } + } + public switch_rtcp_numbers_t() : this(freeswitchPINVOKE.new_switch_rtcp_numbers_t(), true) { } @@ -36507,7 +36860,8 @@ public enum switch_rtp_bug_flag_t { RTP_BUG_GEN_ONE_GEN_ALL = (1 << 8), RTP_BUG_CHANGE_SSRC_ON_MARKER = (1 << 9), RTP_BUG_FLUSH_JB_ON_DTMF = (1 << 10), - RTP_BUG_ACCEPT_ANY_PAYLOAD = (1 << 11) + RTP_BUG_ACCEPT_ANY_PAYLOAD = (1 << 11), + RTP_BUG_ALWAYS_AUTO_ADJUST = (1 << 12) } } @@ -36707,6 +37061,7 @@ public enum switch_rtp_flag_t { SWITCH_RTP_FLAG_FIR, SWITCH_RTP_FLAG_PLI, SWITCH_RTP_FLAG_RESET, + SWITCH_RTP_FLAG_MUTE, SWITCH_RTP_FLAG_INVALID } @@ -39676,18 +40031,28 @@ public class switch_timer : IDisposable { } } - public SWIGTYPE_p_switch_size_t tick { + public SWIGTYPE_p_switch_time_t start { set { - freeswitchPINVOKE.switch_timer_tick_set(swigCPtr, SWIGTYPE_p_switch_size_t.getCPtr(value)); + freeswitchPINVOKE.switch_timer_start_set(swigCPtr, SWIGTYPE_p_switch_time_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_timer_tick_get(swigCPtr), true); + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_timer_start_get(swigCPtr), true); if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); return ret; } } + public ulong tick { + set { + freeswitchPINVOKE.switch_timer_tick_set(swigCPtr, value); + } + get { + ulong ret = freeswitchPINVOKE.switch_timer_tick_get(swigCPtr); + return ret; + } + } + public switch_timer() : this(freeswitchPINVOKE.new_switch_timer(), true) { }