/*
 * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 * Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
 *
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 *
 * The Initial Developer of the Original Code is
 * Anthony Minessale II <anthm@freeswitch.org>
 * Portions created by the Initial Developer are Copyright (C)
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Anthony Minessale II <anthm@freeswitch.org>
 * Neal Horman <neal at wanlink dot com>
 * Bret McDanel <trixter at 0xdecafbad dot com>
 * Dale Thatcher <freeswitch at dalethatcher dot com>
 * Chris Danielson <chris at maxpowersoft dot com>
 * Rupa Schomaker <rupa@rupa.com>
 * David Weekly <david@weekly.org>
 * Joao Mesquita <jmesquita@gmail.com>
 * Raymond Chandler <intralanman@freeswitch.org>
 * Seven Du <dujinfang@gmail.com>
 * Emmanuel Schmidbauer <e.schmidbauer@gmail.com>
 * William King <william.king@quentustech.com>
 *
 * mod_conference.c -- Software Conference Bridge
 *
 */

#ifndef MOD_CONFERENCE_H
#define MOD_CONFERENCE_H

#include <switch.h>

/* DEFINES */

#ifdef OPENAL_POSITIONING
#define AL_ALEXT_PROTOTYPES
#include <AL/al.h>
#include <AL/alc.h>
#include <AL/alext.h>
#endif

#define DEFAULT_LAYER_TIMEOUT 10
#define DEFAULT_AGC_LEVEL 1100
#define CONFERENCE_UUID_VARIABLE "conference_uuid"

/* Size to allocate for audio buffers */
#define CONF_BUFFER_SIZE 1024 * 128
#define CONF_EVENT_MAINT "conference::maintenance"
#define CONF_EVENT_CDR "conference::cdr"
#define CONF_DEFAULT_LEADIN 20

#define CONF_DBLOCK_SIZE CONF_BUFFER_SIZE
#define CONF_DBUFFER_SIZE CONF_BUFFER_SIZE
#define CONF_DBUFFER_MAX 0
#define CONF_CHAT_PROTO "conf"

#ifndef MIN
#define MIN(a, b) ((a)<(b)?(a):(b))
#endif

/* the rate at which the infinite impulse response filter on speaker score will decay. */
#define SCORE_DECAY 0.8
/* the maximum value for the IIR score [keeps loud & longwinded people from getting overweighted] */
#define SCORE_MAX_IIR 25000
/* the minimum score for which you can be considered to be loud enough to now have the floor */
#define SCORE_IIR_SPEAKING_MAX 300
/* the threshold below which you cede the floor to someone loud (see above value). */
#define SCORE_IIR_SPEAKING_MIN 100
/* the FPS of the conference canvas */
#define FPS 30
/* max supported layers in one mcu */
#define MCU_MAX_LAYERS 64

/* video layout scale factor */
#define VIDEO_LAYOUT_SCALE 360.0f

#define CONFERENCE_MUX_DEFAULT_LAYOUT "group:grid"
#define CONFERENCE_MUX_DEFAULT_SUPER_LAYOUT "grid"
#define CONFERENCE_CANVAS_DEFAULT_WIDTH 1280
#define CONFERENCE_CANVAS_DEFAULT_HIGHT 720
#define MAX_CANVASES 20
#define SUPER_CANVAS_ID MAX_CANVASES
#define test_eflag(conference, flag) ((conference)->eflags & flag)

#define lock_member(_member) switch_mutex_lock(_member->write_mutex); switch_mutex_lock(_member->read_mutex)
#define unlock_member(_member) switch_mutex_unlock(_member->read_mutex); switch_mutex_unlock(_member->write_mutex)

//#define lock_member(_member) switch_mutex_lock(_member->write_mutex)
//#define unlock_member(_member) switch_mutex_unlock(_member->write_mutex)

#define CONFFUNCAPISIZE (sizeof(conference_api_sub_commands)/sizeof(conference_api_sub_commands[0]))

#define MAX_MUX_CODECS 50

#define ALC_HRTF_SOFT  0x1992

#define validate_pin(buf, pin, mpin)									\
	pin_valid = (!zstr(pin) && strcmp(buf, pin) == 0);					\
	if (!pin_valid && !zstr(mpin) && strcmp(buf, mpin) == 0) {			\
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Moderator PIN found!\n"); \
		pin_valid = 1;													\
		mpin_matched = 1;												\
	}

/* STRUCTS */

struct conference_fps {
	float fps;
	int ms;
	int samples;
};


typedef enum {
	CONF_SILENT_REQ = (1 << 0),
	CONF_SILENT_DONE = (1 << 1)
} conference_app_flag_t;

extern char *mod_conference_cf_name;
extern char *api_syntax;
extern int EC;

typedef enum {
	FILE_STOP_CURRENT,
	FILE_STOP_ALL,
	FILE_STOP_ASYNC
} file_stop_t;

/* Global Values */
typedef struct conference_globals_s {
	switch_memory_pool_t *conference_pool;
	switch_mutex_t *conference_mutex;
	switch_hash_t *conference_hash;
	switch_mutex_t *id_mutex;
	switch_mutex_t *hash_mutex;
	switch_mutex_t *setup_mutex;
	uint32_t id_pool;
	int32_t running;
	uint32_t threads;
	switch_event_channel_id_t event_channel_id;
} conference_globals_t;

extern conference_globals_t conference_globals;

/* forward declaration for conference_obj and caller_control */
struct conference_member;
typedef struct conference_member conference_member_t;

struct caller_control_actions;

typedef struct caller_control_actions {
	char *binded_dtmf;
	char *data;
	char *expanded_data;
} caller_control_action_t;

typedef struct caller_control_menu_info {
	switch_ivr_menu_t *stack;
	char *name;
} caller_control_menu_info_t;

typedef enum {
	MFLAG_RUNNING,
	MFLAG_CAN_SPEAK,
	MFLAG_CAN_HEAR,
	MFLAG_KICKED,
	MFLAG_ITHREAD,
	MFLAG_NOCHANNEL,
	MFLAG_INTREE,
	MFLAG_NO_MINIMIZE_ENCODING,
	MFLAG_FLUSH_BUFFER,
	MFLAG_ENDCONF,
	MFLAG_HAS_AUDIO,
	MFLAG_TALKING,
	MFLAG_RESTART,
	MFLAG_MINTWO,
	MFLAG_MUTE_DETECT,
	MFLAG_DIST_DTMF,
	MFLAG_MOD,
	MFLAG_INDICATE_MUTE,
	MFLAG_INDICATE_UNMUTE,
	MFLAG_INDICATE_BLIND,
	MFLAG_INDICATE_UNBLIND,
	MFLAG_NOMOH,
	MFLAG_VIDEO_BRIDGE,
	MFLAG_INDICATE_MUTE_DETECT,
	MFLAG_PAUSE_RECORDING,
	MFLAG_ACK_VIDEO,
	MFLAG_GHOST,
	MFLAG_JOIN_ONLY,
	MFLAG_POSITIONAL,
	MFLAG_NO_POSITIONAL,
	MFLAG_JOIN_VID_FLOOR,
	MFLAG_RECEIVING_VIDEO,
	MFLAG_CAN_SEE,
	MFLAG_CAN_BE_SEEN,
	MFLAG_SECOND_SCREEN,
	MFLAG_SILENT,
	MFLAG_FLIP_VIDEO,
	MFLAG_ROTATE_VIDEO,
	MFLAG_MIRROR_VIDEO,
	MFLAG_INDICATE_DEAF,
	MFLAG_INDICATE_UNDEAF,
	MFLAG_TALK_DATA_EVENTS,
	MFLAG_NO_VIDEO_BLANKS,
	MFLAG_VIDEO_JOIN,
	MFLAG_DED_VID_LAYER,
	MFLAG_HOLD,
	///////////////////////////
	MFLAG_MAX
} member_flag_t;

typedef enum {
	CFLAG_RUNNING,
	CFLAG_DYNAMIC,
	CFLAG_ENFORCE_MIN,
	CFLAG_DESTRUCT,
	CFLAG_LOCKED,
	CFLAG_ANSWERED,
	CFLAG_BRIDGE_TO,
	CFLAG_WAIT_MOD,
	CFLAG_VID_FLOOR,
	CFLAG_WASTE_FLAG,
	CFLAG_OUTCALL,
	CFLAG_INHASH,
	CFLAG_EXIT_SOUND,
	CFLAG_ENTER_SOUND,
	CFLAG_USE_ME,
	CFLAG_AUDIO_ALWAYS,
	CFLAG_ENDCONF_FORCED,
	CFLAG_RFC4579,
	CFLAG_FLOOR_CHANGE,
	CFLAG_VID_FLOOR_LOCK,
	CFLAG_JSON_EVENTS,
	CFLAG_LIVEARRAY_SYNC,
	CFLAG_CONF_RESTART_AUTO_RECORD,
	CFLAG_POSITIONAL,
	CFLAG_TRANSCODE_VIDEO,
	CFLAG_VIDEO_MUXING,
	CFLAG_MINIMIZE_VIDEO_ENCODING,
	CFLAG_MANAGE_INBOUND_VIDEO_BITRATE,
	CFLAG_JSON_STATUS,
	CFLAG_VIDEO_BRIDGE_FIRST_TWO,
	CFLAG_VIDEO_REQUIRED_FOR_CANVAS,
	CFLAG_PERSONAL_CANVAS,
	CFLAG_REFRESH_LAYOUT,
	CFLAG_VIDEO_MUTE_EXIT_CANVAS,
	CFLAG_NO_MOH,
	CFLAG_DED_VID_LAYER_AUDIO_FLOOR,
	/////////////////////////////////
	CFLAG_MAX
} conference_flag_t;

typedef struct conference_cdr_node_s {
	switch_caller_profile_t *cp;
	char *record_path;
	switch_time_t join_time;
	switch_time_t leave_time;
	member_flag_t mflags[MFLAG_MAX];
	uint32_t id;
	conference_member_t *member;
	switch_event_t *var_event;
	struct conference_cdr_node_s *next;
} conference_cdr_node_t;

typedef enum {
	CDRR_LOCKED = 1,
	CDRR_PIN,
	CDRR_MAXMEMBERS
} cdr_reject_reason_t;

typedef struct conference_cdr_reject_s {
	switch_caller_profile_t *cp;
	switch_time_t reject_time;
	cdr_reject_reason_t reason;
	struct conference_cdr_reject_s *next;
} conference_cdr_reject_t;

typedef enum {
	CDRE_NONE,
	CDRE_AS_CONTENT,
	CDRE_AS_FILE
} cdr_event_mode_t;


struct call_list {
	char *string;
	int iteration;
	struct call_list *next;
};
typedef struct call_list call_list_t;



typedef enum {
	RFLAG_CAN_SPEAK = (1 << 0),
	RFLAG_CAN_HEAR = (1 << 1),
	RFLAG_CAN_SEND_VIDEO = (1 << 2)
} relation_flag_t;

typedef enum {
	NODE_TYPE_FILE,
	NODE_TYPE_SPEECH
} node_type_t;

typedef enum {
	NFLAG_NONE = (1 << 0),
	NFLAG_PAUSE = (1 << 1)
} node_flag_t;

typedef enum {
	EFLAG_HOLD_MEMBER = (1 << 0),
	EFLAG_DEL_MEMBER = (1 << 1),
	EFLAG_ENERGY_LEVEL = (1 << 2),
	EFLAG_VOLUME_LEVEL = (1 << 3),
	EFLAG_GAIN_LEVEL = (1 << 4),
	EFLAG_DTMF = (1 << 5),
	EFLAG_STOP_TALKING = (1 << 6),
	EFLAG_START_TALKING = (1 << 7),
	EFLAG_MUTE_MEMBER = (1 << 8),
	EFLAG_BLIND_MEMBER = (1 << 9),
	EFLAG_DEAF_MEMBER = (1 << 10),
	EFLAG_UNUSED1 = (1 << 11),
	EFLAG_KICK_MEMBER = (1 << 12),
	EFLAG_DTMF_MEMBER = (1 << 13),
	EFLAG_ENERGY_LEVEL_MEMBER = (1 << 14),
	EFLAG_VOLUME_IN_MEMBER = (1 << 15),
	EFLAG_VOLUME_OUT_MEMBER = (1 << 16),
	EFLAG_PLAY_FILE = (1 << 17),
	EFLAG_PLAY_FILE_MEMBER = (1 << 18),
	EFLAG_SPEAK_TEXT = (1 << 19),
	EFLAG_SPEAK_TEXT_MEMBER = (1 << 20),
	EFLAG_LOCK = (1 << 21),
	EFLAG_UNLOCK = (1 << 22),
	EFLAG_TRANSFER = (1 << 23),
	EFLAG_BGDIAL_RESULT = (1 << 24),
	EFLAG_FLOOR_CHANGE = (1 << 25),
	EFLAG_MUTE_DETECT = (1 << 26),
	EFLAG_RECORD = (1 << 27),
	EFLAG_HUP_MEMBER = (1 << 28),
	EFLAG_PLAY_FILE_DONE = (1 << 29),
	EFLAG_SET_POSITION_MEMBER = (1 << 30)
} event_type_t;

#ifdef OPENAL_POSITIONING
typedef struct al_handle_s {
	switch_mutex_t *mutex;
	ALCdevice *device;
	ALCcontext *context;
	ALuint source;
	ALuint buffer_in[2];
	int setpos;
	ALfloat pos_x;
	ALfloat pos_y;
	ALfloat pos_z;
} al_handle_t;

void conference_al_close(al_handle_t *al);
#else
typedef struct al_handle_s {
	int unsupported;
	switch_mutex_t *mutex;
} al_handle_t;
#endif
struct conference_obj;

typedef struct conference_file_node {
	switch_file_handle_t fh;
	switch_speech_handle_t *sh;
	node_flag_t flags;
	node_type_t type;
	uint8_t done;
	uint8_t async;
	switch_memory_pool_t *pool;
	uint32_t leadin;
	struct conference_file_node *next;
	char *file;
	switch_bool_t mux;
	uint32_t member_id;
	al_handle_t *al;
	int layer_id;
	int canvas_id;
	struct conference_obj *conference;
	char *res_id;
	int loops;
	int new_fnode;
	int layer_lock;
	switch_core_video_filter_t filters;
} conference_file_node_t;

typedef enum {
	REC_ACTION_STOP = 1,
	REC_ACTION_PAUSE,
	REC_ACTION_RESUME
} recording_action_type_t;

/* conference xml config sections */
typedef struct conference_xml_cfg {
	switch_xml_t profile;
	switch_xml_t controls;
} conference_xml_cfg_t;

struct vid_helper {
	conference_member_t *member_a;
	conference_member_t *member_b;
	int up;
};


typedef struct mcu_layer_geometry_s {
	int x;
	int y;
	int scale;
	int hscale;
	int floor;
	int flooronly;
	int fileonly;
	int overlap;
	int zoom;
	int border;
	char *res_id;
	char *role_id;
	char *audio_position;
} mcu_layer_geometry_t;

typedef struct mcu_layer_def_s {
	char *name;
	mcu_layer_geometry_t layers[MCU_MAX_LAYERS];
} mcu_layer_def_t;


typedef struct mcu_layer_cam_opts_s {
	int manual_pan;
	int manual_zoom;
	int autozoom;
	int autopan;
	int zoom_factor;
	int snap_factor;
	int zoom_move_factor;
	int pan_speed;
	int pan_accel_speed;
	int pan_accel_min;
	int zoom_speed;
	int zoom_accel_speed;
	int zoom_accel_min;
} mcu_layer_cam_opts_t;

struct mcu_canvas_s;

typedef struct mcu_layer_s {
	mcu_layer_geometry_t geometry;
	int member_id;
	int idx;
	int tagged;
	int bugged;
	uint32_t screen_w;
	uint32_t screen_h;
	int x_pos;
	int y_pos;
	int banner_patched;
	int mute_patched;
	int avatar_patched;
	int refresh;
	int clear;
	int is_avatar;
	int crop_x;
	int crop_y;
	int crop_w;
	int crop_h;
	int last_w;
	int last_h;
	uint32_t img_count;
	switch_image_t *img;
	switch_image_t *cur_img;
	switch_image_t *overlay_img;
	switch_image_t *banner_img;
	switch_image_t *logo_img;
	switch_image_t *mute_img;
	switch_img_txt_handle_t *txthandle;
	conference_file_node_t *fnode;
	switch_img_position_t logo_pos;
	switch_img_fit_t logo_fit;
	struct mcu_canvas_s *canvas;
	int need_patch;
	conference_member_t *member;
	switch_frame_t bug_frame;
	switch_frame_geometry_t last_geometry;
	switch_frame_geometry_t auto_geometry;
	switch_frame_geometry_t zoom_geometry;
	switch_frame_geometry_t pan_geometry;
	switch_frame_geometry_t manual_geometry;
	mcu_layer_cam_opts_t cam_opts;
	switch_mutex_t *overlay_mutex;
	switch_core_video_filter_t overlay_filters;
	int manual_border;
} mcu_layer_t;

typedef struct video_layout_s {
	char *name;
	char *audio_position;
	char *bgimg;
	char *fgimg;
	char *transition_in;
	char *transition_out;
	mcu_layer_geometry_t images[MCU_MAX_LAYERS];
	int layers;
} video_layout_t;

typedef struct video_layout_node_s {
	video_layout_t *vlayout;
	struct video_layout_node_s *next;
} video_layout_node_t;

typedef struct layout_group_s {
	video_layout_node_t *layouts;
} layout_group_t;

typedef struct codec_set_s {
	switch_codec_t codec;
	switch_frame_t frame;
	uint8_t *packet;
	switch_image_t *scaled_img;
	uint8_t fps_divisor;
	uint32_t frame_count;
	char *video_codec_group;
} codec_set_t;


typedef struct mcu_canvas_s {
	int width;
	int height;
	switch_image_t *img;
	mcu_layer_t layers[MCU_MAX_LAYERS];
	int res_count;
	int role_count;
	int total_layers;
	int layers_used;
	int layout_floor_id;
	int refresh;
	int send_keyframe;
	int play_file;
	int video_count;
	char *video_layout_group;
	switch_rgb_color_t bgcolor;
	switch_rgb_color_t border_color;
	switch_rgb_color_t letterbox_bgcolor;
	switch_mutex_t *mutex;
	switch_mutex_t *write_mutex;
	switch_timer_t timer;
	switch_memory_pool_t *pool;
	video_layout_t *vlayout;
	video_layout_t *new_vlayout;
	int canvas_id;
	struct conference_obj *conference;
	switch_thread_t *video_muxing_thread;
	int video_timer_reset;
	switch_queue_t *video_queue;
	int recording;
	switch_image_t *bgimg;
	switch_image_t *fgimg;
	int playing_video_file;
	int overlay_video_file;
	codec_set_t *write_codecs[MAX_MUX_CODECS];
	int write_codecs_count;
} mcu_canvas_t;

/* Record Node */
typedef struct conference_record {
	struct conference_obj *conference;
	char *path;
	switch_memory_pool_t *pool;
	switch_bool_t autorec;
	struct conference_record *next;
	switch_file_handle_t fh;
	int canvas_id;
} conference_record_t;

typedef enum {
	CONF_VIDEO_MODE_PASSTHROUGH,
	CONF_VIDEO_MODE_TRANSCODE,
	CONF_VIDEO_MODE_MUX
} conference_video_mode_t;

/* Conference Object */
typedef struct conference_obj {
	char *name;
	char *la_name;
	char *la_event_channel;
	char *chat_event_channel;
	char *mod_event_channel;
	char *info_event_channel;
	char *desc;
	char *timer_name;
	char *tts_engine;
	char *tts_voice;
	char *member_enter_sound;
	char *enter_sound;
	char *exit_sound;
	char *alone_sound;
	char *perpetual_sound;
	char *moh_sound;
	char *tmp_moh_sound;
	char *muted_sound;
	char *mute_detect_sound;
	char *unmuted_sound;
	char *deaf_sound;
	char *undeaf_sound;
	char *blind_sound;
	char *unblind_sound;
	char *locked_sound;
	char *is_locked_sound;
	char *is_unlocked_sound;
	char *kicked_sound;
	char *join_only_sound;
	char *caller_id_name;
	char *caller_id_number;
	char *sound_prefix;
	char *special_announce;
	char *auto_record;
	int auto_record_canvas;
	char *record_filename;
	char *outcall_templ;
	char *video_layout_conf;
	char *video_layout_name;
	char *video_layout_group;
	char *video_canvas_bgcolor;
	char *video_canvas_bgimg;
	char *video_border_color;
	char *video_super_canvas_bgcolor;
	char *video_letterbox_bgcolor;
	char *video_mute_banner;
	char *no_video_avatar;
	switch_event_t *variables;
	conference_video_mode_t conference_video_mode;
	int video_quality;
	int members_with_video;
	int members_seeing_video;
	int members_with_avatar;
	uint32_t auto_kps_debounce;
	switch_codec_settings_t video_codec_settings;
	uint32_t canvas_width;
	uint32_t canvas_height;
	uint32_t terminate_on_silence;
	uint32_t max_members;
	uint32_t doc_version;
	uint32_t video_border_size;
	char *maxmember_sound;
	uint32_t announce_count;
	char *pin;
	char *mpin;
	char *pin_sound;
	char *bad_pin_sound;
	char *profile_name;
	char *domain;
	char *chat_id;
	char *caller_controls;
	char *moderator_controls;
	switch_live_array_t *la;
	conference_flag_t flags[CFLAG_MAX];
	member_flag_t mflags[MFLAG_MAX];
	switch_call_cause_t bridge_hangup_cause;
	switch_mutex_t *flag_mutex;
	switch_mutex_t *file_mutex;
	uint32_t rate;
	uint32_t interval;
	uint32_t channels;
	switch_mutex_t *mutex;
	conference_member_t *members;
	uint32_t floor_holder;
	uint32_t video_floor_holder;
	uint32_t last_video_floor_holder;
	switch_mutex_t *member_mutex;
	conference_file_node_t *fnode;
	conference_file_node_t *async_fnode;
	switch_memory_pool_t *pool;
	switch_thread_rwlock_t *rwlock;
	uint32_t count;
	int32_t energy_level;
	int32_t auto_energy_level;
	int32_t max_energy_level;
	uint32_t agc_level;
	uint32_t agc_low_energy_level;
	uint32_t agc_margin;
	uint32_t agc_change_factor;
	uint32_t agc_period_len;
	int32_t max_energy_hit_trigger;
	int32_t auto_energy_sec;
	uint32_t burst_mute_count;
	uint8_t min;
	switch_speech_handle_t lsh;
	switch_speech_handle_t *sh;
	switch_byte_t *not_talking_buf;
	uint32_t not_talking_buf_len;
	int pin_retries;
	int broadcast_chat_messages;
	int comfort_noise_level;
	int auto_recording;
	char *recording_metadata;
	int record_count;
	uint32_t min_recording_participants;
	int ivr_dtmf_timeout;
	int ivr_input_timeout;
	uint32_t eflags;
	uint32_t verbose_events;
	int end_count;
	uint32_t count_ghosts;
	/* allow extra time after 'endconf' member leaves */
	switch_time_t endconference_time;
	int endconference_grace_time;

	uint32_t relationship_total;
	uint32_t score;
	int mux_loop_count;
	int member_loop_count;
	switch_time_t run_time;
	char *uuid_str;
	uint32_t originating;
	switch_call_cause_t cancel_cause;
	conference_cdr_node_t *cdr_nodes;
	conference_cdr_reject_t *cdr_rejected;
	switch_time_t start_time;
	switch_time_t end_time;
	char *log_dir;
	cdr_event_mode_t cdr_event_mode;
	struct vid_helper vh[2];
	struct vid_helper mh;
	conference_record_t *rec_node_head;
	int last_speech_channels;
	mcu_canvas_t *canvases[MAX_CANVASES+1];
	uint32_t canvas_count;
	int super_canvas_label_layers;
	int super_canvas_show_all_layers;
	int canvas_running_count;
	switch_mutex_t *canvas_mutex;
	switch_hash_t *layout_hash;
	switch_hash_t *layout_group_hash;
	struct conference_fps video_fps;
	int recording_members;
	uint32_t video_floor_packets;
	video_layout_t *new_personal_vlayout;
	int max_bw_in;
	int force_bw_in;

	/* special use case, scalling shared h264 canvas*/
	int scale_h264_canvas_width;
	int scale_h264_canvas_height;
	int scale_h264_canvas_fps_divisor;
	char *scale_h264_canvas_bandwidth;
	uint32_t moh_wait;
	uint32_t floor_holder_score_iir;
	char *default_layout_name;
	int mux_paused;
} conference_obj_t;

/* Relationship with another member */
typedef struct conference_relationship {
	uint32_t id;
	uint32_t flags;
	struct conference_relationship *next;
} conference_relationship_t;

/* Conference Member Object */
struct conference_member {
	uint32_t id;
	switch_core_session_t *session;
	switch_channel_t *channel;
	conference_obj_t *conference;
	switch_memory_pool_t *pool;
	switch_buffer_t *audio_buffer;
	switch_buffer_t *mux_buffer;
	switch_buffer_t *resample_buffer;
	member_flag_t flags[MFLAG_MAX];
	int32_t score;
	int32_t last_score;
	uint32_t score_iir;
	switch_mutex_t *flag_mutex;
	switch_mutex_t *write_mutex;
	switch_mutex_t *audio_in_mutex;
	switch_mutex_t *audio_out_mutex;
	switch_mutex_t *read_mutex;
	switch_mutex_t *fnode_mutex;
	switch_thread_rwlock_t *rwlock;
	switch_codec_implementation_t read_impl;
	switch_codec_implementation_t orig_read_impl;
	switch_codec_t read_codec;
	switch_codec_t write_codec;
	char *rec_path;
	switch_time_t rec_time;
	conference_record_t *rec;
	uint8_t *frame;
	uint8_t *last_frame;
	uint32_t frame_size;
	uint8_t *mux_frame;
	uint32_t read;
	uint32_t vol_period;
	int32_t energy_level;
	int32_t auto_energy_level;
	int32_t max_energy_level;
	int32_t agc_level;
	uint32_t agc_low_energy_level;
	uint32_t agc_margin;
	uint32_t agc_change_factor;
	uint32_t agc_period_len;
	switch_agc_t *agc;
	uint32_t mute_counter;
	uint32_t burst_mute_count;
	uint32_t score_avg;
	uint32_t max_energy_hits;
	uint32_t max_energy_hit_trigger;
	int32_t volume_in_level;
	int32_t volume_out_level;
	switch_time_t join_time;
	time_t last_talking;
	switch_time_t first_talk_detect;
	uint32_t talk_detects;
	uint32_t auto_energy_track;
	uint32_t talk_track;
	uint32_t score_count;
	uint32_t score_accum;
	uint32_t score_delta_accum;
	uint32_t native_rate;
	uint32_t gate_open;
	uint32_t gate_count;
	uint32_t nogate_count;
	uint32_t talking_count;
	switch_audio_resampler_t *read_resampler;
	int16_t *resample_out;
	uint32_t resample_out_len;
	conference_file_node_t *fnode;
	conference_relationship_t *relationships;
	switch_speech_handle_t lsh;
	switch_speech_handle_t *sh;
	uint32_t verbose_events;
	struct conference_member *next;
	switch_ivr_dmachine_t *dmachine;
	conference_cdr_node_t *cdr_node;
	char *kicked_sound;
	switch_queue_t *dtmf_queue;
	switch_queue_t *video_queue;
	switch_thread_t *video_muxing_write_thread;
	switch_thread_t *video_layer_thread;
	int layer_thread_running;
	switch_thread_t *input_thread;
	switch_thread_cond_t *layer_cond;
	switch_mutex_t *layer_cond_mutex;
	cJSON *json;
	cJSON *status_field;
	uint8_t loop_loop;
	al_handle_t *al;
	int last_speech_channels;
	int video_layer_id;
	int canvas_id;
	int watching_canvas_id;
	int layer_timeout;
	int video_codec_index;
	int video_codec_id;
	char *video_banner_text;
	switch_image_t *video_logo;
	switch_img_position_t logo_pos;
	switch_img_fit_t logo_fit;
	char *video_mute_png;
	char *video_reservation_id;
	char *video_role_id;
	char *video_codec_group;
	switch_vid_params_t vid_params;
	uint32_t auto_kps_debounce_ticks;
	uint32_t layer_loops;
	switch_frame_buffer_t *fb;
	switch_image_t *avatar_png_img;
	switch_image_t *video_mute_img;
	uint32_t floor_packets;
	int blanks;
	int managed_kps;
	int managed_kps_set;
	int blackouts;
	int good_img;
	int auto_avatar;
	int avatar_patched;
	switch_media_flow_t video_media_flow;
	mcu_canvas_t *canvas;
	switch_image_t *pcanvas_img;
	int max_bw_in;
	int force_bw_in;
	int max_bw_out;
	int reset_media;
	int flip;
	int flip_count;

	switch_mutex_t *text_mutex;
	switch_buffer_t *text_buffer;
	char *text_framedata;
	uint32_t text_framesize;

	mcu_layer_cam_opts_t cam_opts;
	switch_core_video_filter_t video_filters;
	int video_manual_border;
};

typedef enum {
	CONF_API_SUB_ARGS_SPLIT,
	CONF_API_SUB_MEMBER_TARGET,
	CONF_API_SUB_ARGS_AS_ONE
} conference_fntype_t;

typedef void (*void_fn_t) (void);

/* API command parser */
typedef struct api_command {
	char *pname;
	void_fn_t pfnapicmd;
	conference_fntype_t fntype;
	char *pcommand;
	char *psyntax;
} api_command_t;

typedef void (*conference_key_callback_t) (conference_member_t *, struct caller_control_actions *);

typedef struct {
	conference_member_t *member;
	caller_control_action_t action;
	conference_key_callback_t handler;
} key_binding_t;

struct _mapping {
	const char *name;
	conference_key_callback_t handler;
};

typedef enum {
	CONF_API_COMMAND_LIST = 0,
	CONF_API_COMMAND_ENERGY,
	CONF_API_COMMAND_VOLUME_IN,
	CONF_API_COMMAND_VOLUME_OUT,
	CONF_API_COMMAND_PLAY,
	CONF_API_COMMAND_SAY,
	CONF_API_COMMAND_SAYMEMBER,
	CONF_API_COMMAND_STOP,
	CONF_API_COMMAND_DTMF,
	CONF_API_COMMAND_KICK,
	CONF_API_COMMAND_MUTE,
	CONF_API_COMMAND_UNMUTE,
	CONF_API_COMMAND_DEAF,
	CONF_API_COMMAND_UNDEAF,
	CONF_API_COMMAND_RELATE,
	CONF_API_COMMAND_LOCK,
	CONF_API_COMMAND_UNLOCK,
	CONF_API_COMMAND_DIAL,
	CONF_API_COMMAND_BGDIAL,
	CONF_API_COMMAND_TRANSFER,
	CONF_API_COMMAND_RECORD,
	CONF_API_COMMAND_NORECORD,
	CONF_API_COMMAND_EXIT_SOUND,
	CONF_API_COMMAND_ENTER_SOUND,
	CONF_API_COMMAND_PIN,
	CONF_API_COMMAND_NOPIN,
	CONF_API_COMMAND_GET,
	CONF_API_COMMAND_SET,
} api_command_type_t;

struct bg_call {
	conference_obj_t *conference;
	switch_core_session_t *session;
	char *bridgeto;
	uint32_t timeout;
	char *flags;
	char *cid_name;
	char *cid_num;
	char *conference_name;
	char *uuid;
	char *profile;
	switch_call_cause_t *cancel_cause;
	switch_event_t *var_event;
	switch_memory_pool_t *pool;
};

/* FUNCTION DEFINITIONS */


switch_bool_t conference_utils_test_flag(conference_obj_t *conference, conference_flag_t flag);
conference_relationship_t *conference_member_get_relationship(conference_member_t *member, conference_member_t *other_member);

uint32_t next_member_id(void);
void conference_utils_set_cflags(const char *flags, conference_flag_t *f);
void conference_utils_set_mflags(const char *flags, member_flag_t *f);
void conference_utils_merge_mflags(member_flag_t *a, member_flag_t *b);
void conference_utils_clear_eflags(char *events, uint32_t *f);
void conference_event_pres_handler(switch_event_t *event);
void conference_data_event_handler(switch_event_t *event);
void conference_event_call_setup_handler(switch_event_t *event);
void conference_member_add_file_data(conference_member_t *member, int16_t *data, switch_size_t file_data_len);
void conference_send_notify(conference_obj_t *conference, const char *status, const char *call_id, switch_bool_t final);
switch_status_t conference_file_close(conference_obj_t *conference, conference_file_node_t *node);
void *SWITCH_THREAD_FUNC conference_record_thread_run(switch_thread_t *thread, void *obj);
switch_status_t conference_close_open_files(conference_obj_t *conference);
void conference_al_gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream);
void conference_al_process(al_handle_t *al, void *data, switch_size_t datalen, int rate);

void conference_utils_member_set_flag_locked(conference_member_t *member, member_flag_t flag);
void conference_utils_member_set_flag(conference_member_t *member, member_flag_t flag);

void conference_member_update_status_field(conference_member_t *member);
void conference_video_vmute_snap(conference_member_t *member, switch_bool_t clear);
void conference_video_reset_video_bitrate_counters(conference_member_t *member);
void conference_video_clear_layer(mcu_layer_t *layer);
int conference_member_get_canvas_id(conference_member_t *member, const char *val, switch_bool_t watching);
void conference_video_reset_member_codec_index(conference_member_t *member);
void conference_video_detach_video_layer(conference_member_t *member);
void conference_utils_set_flag(conference_obj_t *conference, conference_flag_t flag);
void conference_utils_set_flag_locked(conference_obj_t *conference, conference_flag_t flag);
void conference_utils_clear_flag(conference_obj_t *conference, conference_flag_t flag);
void conference_utils_clear_flag_locked(conference_obj_t *conference, conference_flag_t flag);
switch_status_t conference_loop_dmachine_dispatcher(switch_ivr_dmachine_match_t *match);

mcu_layer_t *conference_video_get_layer_locked(conference_member_t *member);
void conference_video_release_layer(mcu_layer_t **layer);
mcu_canvas_t *conference_video_get_canvas_locked(conference_member_t *member);
void conference_video_release_canvas(mcu_canvas_t **canvasP);
switch_status_t conference_video_change_res(conference_obj_t *conference, int w, int h, int id);
int conference_member_setup_media(conference_member_t *member, conference_obj_t *conference);

al_handle_t *conference_al_create(switch_memory_pool_t *pool);
switch_status_t conference_member_parse_position(conference_member_t *member, const char *data);
video_layout_t *conference_video_find_best_layout(conference_obj_t *conference, layout_group_t *lg, uint32_t count, uint32_t file_count);
void conference_list_count_only(conference_obj_t *conference, switch_stream_handle_t *stream);
void conference_member_set_floor_holder(conference_obj_t *conference, conference_member_t *member, uint32_t id);
void conference_utils_member_clear_flag(conference_member_t *member, member_flag_t flag);
void conference_utils_member_clear_flag_locked(conference_member_t *member, member_flag_t flag);
switch_status_t conference_video_attach_video_layer(conference_member_t *member, mcu_canvas_t *canvas, int idx);
int conference_video_set_fps(conference_obj_t *conference, float fps);
void conference_member_set_logo(conference_member_t *member, const char *path);
void conference_video_layer_set_logo(conference_member_t *member, mcu_layer_t *layer);
void conference_video_layer_set_banner(conference_member_t *member, mcu_layer_t *layer, const char *text);
void conference_fnode_seek(conference_file_node_t *fnode, switch_stream_handle_t *stream, char *arg);
uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop);
switch_bool_t conference_utils_member_test_flag(conference_member_t *member, member_flag_t flag);
void conference_list_pretty(conference_obj_t *conference, switch_stream_handle_t *stream);
switch_status_t conference_record_stop(conference_obj_t *conference, switch_stream_handle_t *stream, char *path);
switch_status_t conference_record_action(conference_obj_t *conference, char *path, recording_action_type_t action);
void conference_xlist(conference_obj_t *conference, switch_xml_t x_conference, int off);
void conference_jlist(conference_obj_t *conference, cJSON *json_conferences);
void conference_event_send_json(conference_obj_t *conference);
void conference_event_send_rfc(conference_obj_t *conference);
void conference_member_update_status_field(conference_member_t *member);
void conference_event_la_command_handler(switch_live_array_t *la, const char *cmd, const char *sessid, cJSON *jla, void *user_data);
void conference_event_adv_la(conference_obj_t *conference, conference_member_t *member, switch_bool_t join);
void conference_event_adv_layout(conference_obj_t *conference, mcu_canvas_t *canvas, video_layout_t *vlayout);
switch_status_t conference_video_init_canvas(conference_obj_t *conference, video_layout_t *vlayout, mcu_canvas_t **canvasP);
switch_status_t conference_video_attach_canvas(conference_obj_t *conference, mcu_canvas_t *canvas, int super);
void conference_video_init_canvas_layers(conference_obj_t *conference, mcu_canvas_t *canvas, video_layout_t *vlayout, switch_bool_t force);
switch_status_t conference_video_attach_video_layer(conference_member_t *member, mcu_canvas_t *canvas, int idx);
void conference_video_reset_video_bitrate_counters(conference_member_t *member);
void conference_video_layer_set_banner(conference_member_t *member, mcu_layer_t *layer, const char *text);
void conference_video_detach_video_layer(conference_member_t *member);
void conference_video_check_used_layers(mcu_canvas_t *canvas);
void conference_video_check_flush(conference_member_t *member, switch_bool_t force);
void conference_video_set_canvas_letterbox_bgcolor(mcu_canvas_t *canvas, char *color);
void conference_video_set_canvas_bgcolor(mcu_canvas_t *canvas, char *color);
void conference_video_scale_and_patch(mcu_layer_t *layer, switch_image_t *ximg, switch_bool_t freeze);
void conference_video_reset_layer(mcu_layer_t *layer);
void conference_video_reset_layer_cam(mcu_layer_t *layer);
void conference_video_clear_layer(mcu_layer_t *layer);
void conference_video_reset_image(switch_image_t *img, switch_rgb_color_t *color);
void conference_video_parse_layouts(conference_obj_t *conference, int WIDTH, int HEIGHT);
int conference_video_set_fps(conference_obj_t *conference, float fps);
video_layout_t *conference_video_get_layout(conference_obj_t *conference, const char *video_layout_name, const char *video_layout_group);
void conference_video_check_avatar(conference_member_t *member, switch_bool_t force);
void conference_video_find_floor(conference_member_t *member, switch_bool_t entering);
void conference_video_destroy_canvas(mcu_canvas_t **canvasP);
void conference_video_fnode_check(conference_file_node_t *fnode, int canvas_id);
switch_status_t conference_video_set_canvas_bgimg(mcu_canvas_t *canvas, const char *img_path);
switch_status_t conference_video_set_canvas_fgimg(mcu_canvas_t *canvas, const char *img_path);
switch_status_t conference_al_parse_position(al_handle_t *al, const char *data);
switch_status_t conference_video_thread_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data);
switch_status_t conference_text_thread_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data);
void *SWITCH_THREAD_FUNC conference_video_muxing_write_thread_run(switch_thread_t *thread, void *obj);
void conference_video_launch_layer_thread(conference_member_t *member);
void conference_video_wake_layer_thread(conference_member_t *member);

int conference_member_noise_gate_check(conference_member_t *member);
void conference_member_check_channels(switch_frame_t *frame, conference_member_t *member, switch_bool_t in);

void conference_fnode_toggle_pause(conference_file_node_t *fnode, switch_stream_handle_t *stream);
void conference_fnode_check_status(conference_file_node_t *fnode, switch_stream_handle_t *stream);
void conference_member_set_score_iir(conference_member_t *member, uint32_t score);
// static conference_relationship_t *conference_member_get_relationship(conference_member_t *member, conference_member_t *other_member);
// static void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim);

conference_relationship_t *conference_member_add_relationship(conference_member_t *member, uint32_t id);
conference_member_t *conference_member_get(conference_obj_t *conference, uint32_t id);
conference_member_t *conference_member_get_by_var(conference_obj_t *conference, const char *var, const char *val);
conference_member_t *conference_member_get_by_role(conference_obj_t *conference, const char *role_id);
switch_status_t conference_member_del_relationship(conference_member_t *member, uint32_t id);
switch_status_t conference_member_add(conference_obj_t *conference, conference_member_t *member);
switch_status_t conference_member_del(conference_obj_t *conference, conference_member_t *member);
void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj);
void *SWITCH_THREAD_FUNC conference_video_muxing_thread_run(switch_thread_t *thread, void *obj);
void *SWITCH_THREAD_FUNC conference_video_super_muxing_thread_run(switch_thread_t *thread, void *obj);
void conference_loop_output(conference_member_t *member);
uint32_t conference_file_stop(conference_obj_t *conference, file_stop_t stop);
switch_status_t conference_file_play(conference_obj_t *conference, char *file, uint32_t leadin, switch_channel_t *channel, uint8_t async);
void conference_member_send_all_dtmf(conference_member_t *member, conference_obj_t *conference, const char *dtmf);
switch_status_t conference_say(conference_obj_t *conference, const char *text, uint32_t leadin);
conference_obj_t *conference_find(char *name, char *domain);
void conference_member_bind_controls(conference_member_t *member, const char *controls);
void conference_send_presence(conference_obj_t *conference);
void conference_video_set_floor_holder(conference_obj_t *conference, conference_member_t *member, switch_bool_t force);
void conference_video_canvas_del_fnode_layer(conference_obj_t *conference, conference_file_node_t *fnode);
void conference_video_canvas_set_fnode_layer(mcu_canvas_t *canvas, conference_file_node_t *fnode, int idx);
void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim);
const char *conference_utils_combine_flag_var(switch_core_session_t *session, const char *var_name);
int conference_loop_mapping_len();
void conference_api_set_agc(conference_member_t *member, const char *data);

switch_status_t conference_outcall(conference_obj_t *conference,
								   char *conference_name,
								   switch_core_session_t *session,
								   char *bridgeto, uint32_t timeout,
								   char *flags,
								   char *cid_name,
								   char *cid_num,
								   char *profile,
								   switch_call_cause_t *cause,
								   switch_call_cause_t *cancel_cause, switch_event_t *var_event);
switch_status_t conference_outcall_bg(conference_obj_t *conference,
									  char *conference_name,
									  switch_core_session_t *session, char *bridgeto, uint32_t timeout, const char *flags, const char *cid_name,
									  const char *cid_num, const char *call_uuid, const char *profile, switch_call_cause_t *cancel_cause,
									  switch_event_t **var_event);

void conference_video_launch_muxing_thread(conference_obj_t *conference, mcu_canvas_t *canvas, int super);
void conference_launch_thread(conference_obj_t *conference);
void conference_video_launch_muxing_write_thread(conference_member_t *member);
void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t *thread, void *obj);
switch_status_t conference_file_local_play(conference_obj_t *conference, switch_core_session_t *session, char *path, uint32_t leadin, void *buf,
										   uint32_t buflen);
switch_status_t conference_member_play_file(conference_member_t *member, char *file, uint32_t leadin, switch_bool_t mux);
switch_status_t conference_member_say(conference_member_t *member, char *text, uint32_t leadin);
uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop);
conference_obj_t *conference_new(char *name, conference_xml_cfg_t cfg, switch_core_session_t *session, switch_memory_pool_t *pool);
switch_status_t chat_send(switch_event_t *message_event);


void conference_record_launch_thread(conference_obj_t *conference, char *path, int canvas_id, switch_bool_t autorec);

typedef switch_status_t (*conference_api_args_cmd_t) (conference_obj_t *, switch_stream_handle_t *, int, char **);
typedef switch_status_t (*conference_api_member_cmd_t) (conference_member_t *, switch_stream_handle_t *, void *);
typedef switch_status_t (*conference_api_text_cmd_t) (conference_obj_t *, switch_stream_handle_t *, const char *);

switch_status_t conference_event_add_data(conference_obj_t *conference, switch_event_t *event);
switch_status_t conference_member_add_event_data(conference_member_t *member, switch_event_t *event);

cJSON *conference_cdr_json_render(conference_obj_t *conference, cJSON *req);
char *conference_cdr_rfc4579_render(conference_obj_t *conference, switch_event_t *event, switch_event_t *revent);
void conference_cdr_del(conference_member_t *member);
void conference_cdr_add(conference_member_t *member);
void conference_cdr_rejected(conference_obj_t *conference, switch_channel_t *channel, cdr_reject_reason_t reason);
void conference_cdr_render(conference_obj_t *conference);
void conference_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
void conference_event_la_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
void conference_event_mod_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
void conference_event_chat_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);

void conference_member_itterator(conference_obj_t *conference, switch_stream_handle_t *stream, uint8_t non_mod, conference_api_member_cmd_t pfncallback, void *data);
int conference_video_flush_queue(switch_queue_t *q, int min);

switch_status_t conference_api_sub_mute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_tmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_unmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_vmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_tvmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_unvmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_vblind(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_tvblind(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_unvblind(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_deaf(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_undeaf(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_video_filter(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_floor(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_vid_floor(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_clear_vid_floor(conference_obj_t *conference, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_position(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_conference_video_vmute_snap(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_dtmf(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_pause_play(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_play_status(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_play(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_moh(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_say(conference_obj_t *conference, switch_stream_handle_t *stream, const char *text);
switch_status_t conference_api_sub_dial(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_bgdial(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_auto_position(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_saymember(conference_obj_t *conference, switch_stream_handle_t *stream, const char *text);
switch_status_t conference_api_sub_check_record(conference_obj_t *conference, switch_stream_handle_t *stream, int arc, char **argv);
switch_status_t conference_api_sub_check_record(conference_obj_t *conference, switch_stream_handle_t *stream, int arc, char **argv);
switch_status_t conference_api_sub_volume_in(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_file_seek(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_cam(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_stop(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_hup(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_hold(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_unhold(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_pauserec(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_volume_out(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_lock(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_unlock(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_relate(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_pin(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_exit_sound(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_vid_banner(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_enter_sound(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_set(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_vid_res_id(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_vid_res_id_member(conference_member_t *member, switch_stream_handle_t *stream, char *res_id, int clear, int force);
switch_status_t conference_api_sub_vid_role_id(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_get_uuid(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_get(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_vid_mute_img(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_vid_codec_group(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_vid_logo_img(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_vid_fps(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_vid_res(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_canvas_fgimg(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_canvas_bgimg(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_write_png(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_file_vol(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_recording(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_vid_layout(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_count(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_xml_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_json_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_energy(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_auto_energy(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_agc(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_max_energy(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_watching_canvas(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_canvas(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_layer(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_kick(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_vid_flip(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_vid_border(conference_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conference_api_sub_transfer(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_record(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_norecord(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_vid_bandwidth(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_sub_vid_personal(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conference_api_dispatch(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv, const char *cmdline, int argn);
switch_status_t conference_api_sub_syntax(char **syntax);
switch_status_t conference_api_main_real(const char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream);
switch_status_t conference_api_set_moh(conference_obj_t *conference, const char *what);

void conference_loop_mute_on(conference_member_t *member, caller_control_action_t *action);
void conference_loop_mute_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_energy_dn(conference_member_t *member, caller_control_action_t *action);
void conference_loop_energy_equ_conf(conference_member_t *member, caller_control_action_t *action);
void conference_loop_volume_talk_zero(conference_member_t *member, caller_control_action_t *action);
void conference_loop_volume_talk_up(conference_member_t *member, caller_control_action_t *action);
void conference_loop_volume_listen_dn(conference_member_t *member, caller_control_action_t *action);
void conference_loop_lock_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_volume_listen_up(conference_member_t *member, caller_control_action_t *action);
void conference_loop_volume_listen_zero(conference_member_t *member, caller_control_action_t *action);
void conference_loop_volume_talk_dn(conference_member_t *member, caller_control_action_t *action);
void conference_loop_energy_up(conference_member_t *member, caller_control_action_t *action);
void conference_loop_floor_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_vid_floor_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_energy_up(conference_member_t *member, caller_control_action_t *action);
void conference_loop_floor_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_vid_floor_force(conference_member_t *member, caller_control_action_t *action);
void conference_loop_vmute_off(conference_member_t *member, caller_control_action_t *action);
void conference_loop_conference_video_vmute_snap(conference_member_t *member, caller_control_action_t *action);
void conference_loop_conference_video_vmute_snapoff(conference_member_t *member, caller_control_action_t *action);
void conference_loop_vmute_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_vmute_on(conference_member_t *member, caller_control_action_t *action);
void conference_loop_moh_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_border(conference_member_t *member, caller_control_action_t *action);
void conference_loop_deafmute_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_hangup(conference_member_t *member, caller_control_action_t *action);
void conference_loop_transfer(conference_member_t *member, caller_control_action_t *action);
void conference_loop_mute_off(conference_member_t *member, caller_control_action_t *action);
void conference_loop_event(conference_member_t *member, caller_control_action_t *action);
void conference_loop_transfer(conference_member_t *member, caller_control_action_t *action);
void conference_loop_exec_app(conference_member_t *member, caller_control_action_t *action);
void conference_loop_deaf_toggle(conference_member_t *member, caller_control_action_t *action);
void conference_loop_deaf_on(conference_member_t *member, caller_control_action_t *action);
void conference_loop_deaf_off(conference_member_t *member, caller_control_action_t *action);
void conference_set_variable(conference_obj_t *conference, const char *var, const char *val);
const char *conference_get_variable(conference_obj_t *conference, const char *var);


/* Global Structs */


/* API Interface Function sub-commands */
/* Entries in this list should be kept in sync with the enum above */
extern api_command_t conference_api_sub_commands[];
extern struct _mapping control_mappings[];


#endif /* MOD_CONFERENCE_H */

/* For Emacs:
 * Local Variables:
 * mode:c
 * indent-tabs-mode:t
 * tab-width:4
 * c-basic-offset:4
 * End:
 * For VIM:
 * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
 */