bridge / res_pjsip_sdp_rtp: Fix issues with media not being reinvited during direct...
[asterisk/asterisk.git] / apps / confbridge / include / confbridge.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2011, Digium, Inc.
5  *
6  * David Vossel <dvossel@digium.com>
7  * Joshua Colp <jcolp@digium.com>
8  *
9  * See http://www.asterisk.org for more information about
10  * the Asterisk project. Please do not directly contact
11  * any of the maintainers of this project for assistance;
12  * the project provides a web site, mailing lists and IRC
13  * channels for your use.
14  *
15  * This program is free software, distributed under the terms of
16  * the GNU General Public License Version 2. See the LICENSE file
17  * at the top of the source tree.
18  */
19
20
21 #ifndef _CONFBRIDGE_H
22 #define _CONFBRIDGE_H
23
24 #include "asterisk.h"
25 #include "asterisk/app.h"
26 #include "asterisk/logger.h"
27 #include "asterisk/linkedlists.h"
28 #include "asterisk/channel.h"
29 #include "asterisk/bridge.h"
30 #include "asterisk/bridge_features.h"
31 #include "conf_state.h"
32
33 /* Maximum length of a conference bridge name */
34 #define MAX_CONF_NAME AST_MAX_EXTENSION
35 /* Maximum length of a conference pin */
36 #define MAX_PIN     80
37 /* Maximum length of bridge/user/menu profile names */
38 #define MAX_PROFILE_NAME 128
39
40 #define DEFAULT_USER_PROFILE "default_user"
41 #define DEFAULT_BRIDGE_PROFILE "default_bridge"
42 #define DEFAULT_MENU_PROFILE "default_menu"
43
44 #define DEFAULT_TALKING_THRESHOLD 160
45 #define DEFAULT_SILENCE_THRESHOLD 2500
46
47 enum user_profile_flags {
48         USER_OPT_ADMIN =        (1 << 0), /*!< Set if the caller is an administrator */
49         USER_OPT_NOONLYPERSON = (1 << 1), /*!< Set if the "you are currently the only person in this conference" sound file should not be played */
50         USER_OPT_MARKEDUSER =   (1 << 2), /*!< Set if the caller is a marked user */
51         USER_OPT_STARTMUTED =   (1 << 3), /*!< Set if the caller should be initially set muted */
52         USER_OPT_MUSICONHOLD =  (1 << 4), /*!< Set if music on hold should be played if nobody else is in the conference bridge */
53         USER_OPT_QUIET =        (1 << 5), /*!< Set if no audio prompts should be played */
54         USER_OPT_ANNOUNCEUSERCOUNT = (1 << 6), /*!< Set if the number of users should be announced to the caller */
55         USER_OPT_WAITMARKED =   (1 << 7), /*!< Set if the user must wait for a marked user before starting */
56         USER_OPT_ENDMARKED =    (1 << 8), /*!< Set if the user should be kicked after the last Marked user exits */
57         USER_OPT_DENOISE =      (1 << 9), /*!< Sets if denoise filter should be used on audio before mixing. */
58         USER_OPT_ANNOUNCE_JOIN_LEAVE = (1 << 10), /*!< Sets if the user's name should be recorded and announced on join and leave. */
59         USER_OPT_TALKER_DETECT = (1 << 11), /*!< Sets if start and stop talking events should generated for this user over AMI. */
60         USER_OPT_DROP_SILENCE =  (1 << 12), /*!< Sets if silence should be dropped from the mix or not. */
61         USER_OPT_DTMF_PASS    =  (1 << 13), /*!< Sets if dtmf should be passed into the conference or not */
62         USER_OPT_ANNOUNCEUSERCOUNTALL = (1 << 14), /*!< Sets if the number of users should be announced to everyone. */
63         USER_OPT_JITTERBUFFER =  (1 << 15), /*!< Places a jitterbuffer on the user. */
64         USER_OPT_ANNOUNCE_JOIN_LEAVE_REVIEW = (1 << 16), /*!< modifies ANNOUNCE_JOIN_LEAVE - user reviews the recording before continuing */
65 };
66
67 enum bridge_profile_flags {
68         BRIDGE_OPT_RECORD_CONFERENCE = (1 << 0), /*!< Set if the conference should be recorded */
69         BRIDGE_OPT_VIDEO_SRC_LAST_MARKED = (1 << 1), /*!< Set if conference should feed video of last marked user to all participants. */
70         BRIDGE_OPT_VIDEO_SRC_FIRST_MARKED = (1 << 2), /*!< Set if conference should feed video of first marked user to all participants. */
71         BRIDGE_OPT_VIDEO_SRC_FOLLOW_TALKER = (1 << 3), /*!< Set if conference set the video feed to follow the loudest talker.  */
72         BRIDGE_OPT_RECORD_FILE_APPEND = (1 << 4), /*!< Set if the record file should be appended to between start/stops.  */
73         BRIDGE_OPT_RECORD_FILE_TIMESTAMP = (1 << 5), /*< Set if the record file should have a timestamp appended */
74 };
75
76 enum conf_menu_action_id {
77         MENU_ACTION_TOGGLE_MUTE = 1,
78         MENU_ACTION_PLAYBACK,
79         MENU_ACTION_PLAYBACK_AND_CONTINUE,
80         MENU_ACTION_INCREASE_LISTENING,
81         MENU_ACTION_DECREASE_LISTENING,
82         MENU_ACTION_RESET_LISTENING,
83         MENU_ACTION_RESET_TALKING,
84         MENU_ACTION_INCREASE_TALKING,
85         MENU_ACTION_DECREASE_TALKING,
86         MENU_ACTION_DIALPLAN_EXEC,
87         MENU_ACTION_ADMIN_TOGGLE_LOCK,
88         MENU_ACTION_ADMIN_KICK_LAST,
89         MENU_ACTION_LEAVE,
90         MENU_ACTION_NOOP,
91         MENU_ACTION_SET_SINGLE_VIDEO_SRC,
92         MENU_ACTION_RELEASE_SINGLE_VIDEO_SRC,
93         MENU_ACTION_PARTICIPANT_COUNT,
94         MENU_ACTION_ADMIN_TOGGLE_MUTE_PARTICIPANTS,
95 };
96
97 /*! The conference menu action contains both
98  *  the action id that represents the action that
99  *  must take place, along with any data associated
100  *  with that action. */
101 struct conf_menu_action {
102         enum conf_menu_action_id id;
103         union {
104                 char playback_file[PATH_MAX];
105                 struct {
106                         char context[AST_MAX_CONTEXT];
107                         char exten[AST_MAX_EXTENSION];
108                         int priority;
109                 } dialplan_args;
110         } data;
111         AST_LIST_ENTRY(conf_menu_action) action;
112 };
113
114 /*! Conference menu entries contain the DTMF sequence
115  *  and the list of actions that are associated with that
116  *  sequence. */
117 struct conf_menu_entry {
118         /*! the DTMF sequence that triggers the actions */
119         char dtmf[MAXIMUM_DTMF_FEATURE_STRING];
120         /*! The actions associated with this menu entry. */
121         AST_LIST_HEAD_NOLOCK(, conf_menu_action) actions;
122         AST_LIST_ENTRY(conf_menu_entry) entry;
123 };
124
125 /*! Conference menu structure.  Contains a list
126  * of DTMF sequences coupled with the actions those
127  * sequences invoke.*/
128 struct conf_menu {
129         char name[MAX_PROFILE_NAME];
130         AST_LIST_HEAD_NOLOCK(, conf_menu_entry) entries;
131 };
132
133 struct user_profile {
134         char name[MAX_PROFILE_NAME];
135         char pin[MAX_PIN];
136         char moh_class[128];
137         char announcement[PATH_MAX];
138         unsigned int flags;
139         unsigned int announce_user_count_all_after;
140         /*! The time in ms of talking before a user is considered to be talking by the dsp. */
141         unsigned int talking_threshold;
142         /*! The time in ms of silence before a user is considered to be silent by the dsp. */
143         unsigned int silence_threshold;
144 };
145
146 enum conf_sounds {
147         CONF_SOUND_HAS_JOINED,
148         CONF_SOUND_HAS_LEFT,
149         CONF_SOUND_KICKED,
150         CONF_SOUND_MUTED,
151         CONF_SOUND_UNMUTED,
152         CONF_SOUND_ONLY_ONE,
153         CONF_SOUND_THERE_ARE,
154         CONF_SOUND_OTHER_IN_PARTY,
155         CONF_SOUND_PLACE_IN_CONF,
156         CONF_SOUND_WAIT_FOR_LEADER,
157         CONF_SOUND_LEADER_HAS_LEFT,
158         CONF_SOUND_GET_PIN,
159         CONF_SOUND_INVALID_PIN,
160         CONF_SOUND_ONLY_PERSON,
161         CONF_SOUND_LOCKED,
162         CONF_SOUND_LOCKED_NOW,
163         CONF_SOUND_UNLOCKED_NOW,
164         CONF_SOUND_ERROR_MENU,
165         CONF_SOUND_JOIN,
166         CONF_SOUND_LEAVE,
167         CONF_SOUND_PARTICIPANTS_MUTED,
168         CONF_SOUND_PARTICIPANTS_UNMUTED,
169         CONF_SOUND_BEGIN,
170 };
171
172 struct bridge_profile_sounds {
173         AST_DECLARE_STRING_FIELDS(
174                 AST_STRING_FIELD(hasjoin);
175                 AST_STRING_FIELD(hasleft);
176                 AST_STRING_FIELD(kicked);
177                 AST_STRING_FIELD(muted);
178                 AST_STRING_FIELD(unmuted);
179                 AST_STRING_FIELD(onlyone);
180                 AST_STRING_FIELD(thereare);
181                 AST_STRING_FIELD(otherinparty);
182                 AST_STRING_FIELD(placeintoconf);
183                 AST_STRING_FIELD(waitforleader);
184                 AST_STRING_FIELD(leaderhasleft);
185                 AST_STRING_FIELD(getpin);
186                 AST_STRING_FIELD(invalidpin);
187                 AST_STRING_FIELD(onlyperson);
188                 AST_STRING_FIELD(locked);
189                 AST_STRING_FIELD(lockednow);
190                 AST_STRING_FIELD(unlockednow);
191                 AST_STRING_FIELD(errormenu);
192                 AST_STRING_FIELD(leave);
193                 AST_STRING_FIELD(join);
194                 AST_STRING_FIELD(participantsmuted);
195                 AST_STRING_FIELD(participantsunmuted);
196                 AST_STRING_FIELD(begin);
197         );
198 };
199
200 struct bridge_profile {
201         char name[MAX_PROFILE_NAME];
202         char language[MAX_LANGUAGE];              /*!< Language used for playback_chan */
203         char rec_file[PATH_MAX];
204         char rec_options[128];
205         char rec_command[128];
206         unsigned int flags;
207         unsigned int max_members;          /*!< The maximum number of participants allowed in the conference */
208         unsigned int internal_sample_rate; /*!< The internal sample rate of the bridge. 0 when set to auto adjust mode. */
209         unsigned int mix_interval;  /*!< The internal mixing interval used by the bridge. When set to 0 the bridgewill use a default interval. */
210         struct bridge_profile_sounds *sounds;
211 };
212
213 /*! \brief The structure that represents a conference bridge */
214 struct confbridge_conference {
215         char name[MAX_CONF_NAME];                                         /*!< Name of the conference bridge */
216         struct confbridge_state *state;                                   /*!< Conference state information */
217         struct ast_bridge *bridge;                                        /*!< Bridge structure doing the mixing */
218         struct bridge_profile b_profile;                                  /*!< The Bridge Configuration Profile */
219         unsigned int activeusers;                                         /*!< Number of active users present */
220         unsigned int markedusers;                                         /*!< Number of marked users present */
221         unsigned int waitingusers;                                        /*!< Number of waiting users present */
222         unsigned int locked:1;                                            /*!< Is this conference bridge locked? */
223         unsigned int muted:1;                                             /*!< Is this conference bridge muted? */
224         unsigned int record_state:2;                                      /*!< Whether recording is started, stopped, or should exit */
225         struct ast_channel *playback_chan;                                /*!< Channel used for playback into the conference bridge */
226         struct ast_channel *record_chan;                                  /*!< Channel used for recording the conference */
227         pthread_t record_thread;                                          /*!< The thread the recording chan lives in */
228         ast_mutex_t playback_lock;                                        /*!< Lock used for playback channel */
229         ast_mutex_t record_lock;                                          /*!< Lock used for the record thread */
230         ast_cond_t record_cond;                                           /*!< Recording condition variable */
231         AST_LIST_HEAD_NOLOCK(, confbridge_user) active_list;              /*!< List of users participating in the conference bridge */
232         AST_LIST_HEAD_NOLOCK(, confbridge_user) waiting_list;             /*!< List of users waiting to join the conference bridge */
233 };
234
235 extern struct ao2_container *conference_bridges;
236
237 struct post_join_action {
238         int (*func)(struct confbridge_user *user);
239         AST_LIST_ENTRY(post_join_action) list;
240 };
241
242 /*! \brief The structure that represents a conference bridge user */
243 struct confbridge_user {
244         struct confbridge_conference *conference;    /*!< Conference bridge they are participating in */
245         struct bridge_profile b_profile;             /*!< The Bridge Configuration Profile */
246         struct user_profile u_profile;               /*!< The User Configuration Profile */
247         char menu_name[MAX_PROFILE_NAME];            /*!< The name of the DTMF menu assigned to this user */
248         char name_rec_location[PATH_MAX];            /*!< Location of the User's name recorded file if it exists */
249         struct ast_channel *chan;                    /*!< Asterisk channel participating */
250         struct ast_bridge_features features;         /*!< Bridge features structure */
251         struct ast_bridge_tech_optimizations tech_args; /*!< Bridge technology optimizations for talk detection */
252         unsigned int suspended_moh;                  /*!< Count of active suspended MOH actions. */
253         unsigned int muted:1;                        /*!< Has the user requested to be muted? */
254         unsigned int kicked:1;                       /*!< User has been kicked from the conference */
255         unsigned int playing_moh:1;                  /*!< MOH is currently being played to the user */
256         AST_LIST_HEAD_NOLOCK(, post_join_action) post_join_list; /*!< List of sounds to play after joining */;
257         AST_LIST_ENTRY(confbridge_user) list;        /*!< Linked list information */
258 };
259
260 /*! \brief load confbridge.conf file */
261 int conf_load_config(void);
262
263 /*! \brief reload confbridge.conf file */
264 int conf_reload_config(void);
265
266 /*! \brief destroy the information loaded from the confbridge.conf file*/
267 void conf_destroy_config(void);
268
269 /*!
270  * \brief find a user profile given a user profile's name and store
271  * that profile in result structure.
272  *
273  * \param chan channel the user profile is requested for
274  * \param user_profile_name name of the profile requested (optional)
275  * \param result data contained by the user profile will be copied to this struct pointer
276  *
277  * \details If user_profile_name is not provided, this function will
278  * check for the presence of a user profile set by the CONFBRIDGE
279  * function on a channel datastore. If that doesn't exist, the
280  * default_user profile is used.
281  *
282  * \retval user profile on success
283  * \retval NULL on failure
284  */
285 const struct user_profile *conf_find_user_profile(struct ast_channel *chan, const char *user_profile_name, struct user_profile *result);
286
287 /*!
288  * \brief Find a bridge profile given a bridge profile's name and store
289  * that profile in result structure.
290  *
291  * \param chan channel the bridge profile is requested for
292  * \param bridge_profile_name name of the profile requested (optional)
293  * \param result data contained by the bridge profile will be copied to this struct pointer
294  *
295  * \details If bridge_profile_name is not provided, this function will
296  * check for the presence of a bridge profile set by the CONFBRIDGE
297  * function on a channel datastore. If that doesn't exist, the
298  * default_bridge profile is used.
299  *
300  * \retval bridge profile on success
301  * \retval NULL on failure
302  */
303 const struct bridge_profile *conf_find_bridge_profile(struct ast_channel *chan, const char *bridge_profile_name, struct bridge_profile *result);
304
305 /*!
306  * \brief find a menu profile given a menu profile's name and apply
307  * the menu in DTMF hooks.
308  *
309  * \param chan channel the menu profile is requested for
310  * \param user user profile the menu is being applied to
311  * \param menu_profile_name name of the profile requested (optional)
312  *
313  * \details If menu_profile_name is not provided, this function will
314  * check for the presence of a menu profile set by the CONFBRIDGE
315  * function on a channel datastore. If that doesn't exist, the
316  * default_menu profile is used.
317  *
318  * \retval 0 on success
319  * \retval -1 on failure
320  */
321 int conf_set_menu_to_user(struct ast_channel *chan, struct confbridge_user *user, const char *menu_profile_name);
322
323 /*!
324  * \brief Destroy a bridge profile found by 'conf_find_bridge_profile'
325  */
326 void conf_bridge_profile_destroy(struct bridge_profile *b_profile);
327
328 /*!
329  * \brief copies a bridge profile
330  * \note conf_bridge_profile_destroy must be called on the dst structure
331  */
332 void conf_bridge_profile_copy(struct bridge_profile *dst, struct bridge_profile *src);
333
334 /*!
335  * \brief Finds a menu_entry in a menu structure matched by DTMF sequence.
336  *
337  * \note the menu entry found must be destroyed using conf_menu_entry_destroy()
338  *
339  * \retval 1 success, entry is found and stored in result
340  * \retval 0 failure, no entry found for given DTMF sequence
341  */
342 int conf_find_menu_entry_by_sequence(const char *dtmf_sequence, struct conf_menu *menu, struct conf_menu_entry *result);
343
344 /*!
345  * \brief Destroys and frees all the actions stored in a menu_entry structure
346  */
347 void conf_menu_entry_destroy(struct conf_menu_entry *menu_entry);
348
349 /*!
350  * \brief Once a DTMF sequence matches a sequence in the user's DTMF menu, this function will get
351  * called to perform the menu action.
352  *
353  * \param bridge_channel Bridged channel this is involving
354  * \param user the conference user to perform the action on.
355  * \param menu_entry the menu entry that invoked this callback to occur.
356  * \param menu an AO2 referenced pointer to the entire menu structure the menu_entry
357  *        derived from.
358  *
359  * \note The menu_entry is a deep copy of the entry found in the menu structure.  This allows
360  * for the menu_entry to be accessed without requiring the menu lock.  If the menu must
361  * be accessed, the menu lock must be held.  Reference counting of the menu structure is
362  * handled outside of the scope of this function.
363  *
364  * \retval 0 success
365  * \retval -1 failure
366  */
367 int conf_handle_dtmf(
368         struct ast_bridge_channel *bridge_channel,
369         struct confbridge_user *user,
370         struct conf_menu_entry *menu_entry,
371         struct conf_menu *menu);
372
373
374 /*! \brief Looks to see if sound file is stored in bridge profile sounds, if not
375  *  default sound is provided.*/
376 const char *conf_get_sound(enum conf_sounds sound, struct bridge_profile_sounds *custom_sounds);
377
378 int func_confbridge_helper(struct ast_channel *chan, const char *cmd, char *data, const char *value);
379
380 /*!
381  * \brief Play sound file into conference bridge
382  *
383  * \param conference The conference bridge to play sound file into
384  * \param filename Sound file to play
385  *
386  * \retval 0 success
387  * \retval -1 failure
388  */
389 int play_sound_file(struct confbridge_conference *conference, const char *filename);
390
391 /*! \brief Callback to be called when the conference has become empty
392  * \param conference The conference bridge
393  */
394 void conf_ended(struct confbridge_conference *conference);
395
396 /*!
397  * \brief Update the actual mute status of the user and set it on the bridge.
398  *
399  * \param user User to update the mute status.
400  *
401  * \return Nothing
402  */
403 void conf_update_user_mute(struct confbridge_user *user);
404
405 /*!
406  * \brief Stop MOH for the conference user.
407  *
408  * \param user Conference user to stop MOH on.
409  *
410  * \return Nothing
411  */
412 void conf_moh_stop(struct confbridge_user *user);
413
414 /*!
415  * \brief Start MOH for the conference user.
416  *
417  * \param user Conference user to start MOH on.
418  *
419  * \return Nothing
420  */
421 void conf_moh_start(struct confbridge_user *user);
422
423 /*! \brief Attempt to mute/play MOH to the only user in the conference if they require it
424  * \param conference A conference bridge containing a single user
425  */
426 void conf_mute_only_active(struct confbridge_conference *conference);
427
428 /*! \brief Callback to execute any time we transition from zero to one active users
429  * \param conference The conference bridge with a single active user joined
430  * \retval 0 success
431  * \retval -1 failure
432  */
433 void conf_handle_first_join(struct confbridge_conference *conference);
434
435 /*! \brief Handle actions every time a waitmarked user joins w/o a marked user present
436  * \param user The waitmarked user
437  * \retval 0 success
438  * \retval -1 failure
439  */
440 int conf_handle_inactive_waitmarked(struct confbridge_user *user);
441
442 /*! \brief Handle actions whenever an unmarked user joins an inactive conference
443  * \note These actions seem like they could apply just as well to a marked user
444  * and possibly be made to happen any time transitioning to a single state.
445  *
446  * \param user The unmarked user
447  */
448 int conf_handle_only_unmarked(struct confbridge_user *user);
449
450 /*! \brief Handle when a conference moves to having more than one active participant
451  * \param conference The conference bridge with more than one active participant
452  */
453 void conf_handle_second_active(struct confbridge_conference *conference);
454
455 /*! \brief Add a conference bridge user as an unmarked active user of the conference
456  * \param conference The conference bridge to add the user to
457  * \param user The conference bridge user to add to the conference
458  */
459 void conf_add_user_active(struct confbridge_conference *conference, struct confbridge_user *user);
460
461 /*! \brief Add a conference bridge user as a marked active user of the conference
462  * \param conference The conference bridge to add the user to
463  * \param user The conference bridge user to add to the conference
464  */
465 void conf_add_user_marked(struct confbridge_conference *conference, struct confbridge_user *user);
466
467 /*! \brief Add a conference bridge user as an waiting user of the conference
468  * \param conference The conference bridge to add the user to
469  * \param user The conference bridge user to add to the conference
470  */
471 void conf_add_user_waiting(struct confbridge_conference *conference, struct confbridge_user *user);
472
473 /*! \brief Remove a conference bridge user from the unmarked active conference users in the conference
474  * \param conference The conference bridge to remove the user from
475  * \param user The conference bridge user to remove from the conference
476  */
477 void conf_remove_user_active(struct confbridge_conference *conference, struct confbridge_user *user);
478
479 /*! \brief Remove a conference bridge user from the marked active conference users in the conference
480  * \param conference The conference bridge to remove the user from
481  * \param user The conference bridge user to remove from the conference
482  */
483 void conf_remove_user_marked(struct confbridge_conference *conference, struct confbridge_user *user);
484
485 /*! \brief Remove a conference bridge user from the waiting conference users in the conference
486  * \param conference The conference bridge to remove the user from
487  * \param user The conference bridge user to remove from the conference
488  */
489 void conf_remove_user_waiting(struct confbridge_conference *conference, struct confbridge_user *user);
490
491 /*! \brief Queue a function to run with the given conference bridge user as an argument once the state transition is complete
492  * \param user The conference bridge user to pass to the function
493  * \param func The function to queue
494  * \retval 0 success
495  * \retval non-zero failure
496  */
497 int conf_add_post_join_action(struct confbridge_user *user, int (*func)(struct confbridge_user *user));
498
499 /*!
500  * \since 12.0
501  * \brief get the confbridge start stasis message type
502  *
503  * \retval stasis message type for confbridge start messages if it's available
504  * \retval NULL if it isn't
505  */
506 struct stasis_message_type *confbridge_start_type(void);
507
508 /*!
509  * \since 12.0
510  * \brief get the confbridge end stasis message type
511  *
512  * \retval stasis message type for confbridge end messages if it's available
513  * \retval NULL if it isn't
514  */
515 struct stasis_message_type *confbridge_end_type(void);
516
517 /*!
518  * \since 12.0
519  * \brief get the confbridge join stasis message type
520  *
521  * \retval stasis message type for confbridge join messages if it's available
522  * \retval NULL if it isn't
523  */
524 struct stasis_message_type *confbridge_join_type(void);
525
526 /*!
527  * \since 12.0
528  * \brief get the confbridge leave stasis message type
529  *
530  * \retval stasis message type for confbridge leave messages if it's available
531  * \retval NULL if it isn't
532  */
533 struct stasis_message_type *confbridge_leave_type(void);
534
535 /*!
536  * \since 12.0
537  * \brief get the confbridge start_record stasis message type
538  *
539  * \retval stasis message type for confbridge start_record messages if it's available
540  * \retval NULL if it isn't
541  */
542 struct stasis_message_type *confbridge_start_record_type(void);
543
544 /*!
545  * \since 12.0
546  * \brief get the confbridge stop_record stasis message type
547  *
548  * \retval stasis message type for confbridge stop_record messages if it's available
549  * \retval NULL if it isn't
550  */
551 struct stasis_message_type *confbridge_stop_record_type(void);
552
553 /*!
554  * \since 12.0
555  * \brief get the confbridge mute stasis message type
556  *
557  * \retval stasis message type for confbridge mute messages if it's available
558  * \retval NULL if it isn't
559  */
560 struct stasis_message_type *confbridge_mute_type(void);
561
562 /*!
563  * \since 12.0
564  * \brief get the confbridge unmute stasis message type
565  *
566  * \retval stasis message type for confbridge unmute messages if it's available
567  * \retval NULL if it isn't
568  */
569 struct stasis_message_type *confbridge_unmute_type(void);
570
571 /*!
572  * \since 12.0
573  * \brief get the confbridge talking stasis message type
574  *
575  * \retval stasis message type for confbridge talking messages if it's available
576  * \retval NULL if it isn't
577  */
578 struct stasis_message_type *confbridge_talking_type(void);
579
580 /*!
581  * \since 12.0
582  * \brief register stasis message routers to handle manager events for confbridge messages
583  *
584  * \retval 0 success
585  * \retval non-zero failure
586  */
587 int manager_confbridge_init(void);
588
589 /*!
590  * \since 12.0
591  * \brief unregister stasis message routers to handle manager events for confbridge messages
592  */
593 void manager_confbridge_shutdown(void);
594
595 /*!
596  * \brief Get ConfBridge record channel technology struct.
597  * \since 12.0.0
598  *
599  * \return ConfBridge record channel technology.
600  */
601 struct ast_channel_tech *conf_record_get_tech(void);
602
603 /*!
604  * \brief Get ConfBridge announce channel technology struct.
605  * \since 12.0.0
606  *
607  * \return ConfBridge announce channel technology.
608  */
609 struct ast_channel_tech *conf_announce_get_tech(void);
610
611 /*!
612  * \brief Remove the announcer channel from the conference.
613  * \since 12.0.0
614  *
615  * \param chan Either channel in the announcer channel pair.
616  *
617  * \return Nothing
618  */
619 void conf_announce_channel_depart(struct ast_channel *chan);
620
621 /*!
622  * \brief Push the announcer channel into the conference.
623  * \since 12.0.0
624  *
625  * \param ast Either channel in the announcer channel pair.
626  *
627  * \retval 0 on success.
628  * \retval -1 on error.
629  */
630 int conf_announce_channel_push(struct ast_channel *ast);
631 #endif