kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-04-15 16:39:14 +00:00
Code Issues Projects Releases Wiki Activity

FSCORE-237 make channel flags array based so we do not have 32 flag limit

Browse Source 
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@10710 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris 2008-12-11 15:20:24 +00:00
parent f8734c080e
commit 42c11dd764
5 changed files with 185 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/include/switch_channel.h
View File

@ -145,7 +145,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_alloc(_In_ switch_channel_t **cha
\param flags the initial channel flags \param flags the initial channel flags
*/ */
SWITCH_DECLARE(switch_status_t) switch_channel_init(switch_channel_t *channel, switch_core_session_t *session, switch_channel_state_t state, SWITCH_DECLARE(switch_status_t) switch_channel_init(switch_channel_t *channel, switch_core_session_t *session, switch_channel_state_t state,
uint32_t flags); switch_channel_flag_t flag);
/*! /*!
\brief Fire A presence event for the channel \brief Fire A presence event for the channel
@ -259,49 +259,49 @@ SWITCH_DECLARE(void) switch_channel_set_caller_extension(switch_channel_t *chann
SWITCH_DECLARE(switch_caller_extension_t *) switch_channel_get_caller_extension(switch_channel_t *channel); SWITCH_DECLARE(switch_caller_extension_t *) switch_channel_get_caller_extension(switch_channel_t *channel);
/*! /*!
\brief Test for presence of given flag(s) on a given channel \brief Test for presence of given flag on a given channel
\param channel channel to test \param channel channel to test
\param flags or'd list of channel flags to test \param flag to test
\return TRUE if flags were present \return TRUE if flags were present
*/ */
SWITCH_DECLARE(uint32_t) switch_channel_test_flag(switch_channel_t *channel, switch_channel_flag_t flags); SWITCH_DECLARE(uint32_t) switch_channel_test_flag(switch_channel_t *channel, switch_channel_flag_t flag);
/*! /*!
\brief Set given flag(s) on a given channel \brief Set given flag(s) on a given channel
\param channel channel on which to set flag(s) \param channel channel on which to set flag
\param flags or'd list of flags to set \param flag or'd list of flags to set
*/ */
SWITCH_DECLARE(void) switch_channel_set_flag(switch_channel_t *channel, switch_channel_flag_t flags); SWITCH_DECLARE(void) switch_channel_set_flag(switch_channel_t *channel, switch_channel_flag_t flag);
/*! /*!
\brief Set given flag(s) on a given channel's bridge partner \brief Set given flag(s) on a given channel's bridge partner
\param channel channel to derive the partner channel to set flag(s) on \param channel channel to derive the partner channel to set flag on
\param flags or'd list of flags to set \param flag to set
\return true if the flag was set \return true if the flag was set
*/ */
SWITCH_DECLARE(switch_bool_t) switch_channel_set_flag_partner(switch_channel_t *channel, switch_channel_flag_t flags); SWITCH_DECLARE(switch_bool_t) switch_channel_set_flag_partner(switch_channel_t *channel, switch_channel_flag_t flag);
/*! /*!
\brief Clears given flag(s) on a given channel's bridge partner \brief Clears given flag(s) on a given channel's bridge partner
\param channel channel to derive the partner channel to clear flag(s) from \param channel channel to derive the partner channel to clear flag(s) from
\param flags the flags to clear \param flag the flag to clear
\return true if the flag was cleared \return true if the flag was cleared
*/ */
SWITCH_DECLARE(switch_bool_t) switch_channel_clear_flag_partner(switch_channel_t *channel, switch_channel_flag_t flags); SWITCH_DECLARE(switch_bool_t) switch_channel_clear_flag_partner(switch_channel_t *channel, switch_channel_flag_t flag);
/*! /*!
\brief Set given flag(s) on a given channel to be applied on the next state change \brief Set given flag(s) on a given channel to be applied on the next state change
\param channel channel on which to set flag(s) \param channel channel on which to set flag(s)
\param flags or'd list of flags to set \param flag flag to set
*/ */
SWITCH_DECLARE(void) switch_channel_set_state_flag(switch_channel_t *channel, switch_channel_flag_t flags); SWITCH_DECLARE(void) switch_channel_set_state_flag(switch_channel_t *channel, switch_channel_flag_t flag);
/*! /*!
\brief Clear given flag(s) from a channel \brief Clear given flag(s) from a channel
\param channel channel to clear flags from \param channel channel to clear flags from
\param flags or'd list of flags to clear \param flag flag to clear
*/ */
SWITCH_DECLARE(void) switch_channel_clear_flag(switch_channel_t *channel, switch_channel_flag_t flags); SWITCH_DECLARE(void) switch_channel_clear_flag(switch_channel_t *channel, switch_channel_flag_t flag);
SWITCH_DECLARE(switch_status_t) switch_channel_perform_answer(switch_channel_t *channel, const char *file, const char *func, int line); SWITCH_DECLARE(switch_status_t) switch_channel_perform_answer(switch_channel_t *channel, const char *file, const char *func, int line);
@ -484,7 +484,7 @@ SWITCH_DECLARE(char *) switch_channel_build_param_string(_In_ switch_channel_t *
_In_opt_ const char *prefix); _In_opt_ const char *prefix);
SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(_In_ switch_channel_t *channel); SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(_In_ switch_channel_t *channel);
#define switch_channel_stop_broadcast(_channel) if (switch_channel_test_flag(_channel, CF_BROADCAST)) switch_channel_set_flag(_channel, CF_BREAK | CF_STOP_BROADCAST) #define switch_channel_stop_broadcast(_channel) for(;;) {if (switch_channel_test_flag(_channel, CF_BROADCAST)) {switch_channel_set_flag(_channel, CF_STOP_BROADCAST); switch_channel_set_flag(_channel, CF_BREAK); } break;}
#define switch_channel_media_ready(_channel) ((switch_channel_test_flag(_channel, CF_ANSWERED) || switch_channel_test_flag(_channel, CF_EARLY_MEDIA)) && !switch_channel_test_flag(_channel, CF_PROXY_MODE)) #define switch_channel_media_ready(_channel) ((switch_channel_test_flag(_channel, CF_ANSWERED) || switch_channel_test_flag(_channel, CF_EARLY_MEDIA)) && !switch_channel_test_flag(_channel, CF_PROXY_MODE))

121
src/include/switch_types.h
View File

@ -732,73 +732,70 @@ typedef enum {
\brief Channel Flags \brief Channel Flags
<pre> <pre>
CF_ANSWERED = (1 << 0) - Channel is answered CF_ANSWERED - Channel is answered
CF_OUTBOUND = (1 << 1) - Channel is an outbound channel CF_OUTBOUND - Channel is an outbound channel
CF_EARLY_MEDIA = (1 << 2) - Channel is ready for audio before answer CF_EARLY_MEDIA - Channel is ready for audio before answer
CF_ORIGINATOR = (1 << 3) - Channel is an originator CF_ORIGINATOR - Channel is an originator
CF_TRANSFER = (1 << 4) - Channel is being transfered CF_TRANSFER - Channel is being transfered
CF_ACCEPT_CNG = (1 << 5) - Channel will accept CNG frames CF_ACCEPT_CNG - Channel will accept CNG frames
CF_REDIRECT = (1 << 6) - Channel is being redirected CF_REDIRECT - Channel is being redirected
CF_BRIDGED = (1 << 7) - Channel in a bridge CF_BRIDGED - Channel in a bridge
CF_HOLD = (1 << 8) - Channel is on hold CF_HOLD - Channel is on hold
CF_SERVICE = (1 << 9) - Channel has a service thread CF_SERVICE - Channel has a service thread
CF_TAGGED = (1 << 10) - Channel is tagged CF_TAGGED - Channel is tagged
CF_WINNER = (1 << 11) - Channel is the winner CF_WINNER - Channel is the winner
CF_CONTROLLED = (1 << 12) - Channel is under control CF_CONTROLLED - Channel is under control
CF_PROXY_MODE = (1 << 13) - Channel has no media CF_PROXY_MODE - Channel has no media
CF_SUSPEND = (1 << 14) - Suspend i/o CF_SUSPEND - Suspend i/o
CF_EVENT_PARSE = (1 << 15) - Suspend control events CF_EVENT_PARSE - Suspend control events
CF_USE_ME = (1 << 16) - use me CF_GEN_RINGBACK - Channel is generating it's own ringback
CF_GEN_RINGBACK = (1 << 17) - Channel is generating it's own ringback CF_RING_READY - Channel is ready to send ringback
CF_RING_READY = (1 << 18) - Channel is ready to send ringback CF_BREAK - Channel should stop what it's doing
CF_BREAK = (1 << 19) - Channel should stop what it's doing CF_BROADCAST - Channel is broadcasting
CF_BROADCAST = (1 << 20) - Channel is broadcasting CF_UNICAST - Channel has a unicast connection
CF_UNICAST = (1 << 21) - Channel has a unicast connection CF_VIDEO - Channel has video
CF_VIDEO = (1 << 22) - Channel has video CF_EVENT_LOCK - Don't parse events
CF_EVENT_LOCK = (1 << 23) - Don't parse events CF_RESET - Tell extension parser to reset
CF_RESET = (1 << 24) - Tell extension parser to reset CF_ORIGINATING - Channel is originating
CF_ORIGINATING = (1 << 25) - Channel is originating CF_STOP_BROADCAST - Signal to stop broadcast
CF_STOP_BROADCAST = (1 << 26) - Signal to stop broadcast
</pre> </pre>
*/ */
typedef enum { typedef enum {
CF_ANSWERED = (1 << 0), CF_ANSWERED = 1,
CF_OUTBOUND = (1 << 1), CF_OUTBOUND,
CF_EARLY_MEDIA = (1 << 2), CF_EARLY_MEDIA,
CF_ORIGINATOR = (1 << 3), CF_ORIGINATOR,
CF_TRANSFER = (1 << 4), CF_TRANSFER,
CF_ACCEPT_CNG = (1 << 5), CF_ACCEPT_CNG,
CF_REDIRECT = (1 << 6), CF_REDIRECT,
CF_BRIDGED = (1 << 7), CF_BRIDGED,
CF_HOLD = (1 << 8), CF_HOLD,
CF_SERVICE = (1 << 9), CF_SERVICE,
CF_TAGGED = (1 << 10), CF_TAGGED,
CF_WINNER = (1 << 11), CF_WINNER,
CF_CONTROLLED = (1 << 12), CF_CONTROLLED,
CF_PROXY_MODE = (1 << 13), CF_PROXY_MODE,
CF_SUSPEND = (1 << 14), CF_SUSPEND,
CF_EVENT_PARSE = (1 << 15), CF_EVENT_PARSE,
CF_USE_ME = (1 << 16), CF_GEN_RINGBACK,
CF_GEN_RINGBACK = (1 << 17), CF_RING_READY,
CF_RING_READY = (1 << 18), CF_BREAK,
CF_BREAK = (1 << 19), CF_BROADCAST,
CF_BROADCAST = (1 << 20), CF_UNICAST,
CF_UNICAST = (1 << 21), CF_VIDEO,
CF_VIDEO = (1 << 22), CF_EVENT_LOCK,
CF_EVENT_LOCK = (1 << 23), CF_RESET,
CF_RESET = (1 << 24), CF_ORIGINATING,
CF_ORIGINATING = (1 << 25), CF_STOP_BROADCAST,
CF_STOP_BROADCAST = (1 << 26), CF_PROXY_MEDIA,
CF_PROXY_MEDIA = (1 << 27), CF_INNER_BRIDGE,
CF_INNER_BRIDGE = (1 << 28), CF_REQ_MEDIA,
CF_REQ_MEDIA = (1 << 29), CF_VERBOSE_EVENTS,
CF_VERBOSE_EVENTS = (1 << 30)
} switch_channel_flag_enum_t;
typedef uint32_t switch_channel_flag_t;
/* WARNING: DO NOT ADD ANY FLAGS BELOW THIS LINE */
CF_FLAG_MAX
} switch_channel_flag_t;
/*! /*!
\enum switch_frame_flag_t \enum switch_frame_flag_t

20
src/mod/languages/mod_managed/freeswitch_wrap.cxx
View File

@ -17084,7 +17084,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_wait_for_state(void * jarg1, v
} }
SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_wait_for_flag(void * jarg1, unsigned long jarg2, int jarg3, unsigned long jarg4, void * jarg5) { SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_wait_for_flag(void * jarg1, int jarg2, int jarg3, unsigned long jarg4, void * jarg5) {
int jresult ; int jresult ;
switch_channel_t *arg1 = (switch_channel_t *) 0 ; switch_channel_t *arg1 = (switch_channel_t *) 0 ;
switch_channel_flag_t arg2 ; switch_channel_flag_t arg2 ;
@ -17230,18 +17230,18 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_alloc(void * jarg1, void * jarg
} }
SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_init(void * jarg1, void * jarg2, int jarg3, unsigned long jarg4) { SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_init(void * jarg1, void * jarg2, int jarg3, int jarg4) {
int jresult ; int jresult ;
switch_channel_t *arg1 = (switch_channel_t *) 0 ; switch_channel_t *arg1 = (switch_channel_t *) 0 ;
switch_core_session_t *arg2 = (switch_core_session_t *) 0 ; switch_core_session_t *arg2 = (switch_core_session_t *) 0 ;
switch_channel_state_t arg3 ; switch_channel_state_t arg3 ;
uint32_t arg4 ; switch_channel_flag_t arg4 ;
switch_status_t result; switch_status_t result;
arg1 = (switch_channel_t *)jarg1; arg1 = (switch_channel_t *)jarg1;
arg2 = (switch_core_session_t *)jarg2; arg2 = (switch_core_session_t *)jarg2;
arg3 = (switch_channel_state_t)jarg3; arg3 = (switch_channel_state_t)jarg3;
arg4 = (uint32_t)jarg4; arg4 = (switch_channel_flag_t)jarg4;
result = (switch_status_t)switch_channel_init(arg1,arg2,arg3,arg4); result = (switch_status_t)switch_channel_init(arg1,arg2,arg3,arg4);
jresult = result; jresult = result;
return jresult; return jresult;
@ -17481,7 +17481,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_channel_get_caller_extension(void *
} }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_channel_test_flag(void * jarg1, unsigned long jarg2) { SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_channel_test_flag(void * jarg1, int jarg2) {
unsigned long jresult ; unsigned long jresult ;
switch_channel_t *arg1 = (switch_channel_t *) 0 ; switch_channel_t *arg1 = (switch_channel_t *) 0 ;
switch_channel_flag_t arg2 ; switch_channel_flag_t arg2 ;
@ -17495,7 +17495,7 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_channel_test_flag(void * jarg
} }
SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_flag(void * jarg1, unsigned long jarg2) { SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_flag(void * jarg1, int jarg2) {
switch_channel_t *arg1 = (switch_channel_t *) 0 ; switch_channel_t *arg1 = (switch_channel_t *) 0 ;
switch_channel_flag_t arg2 ; switch_channel_flag_t arg2 ;
@ -17505,7 +17505,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_flag(void * jarg1, unsigne
} }
SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_set_flag_partner(void * jarg1, unsigned long jarg2) { SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_set_flag_partner(void * jarg1, int jarg2) {
int jresult ; int jresult ;
switch_channel_t *arg1 = (switch_channel_t *) 0 ; switch_channel_t *arg1 = (switch_channel_t *) 0 ;
switch_channel_flag_t arg2 ; switch_channel_flag_t arg2 ;
@ -17519,7 +17519,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_set_flag_partner(void * jarg1,
} }
SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_clear_flag_partner(void * jarg1, unsigned long jarg2) { SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_clear_flag_partner(void * jarg1, int jarg2) {
int jresult ; int jresult ;
switch_channel_t *arg1 = (switch_channel_t *) 0 ; switch_channel_t *arg1 = (switch_channel_t *) 0 ;
switch_channel_flag_t arg2 ; switch_channel_flag_t arg2 ;
@ -17533,7 +17533,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_clear_flag_partner(void * jarg1
} }
SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_state_flag(void * jarg1, unsigned long jarg2) { SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_state_flag(void * jarg1, int jarg2) {
switch_channel_t *arg1 = (switch_channel_t *) 0 ; switch_channel_t *arg1 = (switch_channel_t *) 0 ;
switch_channel_flag_t arg2 ; switch_channel_flag_t arg2 ;
@ -17543,7 +17543,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_state_flag(void * jarg1, u
} }
SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_clear_flag(void * jarg1, unsigned long jarg2) { SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_clear_flag(void * jarg1, int jarg2) {
switch_channel_t *arg1 = (switch_channel_t *) 0 ; switch_channel_t *arg1 = (switch_channel_t *) 0 ;
switch_channel_flag_t arg2 ; switch_channel_flag_t arg2 ;

112
src/mod/languages/mod_managed/managed/swig.cs
View File

@ -2209,8 +2209,8 @@ public class freeswitch {
freeswitchPINVOKE.switch_channel_wait_for_state(SWIGTYPE_p_switch_channel.getCPtr(channel), SWIGTYPE_p_switch_channel.getCPtr(other_channel), (int)want_state); freeswitchPINVOKE.switch_channel_wait_for_state(SWIGTYPE_p_switch_channel.getCPtr(channel), SWIGTYPE_p_switch_channel.getCPtr(other_channel), (int)want_state);
} }
public static switch_status_t switch_channel_wait_for_flag(SWIGTYPE_p_switch_channel channel, uint want_flag, switch_bool_t pres, uint to, SWIGTYPE_p_switch_channel super_channel) { public static switch_status_t switch_channel_wait_for_flag(SWIGTYPE_p_switch_channel channel, switch_channel_flag_t want_flag, switch_bool_t pres, uint to, SWIGTYPE_p_switch_channel super_channel) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_wait_for_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), want_flag, (int)pres, to, SWIGTYPE_p_switch_channel.getCPtr(super_channel)); switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_wait_for_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)want_flag, (int)pres, to, SWIGTYPE_p_switch_channel.getCPtr(super_channel));
return ret; return ret;
} }
@ -2260,8 +2260,8 @@ public class freeswitch {
return ret; return ret;
} }
public static switch_status_t switch_channel_init(SWIGTYPE_p_switch_channel channel, SWIGTYPE_p_switch_core_session session, switch_channel_state_t state, uint flags) { public static switch_status_t switch_channel_init(SWIGTYPE_p_switch_channel channel, SWIGTYPE_p_switch_core_session session, switch_channel_state_t state, switch_channel_flag_t flag) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_init(SWIGTYPE_p_switch_channel.getCPtr(channel), SWIGTYPE_p_switch_core_session.getCPtr(session), (int)state, flags); switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_init(SWIGTYPE_p_switch_channel.getCPtr(channel), SWIGTYPE_p_switch_core_session.getCPtr(session), (int)state, (int)flag);
return ret; return ret;
} }
@ -2358,31 +2358,31 @@ public class freeswitch {
return ret; return ret;
} }
public static uint switch_channel_test_flag(SWIGTYPE_p_switch_channel channel, uint flags) { public static uint switch_channel_test_flag(SWIGTYPE_p_switch_channel channel, switch_channel_flag_t flag) {
uint ret = freeswitchPINVOKE.switch_channel_test_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), flags); uint ret = freeswitchPINVOKE.switch_channel_test_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)flag);
return ret; return ret;
} }
public static void switch_channel_set_flag(SWIGTYPE_p_switch_channel channel, uint flags) { public static void switch_channel_set_flag(SWIGTYPE_p_switch_channel channel, switch_channel_flag_t flag) {
freeswitchPINVOKE.switch_channel_set_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), flags); freeswitchPINVOKE.switch_channel_set_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)flag);
} }
public static switch_bool_t switch_channel_set_flag_partner(SWIGTYPE_p_switch_channel channel, uint flags) { public static switch_bool_t switch_channel_set_flag_partner(SWIGTYPE_p_switch_channel channel, switch_channel_flag_t flag) {
switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_channel_set_flag_partner(SWIGTYPE_p_switch_channel.getCPtr(channel), flags); switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_channel_set_flag_partner(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)flag);
return ret; return ret;
} }
public static switch_bool_t switch_channel_clear_flag_partner(SWIGTYPE_p_switch_channel channel, uint flags) { public static switch_bool_t switch_channel_clear_flag_partner(SWIGTYPE_p_switch_channel channel, switch_channel_flag_t flag) {
switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_channel_clear_flag_partner(SWIGTYPE_p_switch_channel.getCPtr(channel), flags); switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_channel_clear_flag_partner(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)flag);
return ret; return ret;
} }
public static void switch_channel_set_state_flag(SWIGTYPE_p_switch_channel channel, uint flags) { public static void switch_channel_set_state_flag(SWIGTYPE_p_switch_channel channel, switch_channel_flag_t flag) {
freeswitchPINVOKE.switch_channel_set_state_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), flags); freeswitchPINVOKE.switch_channel_set_state_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)flag);
} }
public static void switch_channel_clear_flag(SWIGTYPE_p_switch_channel channel, uint flags) { public static void switch_channel_clear_flag(SWIGTYPE_p_switch_channel channel, switch_channel_flag_t flag) {
freeswitchPINVOKE.switch_channel_clear_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), flags); freeswitchPINVOKE.switch_channel_clear_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)flag);
} }
public static switch_status_t switch_channel_perform_answer(SWIGTYPE_p_switch_channel channel, string file, string func, int line) { public static switch_status_t switch_channel_perform_answer(SWIGTYPE_p_switch_channel channel, string file, string func, int line) {
@ -8343,7 +8343,7 @@ class freeswitchPINVOKE {
public static extern void switch_channel_wait_for_state(HandleRef jarg1, HandleRef jarg2, int jarg3); public static extern void switch_channel_wait_for_state(HandleRef jarg1, HandleRef jarg2, int jarg3);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_wait_for_flag")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_wait_for_flag")]
public static extern int switch_channel_wait_for_flag(HandleRef jarg1, uint jarg2, int jarg3, uint jarg4, HandleRef jarg5); public static extern int switch_channel_wait_for_flag(HandleRef jarg1, int jarg2, int jarg3, uint jarg4, HandleRef jarg5);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_perform_set_state")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_perform_set_state")]
public static extern int switch_channel_perform_set_state(HandleRef jarg1, string jarg2, string jarg3, int jarg4, int jarg5); public static extern int switch_channel_perform_set_state(HandleRef jarg1, string jarg2, string jarg3, int jarg4, int jarg5);
@ -8373,7 +8373,7 @@ class freeswitchPINVOKE {
public static extern int switch_channel_alloc(HandleRef jarg1, HandleRef jarg2); public static extern int switch_channel_alloc(HandleRef jarg1, HandleRef jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_init")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_init")]
public static extern int switch_channel_init(HandleRef jarg1, HandleRef jarg2, int jarg3, uint jarg4); public static extern int switch_channel_init(HandleRef jarg1, HandleRef jarg2, int jarg3, int jarg4);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_presence")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_presence")]
public static extern void switch_channel_presence(HandleRef jarg1, string jarg2, string jarg3, string jarg4); public static extern void switch_channel_presence(HandleRef jarg1, string jarg2, string jarg3, string jarg4);
@ -8433,22 +8433,22 @@ class freeswitchPINVOKE {
public static extern IntPtr switch_channel_get_caller_extension(HandleRef jarg1); public static extern IntPtr switch_channel_get_caller_extension(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_test_flag")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_test_flag")]
public static extern uint switch_channel_test_flag(HandleRef jarg1, uint jarg2); public static extern uint switch_channel_test_flag(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_flag")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_flag")]
public static extern void switch_channel_set_flag(HandleRef jarg1, uint jarg2); public static extern void switch_channel_set_flag(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_flag_partner")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_flag_partner")]
public static extern int switch_channel_set_flag_partner(HandleRef jarg1, uint jarg2); public static extern int switch_channel_set_flag_partner(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_clear_flag_partner")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_clear_flag_partner")]
public static extern int switch_channel_clear_flag_partner(HandleRef jarg1, uint jarg2); public static extern int switch_channel_clear_flag_partner(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_state_flag")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_state_flag")]
public static extern void switch_channel_set_state_flag(HandleRef jarg1, uint jarg2); public static extern void switch_channel_set_state_flag(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_clear_flag")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_clear_flag")]
public static extern void switch_channel_clear_flag(HandleRef jarg1, uint jarg2); public static extern void switch_channel_clear_flag(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_perform_answer")] [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_perform_answer")]
public static extern int switch_channel_perform_answer(HandleRef jarg1, string jarg2, string jarg3, int jarg4); public static extern int switch_channel_perform_answer(HandleRef jarg1, string jarg2, string jarg3, int jarg4);
@ -16832,38 +16832,38 @@ namespace FreeSWITCH.Native {
namespace FreeSWITCH.Native { namespace FreeSWITCH.Native {
[System.Flags] public enum switch_channel_flag_enum_t { public enum switch_channel_flag_t {
CF_ANSWERED = (1 << 0), CF_ANSWERED = 1,
CF_OUTBOUND = (1 << 1), CF_OUTBOUND,
CF_EARLY_MEDIA = (1 << 2), CF_EARLY_MEDIA,
CF_ORIGINATOR = (1 << 3), CF_ORIGINATOR,
CF_TRANSFER = (1 << 4), CF_TRANSFER,
CF_ACCEPT_CNG = (1 << 5), CF_ACCEPT_CNG,
CF_REDIRECT = (1 << 6), CF_REDIRECT,
CF_BRIDGED = (1 << 7), CF_BRIDGED,
CF_HOLD = (1 << 8), CF_HOLD,
CF_SERVICE = (1 << 9), CF_SERVICE,
CF_TAGGED = (1 << 10), CF_TAGGED,
CF_WINNER = (1 << 11), CF_WINNER,
CF_CONTROLLED = (1 << 12), CF_CONTROLLED,
CF_PROXY_MODE = (1 << 13), CF_PROXY_MODE,
CF_SUSPEND = (1 << 14), CF_SUSPEND,
CF_EVENT_PARSE = (1 << 15), CF_EVENT_PARSE,
CF_USE_ME = (1 << 16), CF_GEN_RINGBACK,
CF_GEN_RINGBACK = (1 << 17), CF_RING_READY,
CF_RING_READY = (1 << 18), CF_BREAK,
CF_BREAK = (1 << 19), CF_BROADCAST,
CF_BROADCAST = (1 << 20), CF_UNICAST,
CF_UNICAST = (1 << 21), CF_VIDEO,
CF_VIDEO = (1 << 22), CF_EVENT_LOCK,
CF_EVENT_LOCK = (1 << 23), CF_RESET,
CF_RESET = (1 << 24), CF_ORIGINATING,
CF_ORIGINATING = (1 << 25), CF_STOP_BROADCAST,
CF_STOP_BROADCAST = (1 << 26), CF_PROXY_MEDIA,
CF_PROXY_MEDIA = (1 << 27), CF_INNER_BRIDGE,
CF_INNER_BRIDGE = (1 << 28), CF_REQ_MEDIA,
CF_REQ_MEDIA = (1 << 29), CF_VERBOSE_EVENTS,
CF_VERBOSE_EVENTS = (1 << 30) CF_FLAG_MAX
} }
} }

71
src/switch_channel.c
View File

@ -115,9 +115,9 @@ struct switch_channel {
switch_core_session_t *session; switch_core_session_t *session;
switch_channel_state_t state; switch_channel_state_t state;
switch_channel_state_t running_state; switch_channel_state_t running_state;
switch_channel_flag_t flags; uint8_t flags[CF_FLAG_MAX];
uint8_t state_flags[CF_FLAG_MAX];
uint32_t private_flags; uint32_t private_flags;
switch_channel_flag_t state_flags;
switch_caller_profile_t *caller_profile; switch_caller_profile_t *caller_profile;
const switch_state_handler_table_t *state_handlers[SWITCH_MAX_STATE_HANDLERS]; const switch_state_handler_table_t *state_handlers[SWITCH_MAX_STATE_HANDLERS];
int state_handler_index; int state_handler_index;
@ -410,11 +410,11 @@ SWITCH_DECLARE(void) switch_channel_uninit(switch_channel_t *channel)
} }
SWITCH_DECLARE(switch_status_t) switch_channel_init(switch_channel_t *channel, switch_core_session_t *session, switch_channel_state_t state, SWITCH_DECLARE(switch_status_t) switch_channel_init(switch_channel_t *channel, switch_core_session_t *session, switch_channel_state_t state,
uint32_t flags) switch_channel_flag_t flag)
{ {
switch_assert(channel != NULL); switch_assert(channel != NULL);
channel->state = state; channel->state = state;
channel->flags = flags; switch_channel_set_flag(channel, flag);
channel->session = session; channel->session = session;
channel->running_state = CS_NONE; channel->running_state = CS_NONE;
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
@ -643,13 +643,13 @@ SWITCH_DECLARE(switch_status_t) switch_channel_set_variable_partner(switch_chann
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
SWITCH_DECLARE(uint32_t) switch_channel_test_flag(switch_channel_t *channel, switch_channel_flag_t flags) SWITCH_DECLARE(uint32_t) switch_channel_test_flag(switch_channel_t *channel, switch_channel_flag_t flag)
{ {
switch_assert(channel != NULL); switch_assert(channel != NULL);
return switch_test_flag(channel, flags) ? 1 : 0; return channel->flags[flag] ? 1 : 0;
} }
SWITCH_DECLARE(switch_bool_t) switch_channel_set_flag_partner(switch_channel_t *channel, switch_channel_flag_t flags) SWITCH_DECLARE(switch_bool_t) switch_channel_set_flag_partner(switch_channel_t *channel, switch_channel_flag_t flag)
{ {
const char *uuid; const char *uuid;
@ -658,7 +658,7 @@ SWITCH_DECLARE(switch_bool_t) switch_channel_set_flag_partner(switch_channel_t *
if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))) { if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))) {
switch_core_session_t *session; switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid))) { if ((session = switch_core_session_locate(uuid))) {
switch_channel_set_flag(switch_core_session_get_channel(session), flags); switch_channel_set_flag(switch_core_session_get_channel(session), flag);
switch_core_session_rwunlock(session); switch_core_session_rwunlock(session);
return SWITCH_TRUE; return SWITCH_TRUE;
} }
@ -667,7 +667,7 @@ SWITCH_DECLARE(switch_bool_t) switch_channel_set_flag_partner(switch_channel_t *
return SWITCH_FALSE; return SWITCH_FALSE;
} }
SWITCH_DECLARE(switch_bool_t) switch_channel_clear_flag_partner(switch_channel_t *channel, switch_channel_flag_t flags) SWITCH_DECLARE(switch_bool_t) switch_channel_clear_flag_partner(switch_channel_t *channel, switch_channel_flag_t flag)
{ {
const char *uuid; const char *uuid;
@ -676,7 +676,7 @@ SWITCH_DECLARE(switch_bool_t) switch_channel_clear_flag_partner(switch_channel_t
if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))) { if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))) {
switch_core_session_t *session; switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid))) { if ((session = switch_core_session_locate(uuid))) {
switch_channel_clear_flag(switch_core_session_get_channel(session), flags); switch_channel_clear_flag(switch_core_session_get_channel(session), flag);
switch_core_session_rwunlock(session); switch_core_session_rwunlock(session);
return SWITCH_TRUE; return SWITCH_TRUE;
} }
@ -714,11 +714,11 @@ SWITCH_DECLARE(switch_status_t) switch_channel_wait_for_flag(switch_channel_t *c
for (;;) { for (;;) {
if (pres) { if (pres) {
if (switch_test_flag(channel, want_flag)) { if (switch_channel_test_flag(channel, want_flag)) {
break; break;
} }
} else { } else {
if (!switch_test_flag(channel, want_flag)) { if (!switch_channel_test_flag(channel, want_flag)) {
break; break;
} }
} }
@ -741,11 +741,16 @@ SWITCH_DECLARE(switch_status_t) switch_channel_wait_for_flag(switch_channel_t *c
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
SWITCH_DECLARE(void) switch_channel_set_flag(switch_channel_t *channel, switch_channel_flag_t flags) SWITCH_DECLARE(void) switch_channel_set_flag(switch_channel_t *channel, switch_channel_flag_t flag)
{ {
switch_assert(channel != NULL); switch_assert(channel);
switch_set_flag_locked(channel, flags); switch_assert(channel->flag_mutex);
if (flags & CF_OUTBOUND) {
switch_mutex_lock(channel->flag_mutex);
channel->flags[flag] = 1;
switch_mutex_unlock(channel->flag_mutex);
if (flag == CF_OUTBOUND) {
switch_channel_set_variable(channel, "is_outbound", "true"); switch_channel_set_variable(channel, "is_outbound", "true");
} }
} }
@ -773,21 +778,25 @@ SWITCH_DECLARE(int) switch_channel_test_private_flag(switch_channel_t *channel,
return (channel->private_flags & flags); return (channel->private_flags & flags);
} }
SWITCH_DECLARE(void) switch_channel_set_state_flag(switch_channel_t *channel, switch_channel_flag_t flag)
SWITCH_DECLARE(void) switch_channel_set_state_flag(switch_channel_t *channel, switch_channel_flag_t flags)
{ {
switch_assert(channel != NULL); switch_assert(channel != NULL);
switch_mutex_lock(channel->flag_mutex); switch_mutex_lock(channel->flag_mutex);
channel->state_flags |= flags; channel->state_flags[0] = 1;
channel->state_flags[flag] = 1;
switch_mutex_unlock(channel->flag_mutex); switch_mutex_unlock(channel->flag_mutex);
} }
SWITCH_DECLARE(void) switch_channel_clear_flag(switch_channel_t *channel, switch_channel_flag_t flags) SWITCH_DECLARE(void) switch_channel_clear_flag(switch_channel_t *channel, switch_channel_flag_t flag)
{ {
switch_assert(channel != NULL); switch_assert(channel != NULL);
switch_clear_flag_locked(channel, flags); switch_assert(channel->flag_mutex);
if (flags & CF_OUTBOUND) {
switch_mutex_lock(channel->flag_mutex);
channel->flags[flag] = 0;
switch_mutex_unlock(channel->flag_mutex);
if (flag == CF_OUTBOUND) {
switch_channel_set_variable(channel, "is_outbound", NULL); switch_channel_set_variable(channel, "is_outbound", NULL);
} }
} }
@ -823,7 +832,7 @@ SWITCH_DECLARE(uint8_t) switch_channel_ready(switch_channel_t *channel)
switch_assert(channel != NULL); switch_assert(channel != NULL);
if (!channel->hangup_cause && channel->state > CS_ROUTING && channel->state < CS_HANGUP && channel->state != CS_RESET && if (!channel->hangup_cause && channel->state > CS_ROUTING && channel->state < CS_HANGUP && channel->state != CS_RESET &&
!switch_test_flag(channel, CF_TRANSFER)) { !switch_channel_test_flag(channel, CF_TRANSFER)) {
ret++; ret++;
} }
@ -867,16 +876,22 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_name_state(const char *nam
SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_running_state(switch_channel_t *channel, switch_channel_state_t state, SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_running_state(switch_channel_t *channel, switch_channel_state_t state,
const char *file, const char *func, int line) const char *file, const char *func, int line)
{ {
int x;
switch_mutex_lock(channel->flag_mutex); switch_mutex_lock(channel->flag_mutex);
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, "(%s) Running State Change %s\n", channel->name, state_names[state]); switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, "(%s) Running State Change %s\n", channel->name, state_names[state]);
channel->running_state = state; channel->running_state = state;
if (channel->state_flags) { if (channel->state_flags[0]) {
channel->flags |= channel->state_flags; for(x = 1; x < CF_FLAG_MAX ; x++ ) {
channel->state_flags = 0; if (channel->state_flags[x]) {
channel->flags[x] = 1;
channel->state_flags[x] = 0;
}
}
channel->state_flags[0] = 0;
} }
switch_clear_flag(channel, CF_TAGGED); switch_channel_clear_flag(channel, CF_TAGGED);
if (channel->state >= CS_ROUTING) { if (channel->state >= CS_ROUTING) {
switch_channel_presence(channel, "unknown", (char *) state_names[state], NULL); switch_channel_presence(channel, "unknown", (char *) state_names[state], NULL);
@ -1185,7 +1200,7 @@ SWITCH_DECLARE(void) switch_channel_event_set_data(switch_channel_t *channel, sw
} }
if (switch_test_flag(channel, CF_VERBOSE_EVENTS) || if (switch_channel_test_flag(channel, CF_VERBOSE_EVENTS) ||
event->event_id == SWITCH_EVENT_CHANNEL_ORIGINATE || event->event_id == SWITCH_EVENT_CHANNEL_ORIGINATE ||
event->event_id == SWITCH_EVENT_CHANNEL_UUID || event->event_id == SWITCH_EVENT_CHANNEL_UUID ||
event->event_id == SWITCH_EVENT_CHANNEL_ANSWER || event->event_id == SWITCH_EVENT_CHANNEL_ANSWER ||