audiohook.h File Reference

Audiohooks Architecture. More...

#include "asterisk/lock.h"
#include "asterisk/linkedlists.h"
#include "asterisk/slinfactory.h"

Include dependency graph for audiohook.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_audiohook
struct	ast_audiohook_options

Macros
#define	ast_audiohook_lock(ah)   ast_mutex_lock(&(ah)->lock)
	Lock an audiohook.
#define	ast_audiohook_unlock(ah)   ast_mutex_unlock(&(ah)->lock)
	Unlock an audiohook.

Typedefs
typedef int(*	ast_audiohook_manipulate_callback) (struct ast_audiohook *audiohook, struct ast_channel *chan, struct ast_frame *frame, enum ast_audiohook_direction direction)
	Callback function for manipulate audiohook type.

Enumerations
enum	ast_audiohook_direction { AST_AUDIOHOOK_DIRECTION_READ = 0 , AST_AUDIOHOOK_DIRECTION_WRITE , AST_AUDIOHOOK_DIRECTION_BOTH }
enum	ast_audiohook_flags {   AST_AUDIOHOOK_TRIGGER_MODE = (3 << 0) , AST_AUDIOHOOK_TRIGGER_READ = (1 << 0) , AST_AUDIOHOOK_TRIGGER_WRITE = (2 << 0) , AST_AUDIOHOOK_WANTS_DTMF = (1 << 2) ,   AST_AUDIOHOOK_TRIGGER_SYNC = (1 << 3) , AST_AUDIOHOOK_SMALL_QUEUE = (1 << 4) , AST_AUDIOHOOK_MUTE_READ = (1 << 5) , AST_AUDIOHOOK_MUTE_WRITE = (1 << 6) ,   AST_AUDIOHOOK_COMPATIBLE = (1 << 7) , AST_AUDIOHOOK_SUBSTITUTE_SILENCE = (1 << 8) }
enum	ast_audiohook_init_flags { AST_AUDIOHOOK_MANIPULATE_ALL_RATES = (1 << 0) }
enum	ast_audiohook_status { AST_AUDIOHOOK_STATUS_NEW = 0 , AST_AUDIOHOOK_STATUS_RUNNING , AST_AUDIOHOOK_STATUS_SHUTDOWN , AST_AUDIOHOOK_STATUS_DONE }
enum	ast_audiohook_type { AST_AUDIOHOOK_TYPE_SPY = 0 , AST_AUDIOHOOK_TYPE_WHISPER , AST_AUDIOHOOK_TYPE_MANIPULATE }

Functions
int	ast_audiohook_attach (struct ast_channel *chan, struct ast_audiohook *audiohook)
	Attach audiohook to channel.
int	ast_audiohook_destroy (struct ast_audiohook *audiohook)
	Destroys an audiohook structure.
int	ast_audiohook_detach (struct ast_audiohook *audiohook)
	Detach audiohook from channel.
void	ast_audiohook_detach_list (struct ast_audiohook_list *audiohook_list)
	Detach audiohooks from list and destroy said list.
int	ast_audiohook_detach_source (struct ast_channel *chan, const char *source)
	Detach specified source audiohook from channel.
int	ast_audiohook_init (struct ast_audiohook *audiohook, enum ast_audiohook_type type, const char *source, enum ast_audiohook_init_flags flags)
	Initialize an audiohook structure.
void	ast_audiohook_move_all (struct ast_channel *old_chan, struct ast_channel *new_chan)
	Move all audiohooks from one channel to another.
void	ast_audiohook_move_by_source (struct ast_channel *old_chan, struct ast_channel *new_chan, const char *source)
	Move an audiohook from one channel to a new one.
struct ast_frame *	ast_audiohook_read_frame (struct ast_audiohook *audiohook, size_t samples, enum ast_audiohook_direction direction, struct ast_format *format)
	Reads a frame in from the audiohook structure.
struct ast_frame *	ast_audiohook_read_frame_all (struct ast_audiohook *audiohook, size_t samples, struct ast_format *format, struct ast_frame **read_frame, struct ast_frame **write_frame)
	Reads a frame in from the audiohook structure in mixed audio mode and copies read and write frame data to provided arguments.
int	ast_audiohook_remove (struct ast_channel *chan, struct ast_audiohook *audiohook)
	Remove an audiohook from a specified channel.
int	ast_audiohook_set_frame_feed_direction (struct ast_audiohook *audiohook, enum ast_audiohook_direction direction)
	Sets direction on audiohook.
int	ast_audiohook_set_mute (struct ast_channel *chan, const char *source, enum ast_audiohook_flags flag, int clear)
	Mute frames read from or written to a channel.
int	ast_audiohook_set_mute_all (struct ast_channel *chan, const char *source, enum ast_audiohook_flags flag, int clear)
	Mute frames read from or written for all audiohooks on a channel.
void	ast_audiohook_trigger_wait (struct ast_audiohook *audiohook)
	Wait for audiohook trigger to be triggered.
void	ast_audiohook_update_status (struct ast_audiohook *audiohook, enum ast_audiohook_status status)
	Update audiohook's status.
int	ast_audiohook_volume_adjust (struct ast_channel *chan, enum ast_audiohook_direction direction, int volume)
	Adjust the volume on frames read from or written to a channel.
int	ast_audiohook_volume_adjust_float (struct ast_channel *chan, enum ast_audiohook_direction direction, float volume)
	Adjust the volume on frames read from or written to a channel.
int	ast_audiohook_volume_get (struct ast_channel *chan, enum ast_audiohook_direction direction)
	Retrieve the volume adjustment value on frames read from or written to a channel.
float	ast_audiohook_volume_get_float (struct ast_channel *chan, enum ast_audiohook_direction direction)
	Retrieve the volume adjustment value on frames read from or written to a channel.
int	ast_audiohook_volume_set (struct ast_channel *chan, enum ast_audiohook_direction direction, int volume)
	Adjust the volume on frames read from or written to a channel.
int	ast_audiohook_volume_set_float (struct ast_channel *chan, enum ast_audiohook_direction direction, float volume)
	Adjust the volume on frames read from or written to a channel.
int	ast_audiohook_write_frame (struct ast_audiohook *audiohook, enum ast_audiohook_direction direction, struct ast_frame *frame)
	Writes a frame into the audiohook structure.
struct ast_frame *	ast_audiohook_write_list (struct ast_channel *chan, struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *frame)
	Pass a frame off to be handled by the audiohook core.
int	ast_audiohook_write_list_empty (struct ast_audiohook_list *audiohook_list)
	Determine if a audiohook_list is empty or not.
int	ast_channel_audiohook_count_by_source (struct ast_channel *chan, const char *source, enum ast_audiohook_type type)
	Find out how many audiohooks from a certain source exist on a given channel, regardless of status.
int	ast_channel_audiohook_count_by_source_running (struct ast_channel *chan, const char *source, enum ast_audiohook_type type)
	Find out how many spies of a certain type exist on a given channel, and are in state running.

Detailed Description

Audiohooks Architecture.

Definition in file audiohook.h.

Macro Definition Documentation

ast_audiohook_lock

#define ast_audiohook_lock

(

ah

)

ast_mutex_lock(&(ah)->lock)

Lock an audiohook.

Parameters

ah	Audiohook structure

Definition at line 313 of file audiohook.h.

ast_audiohook_unlock

#define ast_audiohook_unlock

(

ah

)

ast_mutex_unlock(&(ah)->lock)

Unlock an audiohook.

Parameters

ah	Audiohook structure

Definition at line 318 of file audiohook.h.

Typedef Documentation

ast_audiohook_manipulate_callback

typedef int(* ast_audiohook_manipulate_callback) (struct ast_audiohook *audiohook, struct ast_channel *chan, struct ast_frame *frame, enum ast_audiohook_direction direction)

Callback function for manipulate audiohook type.

Parameters

audiohook
chan
frame	Frame of audio to manipulate
direction	Direction frame came from

Return values

0	on success
-1	on failure

Note

An audiohook does not have any reference to a private data structure for manipulate types. It is up to the manipulate callback to store this data via it's own method. An example would be datastores.

The input frame should never be freed or corrupted during a manipulate callback. If the callback has the potential to corrupt the frame's data during manipulation, local data should be used for the manipulation and only copied to the frame on success.

A failure return value indicates that the frame was not manipulated and that is being returned in its original state.

Definition at line 97 of file audiohook.h.

Enumeration Type Documentation

ast_audiohook_direction

enum ast_audiohook_direction

Enumerator
AST_AUDIOHOOK_DIRECTION_READ	Reading audio in
AST_AUDIOHOOK_DIRECTION_WRITE	Writing audio out
AST_AUDIOHOOK_DIRECTION_BOTH	Both reading audio in and writing audio out

Definition at line 48 of file audiohook.h.

                             {
    AST_AUDIOHOOK_DIRECTION_READ = 0, /*!< Reading audio in */
    AST_AUDIOHOOK_DIRECTION_WRITE,    /*!< Writing audio out */
    AST_AUDIOHOOK_DIRECTION_BOTH,     /*!< Both reading audio in and writing audio out */
};

ast_audiohook_flags

enum ast_audiohook_flags

Enumerator
AST_AUDIOHOOK_TRIGGER_MODE	When audiohook should be triggered to do something
AST_AUDIOHOOK_TRIGGER_READ	Audiohook wants to be triggered when reading audio in
AST_AUDIOHOOK_TRIGGER_WRITE	Audiohook wants to be triggered when writing audio out
AST_AUDIOHOOK_WANTS_DTMF	Audiohook also wants to receive DTMF frames
AST_AUDIOHOOK_TRIGGER_SYNC	Audiohook wants to be triggered when both sides have combined audio available
AST_AUDIOHOOK_SMALL_QUEUE	Audiohooks with this flag set will not allow for a large amount of samples to build up on its slinfactories. We will flush the factories if they contain too many samples.
AST_AUDIOHOOK_MUTE_READ	audiohook should be mute frames read
AST_AUDIOHOOK_MUTE_WRITE	audiohook should be mute frames written
AST_AUDIOHOOK_COMPATIBLE	is the audiohook native slin compatible
AST_AUDIOHOOK_SUBSTITUTE_SILENCE	Substitute silence for missing audio

Definition at line 54 of file audiohook.h.

                         {
    AST_AUDIOHOOK_TRIGGER_MODE  = (3 << 0), /*!< When audiohook should be triggered to do something */
    AST_AUDIOHOOK_TRIGGER_READ  = (1 << 0), /*!< Audiohook wants to be triggered when reading audio in */
    AST_AUDIOHOOK_TRIGGER_WRITE = (2 << 0), /*!< Audiohook wants to be triggered when writing audio out */
    AST_AUDIOHOOK_WANTS_DTMF    = (1 << 2), /*!< Audiohook also wants to receive DTMF frames */
    AST_AUDIOHOOK_TRIGGER_SYNC  = (1 << 3), /*!< Audiohook wants to be triggered when both sides have combined audio available */
    /*! Audiohooks with this flag set will not allow for a large amount of samples to build up on its
     * slinfactories. We will flush the factories if they contain too many samples.
     */
    AST_AUDIOHOOK_SMALL_QUEUE   = (1 << 4),
    AST_AUDIOHOOK_MUTE_READ     = (1 << 5), /*!< audiohook should be mute frames read */
    AST_AUDIOHOOK_MUTE_WRITE    = (1 << 6), /*!< audiohook should be mute frames written */
    AST_AUDIOHOOK_COMPATIBLE    = (1 << 7), /*!< is the audiohook native slin compatible */
 
    AST_AUDIOHOOK_SUBSTITUTE_SILENCE = (1 << 8), /*!< Substitute silence for missing audio */
};

ast_audiohook_init_flags

enum ast_audiohook_init_flags

Enumerator
AST_AUDIOHOOK_MANIPULATE_ALL_RATES	Audiohook manipulate callback is capable of handling slinear at any sample rate. Without enabling this flag on initialization the manipulation callback is guaranteed 8khz audio only.

Definition at line 71 of file audiohook.h.

                              {
    /*! Audiohook manipulate callback is capable of handling slinear at any sample rate.
     * Without enabling this flag on initialization the manipulation callback is guaranteed
     * 8khz audio only. */
    AST_AUDIOHOOK_MANIPULATE_ALL_RATES = (1 << 0),
};

ast_audiohook_status

enum ast_audiohook_status

Enumerator
AST_AUDIOHOOK_STATUS_NEW	Audiohook was just created, not in use yet
AST_AUDIOHOOK_STATUS_RUNNING	Audiohook is running on a channel
AST_AUDIOHOOK_STATUS_SHUTDOWN	Audiohook is being shutdown
AST_AUDIOHOOK_STATUS_DONE	Audiohook has shutdown and is not running on a channel any longer

Definition at line 41 of file audiohook.h.

                          {
    AST_AUDIOHOOK_STATUS_NEW = 0,  /*!< Audiohook was just created, not in use yet */
    AST_AUDIOHOOK_STATUS_RUNNING,  /*!< Audiohook is running on a channel */
    AST_AUDIOHOOK_STATUS_SHUTDOWN, /*!< Audiohook is being shutdown */
    AST_AUDIOHOOK_STATUS_DONE,     /*!< Audiohook has shutdown and is not running on a channel any longer */
};

ast_audiohook_type

enum ast_audiohook_type

Enumerator
AST_AUDIOHOOK_TYPE_SPY	Audiohook wants to receive audio
AST_AUDIOHOOK_TYPE_WHISPER	Audiohook wants to provide audio to be mixed with existing audio
AST_AUDIOHOOK_TYPE_MANIPULATE	Audiohook wants to manipulate the audio

Definition at line 35 of file audiohook.h.

                        {
    AST_AUDIOHOOK_TYPE_SPY = 0,    /*!< Audiohook wants to receive audio */
    AST_AUDIOHOOK_TYPE_WHISPER,    /*!< Audiohook wants to provide audio to be mixed with existing audio */
    AST_AUDIOHOOK_TYPE_MANIPULATE, /*!< Audiohook wants to manipulate the audio */
};

Function Documentation

ast_audiohook_attach()

int ast_audiohook_attach	(	struct ast_channel *	chan,
		struct ast_audiohook *	audiohook
	)

Attach audiohook to channel.

Parameters

chan
audiohook

Returns

0 on success

Return values

-1	on failure

Definition at line 521 of file audiohook.c.

{
    ast_channel_lock(chan);
 
    /* Don't allow an audiohook to be attached to a channel that is already hung up.
     * The hang up process is what actually notifies the audiohook that it should
     * stop.
     */
    if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
        ast_channel_unlock(chan);
        return -1;
    }
 
    if (!ast_channel_audiohooks(chan)) {
        struct ast_audiohook_list *ahlist;
        /* Whoops... allocate a new structure */
        if (!(ahlist = ast_calloc(1, sizeof(*ahlist)))) {
            ast_channel_unlock(chan);
            return -1;
        }
        ast_channel_audiohooks_set(chan, ahlist);
        AST_LIST_HEAD_INIT_NOLOCK(&ast_channel_audiohooks(chan)->spy_list);
        AST_LIST_HEAD_INIT_NOLOCK(&ast_channel_audiohooks(chan)->whisper_list);
        AST_LIST_HEAD_INIT_NOLOCK(&ast_channel_audiohooks(chan)->manipulate_list);
        /* This sample rate will adjust as necessary when writing to the list. */
        ast_channel_audiohooks(chan)->list_internal_samp_rate = DEFAULT_INTERNAL_SAMPLE_RATE;
    }
 
    /* Drop into respective list */
    if (audiohook->type == AST_AUDIOHOOK_TYPE_SPY) {
        AST_LIST_INSERT_TAIL(&ast_channel_audiohooks(chan)->spy_list, audiohook, list);
    } else if (audiohook->type == AST_AUDIOHOOK_TYPE_WHISPER) {
        AST_LIST_INSERT_TAIL(&ast_channel_audiohooks(chan)->whisper_list, audiohook, list);
    } else if (audiohook->type == AST_AUDIOHOOK_TYPE_MANIPULATE) {
        AST_LIST_INSERT_TAIL(&ast_channel_audiohooks(chan)->manipulate_list, audiohook, list);
    }
 
    /*
     * Initialize the audiohook's rate to the default. If it needs to be,
     * it will get updated later.
     */
    audiohook_set_internal_rate(audiohook, DEFAULT_INTERNAL_SAMPLE_RATE, 1);
    audiohook_list_set_samplerate_compatibility(ast_channel_audiohooks(chan));
 
    /* Change status over to running since it is now attached */
    ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_RUNNING);
 
    if (ast_channel_is_bridged(chan)) {
        ast_channel_set_unbridged_nolock(chan, 1);
    }
 
    ast_channel_unlock(chan);
 
    return 0;
}

References AST_AUDIOHOOK_STATUS_RUNNING, AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_audiohook_update_status(), ast_calloc, ast_channel_audiohooks(), ast_channel_audiohooks_set(), ast_channel_flags(), ast_channel_is_bridged(), ast_channel_lock, ast_channel_set_unbridged_nolock(), ast_channel_unlock, AST_FLAG_ZOMBIE, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, ast_test_flag, audiohook_list_set_samplerate_compatibility(), audiohook_set_internal_rate(), DEFAULT_INTERNAL_SAMPLE_RATE, ast_audiohook_list::list_internal_samp_rate, ast_audiohook_list::manipulate_list, ast_audiohook_list::spy_list, ast_audiohook::type, and ast_audiohook_list::whisper_list.

Referenced by audiohook_move(), audiohook_volume_get(), detect_write(), enable_jack_hook(), init_hook(), pitchshift_helper(), scramble_write(), set_talk_detect(), snoop_setup_audiohook(), speex_write(), start_spying(), start_spying(), start_whispering(), start_whispering(), startmon(), and volume_write().

ast_audiohook_destroy()

int ast_audiohook_destroy

(

struct ast_audiohook *

audiohook

)

Destroys an audiohook structure.

Parameters

audiohook

Return values

0	on success
-1	on failure

Definition at line 124 of file audiohook.c.

{
    /* Drop the factories used by this audiohook type */
    switch (audiohook->type) {
    case AST_AUDIOHOOK_TYPE_SPY:
    case AST_AUDIOHOOK_TYPE_WHISPER:
        ast_slinfactory_destroy(&audiohook->read_factory);
        ast_slinfactory_destroy(&audiohook->write_factory);
        break;
    default:
        break;
    }
 
    /* Destroy translation path if present */
    if (audiohook->trans_pvt)
        ast_translator_free_path(audiohook->trans_pvt);
 
    ao2_cleanup(audiohook->format);
 
    /* Lock and trigger be gone! */
    ast_cond_destroy(&audiohook->trigger);
    ast_mutex_destroy(&audiohook->lock);
 
    return 0;
}

References ao2_cleanup, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_cond_destroy, ast_mutex_destroy, ast_slinfactory_destroy(), ast_translator_free_path(), ast_audiohook::format, ast_audiohook::lock, ast_audiohook::read_factory, ast_audiohook::trans_pvt, ast_audiohook::trigger, ast_audiohook::type, and ast_audiohook::write_factory.

Referenced by audiohook_volume_destroy(), channel_spy(), datastore_destroy_cb(), destroy_callback(), destroy_callback(), destroy_callback(), destroy_callback(), destroy_callback(), destroy_jack_data(), destroy_monitor_audiohook(), hook_datastore_destroy_callback(), launch_monitor_thread(), multi_autochan_free(), and snoop_destroy().

ast_audiohook_detach()

int ast_audiohook_detach

(

struct ast_audiohook *

audiohook

)

Detach audiohook from channel.

Parameters

audiohook

Returns

Returns 0 on success, -1 on failure

Definition at line 587 of file audiohook.c.

{
    if (audiohook->status == AST_AUDIOHOOK_STATUS_NEW || audiohook->status == AST_AUDIOHOOK_STATUS_DONE) {
        return 0;
    }
 
    ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_SHUTDOWN);
 
    while (audiohook->status != AST_AUDIOHOOK_STATUS_DONE) {
        ast_audiohook_trigger_wait(audiohook);
    }
 
    return 0;
}

References AST_AUDIOHOOK_STATUS_DONE, AST_AUDIOHOOK_STATUS_NEW, AST_AUDIOHOOK_STATUS_SHUTDOWN, ast_audiohook_trigger_wait(), ast_audiohook_update_status(), and ast_audiohook::status.

Referenced by channel_spy(), destroy_callback(), destroy_callback(), destroy_callback(), destroy_monitor_audiohook(), disable_jack_hook(), hook_datastore_destroy_callback(), multi_autochan_free(), snoop_hangup(), and speex_write().

ast_audiohook_detach_list()

void ast_audiohook_detach_list

(

struct ast_audiohook_list *

audiohook_list

)

Detach audiohooks from list and destroy said list.

Parameters

audiohook_list

List of audiohooks (NULL tolerant)

Definition at line 602 of file audiohook.c.

{
    int i;
    struct ast_audiohook *audiohook;
 
    if (!audiohook_list) {
        return;
    }
 
    /* Drop any spies */
    while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->spy_list, list))) {
        ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_DONE);
    }
 
    /* Drop any whispering sources */
    while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->whisper_list, list))) {
        ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_DONE);
    }
 
    /* Drop any manipulators */
    while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->manipulate_list, list))) {
        ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_DONE);
        audiohook->manipulate_callback(audiohook, NULL, NULL, 0);
    }
 
    /* Drop translation paths if present */
    for (i = 0; i < 2; i++) {
        if (audiohook_list->in_translate[i].trans_pvt) {
            ast_translator_free_path(audiohook_list->in_translate[i].trans_pvt);
            ao2_cleanup(audiohook_list->in_translate[i].format);
        }
        if (audiohook_list->out_translate[i].trans_pvt) {
            ast_translator_free_path(audiohook_list->out_translate[i].trans_pvt);
            ao2_cleanup(audiohook_list->out_translate[i].format);
        }
    }
 
    /* Free ourselves */
    ast_free(audiohook_list);
}

References ao2_cleanup, AST_AUDIOHOOK_STATUS_DONE, ast_audiohook_update_status(), ast_free, AST_LIST_REMOVE_HEAD, ast_translator_free_path(), ast_audiohook_translate::format, ast_audiohook_list::in_translate, ast_audiohook::list, ast_audiohook::manipulate_callback, ast_audiohook_list::manipulate_list, NULL, ast_audiohook_list::out_translate, ast_audiohook_list::spy_list, ast_audiohook_translate::trans_pvt, and ast_audiohook_list::whisper_list.

Referenced by __ast_read(), ast_write_stream(), and destroy_hooks().

ast_audiohook_detach_source()

int ast_audiohook_detach_source	(	struct ast_channel *	chan,
		const char *	source
	)

Detach specified source audiohook from channel.

Parameters

chan	Channel to detach from
source	Name of source to detach

Return values

0	on success
-1	on failure

Note

The channel does not need to be locked before calling this function.

Definition at line 735 of file audiohook.c.

{
    struct ast_audiohook *audiohook = NULL;
 
    ast_channel_lock(chan);
 
    /* Ensure the channel has audiohooks on it */
    if (!ast_channel_audiohooks(chan)) {
        ast_channel_unlock(chan);
        return -1;
    }
 
    audiohook = find_audiohook_by_source(ast_channel_audiohooks(chan), source);
 
    ast_channel_unlock(chan);
 
    if (audiohook && audiohook->status != AST_AUDIOHOOK_STATUS_DONE) {
        ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_SHUTDOWN);
    }
 
    return (audiohook ? 0 : -1);
}

References AST_AUDIOHOOK_STATUS_DONE, AST_AUDIOHOOK_STATUS_SHUTDOWN, ast_audiohook_update_status(), ast_channel_audiohooks(), ast_channel_lock, ast_channel_unlock, find_audiohook_by_source(), NULL, ast_audiohook::source, and ast_audiohook::status.

ast_audiohook_init()

int ast_audiohook_init	(	struct ast_audiohook *	audiohook,
		enum ast_audiohook_type	type,
		const char *	source,
		enum ast_audiohook_init_flags	flags
	)

Initialize an audiohook structure.

Parameters

audiohook
type	Type of audiohook to initialize this as
source	Who is initializing this audiohook
flags

Return values

0	on success
-1	on failure

Definition at line 100 of file audiohook.c.

{
    /* Need to keep the type and source */
    audiohook->type = type;
    audiohook->source = source;
 
    /* Initialize lock that protects our audiohook */
    ast_mutex_init(&audiohook->lock);
    ast_cond_init(&audiohook->trigger, NULL);
 
    audiohook->init_flags = init_flags;
 
    /* Set direction to BOTH so that we feed frames in both directions */
    audiohook->direction = AST_AUDIOHOOK_DIRECTION_BOTH;
 
    /* initialize internal rate at 8khz, this will adjust if necessary */
    audiohook_set_internal_rate(audiohook, DEFAULT_INTERNAL_SAMPLE_RATE, 0);
 
    /* Since we are just starting out... this audiohook is new */
    ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_NEW);
 
    return 0;
}

References AST_AUDIOHOOK_DIRECTION_BOTH, AST_AUDIOHOOK_STATUS_NEW, ast_audiohook_update_status(), ast_cond_init, ast_mutex_init, audiohook_set_internal_rate(), DEFAULT_INTERNAL_SAMPLE_RATE, ast_audiohook::direction, ast_audiohook::init_flags, ast_audiohook::lock, NULL, ast_audiohook::source, ast_audiohook::trigger, type, and ast_audiohook::type.

Referenced by attach_barge(), attach_barge(), audiohook_volume_get(), channel_spy(), detect_write(), do_broadcast(), enable_jack_hook(), hook_state_alloc(), launch_monitor_thread(), pitchshift_helper(), scramble_write(), set_talk_detect(), snoop_setup_audiohook(), speex_write(), and volume_write().

ast_audiohook_move_all()

void ast_audiohook_move_all	(	struct ast_channel *	old_chan,
		struct ast_channel *	new_chan
	)

Move all audiohooks from one channel to another.

Note

It is required that both old_chan and new_chan are locked prior to calling this function. Besides needing to protect the data within the channels, not locking these channels can lead to a potential deadlock.

Parameters

old_chan	The source of the audiohooks being moved
new_chan	The destination channel for the audiohooks to be moved to

Definition at line 709 of file audiohook.c.

{
    struct ast_audiohook *audiohook;
    struct ast_audiohook_list *audiohook_list;
 
    audiohook_list = ast_channel_audiohooks(old_chan);
    if (!audiohook_list) {
        return;
    }
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->spy_list, audiohook, list) {
        audiohook_move(old_chan, new_chan, audiohook);
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->whisper_list, audiohook, list) {
        audiohook_move(old_chan, new_chan, audiohook);
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->manipulate_list, audiohook, list) {
        audiohook_move(old_chan, new_chan, audiohook);
    }
    AST_LIST_TRAVERSE_SAFE_END;
}

References ast_channel_audiohooks(), AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, audiohook_move(), ast_audiohook_list::manipulate_list, ast_audiohook_list::spy_list, and ast_audiohook_list::whisper_list.

Referenced by channel_do_masquerade().

ast_audiohook_move_by_source()

void ast_audiohook_move_by_source	(	struct ast_channel *	old_chan,
		struct ast_channel *	new_chan,
		const char *	source
	)

Move an audiohook from one channel to a new one.

Todo:

Currently only the first audiohook of a specific source found will be moved. We should add the capability to move multiple audiohooks from a single source as well.

Note

It is required that both old_chan and new_chan are locked prior to calling this function. Besides needing to protect the data within the channels, not locking these channels can lead to a potential deadlock

Parameters

old_chan	The source of the audiohook to move
new_chan	The destination to which we want the audiohook to move
source	The source of the audiohook we want to move

Definition at line 693 of file audiohook.c.

{
    struct ast_audiohook *audiohook;
 
    if (!ast_channel_audiohooks(old_chan)) {
        return;
    }
 
    audiohook = find_audiohook_by_source(ast_channel_audiohooks(old_chan), source);
    if (!audiohook) {
        return;
    }
 
    audiohook_move(old_chan, new_chan, audiohook);
}

References ast_channel_audiohooks(), audiohook_move(), find_audiohook_by_source(), and ast_audiohook::source.

ast_audiohook_read_frame()

struct ast_frame * ast_audiohook_read_frame	(	struct ast_audiohook *	audiohook,
		size_t	samples,
		enum ast_audiohook_direction	direction,
		struct ast_format *	format
	)

Reads a frame in from the audiohook structure.

Parameters

audiohook
samples	Number of samples wanted
direction	Direction the audio frame came from
format	Format of frame remote side wants back

Returns

frame on success

Return values

NULL	on failure

Definition at line 483 of file audiohook.c.

{
    return audiohook_read_frame_helper(audiohook, samples, direction, format, NULL, NULL);
}

References audiohook_read_frame_helper(), NULL, and ast_frame::samples.

Referenced by snoop_read(), spy_generate(), and spy_generate().

ast_audiohook_read_frame_all()

struct ast_frame * ast_audiohook_read_frame_all	(	struct ast_audiohook *	audiohook,
		size_t	samples,
		struct ast_format *	format,
		struct ast_frame **	read_frame,
		struct ast_frame **	write_frame
	)

Reads a frame in from the audiohook structure in mixed audio mode and copies read and write frame data to provided arguments.

Parameters

audiohook
samples	Number of samples wanted
format	Format of frame remote side wants back
read_frame	if available, we'll copy the read buffer to this.
write_frame	if available, we'll copy the write buffer to this.

Returns

frame on success

Return values

NULL	on failure

Definition at line 488 of file audiohook.c.

{
    return audiohook_read_frame_helper(audiohook, samples, AST_AUDIOHOOK_DIRECTION_BOTH, format, read_frame, write_frame);
}

References AST_AUDIOHOOK_DIRECTION_BOTH, audiohook_read_frame_helper(), read_frame(), and ast_frame::samples.

Referenced by mixmonitor_thread(), and spy_generate().

ast_audiohook_remove()

int ast_audiohook_remove	(	struct ast_channel *	chan,
		struct ast_audiohook *	audiohook
	)

Remove an audiohook from a specified channel.

Parameters

chan	Channel to remove from
audiohook	Audiohook to remove

Return values

0	on success
-1	on failure

Note

The channel does not need to be locked before calling this function

Definition at line 758 of file audiohook.c.

{
    ast_channel_lock(chan);
 
    if (!ast_channel_audiohooks(chan)) {
        ast_channel_unlock(chan);
        return -1;
    }
 
    if (audiohook->type == AST_AUDIOHOOK_TYPE_SPY) {
        AST_LIST_REMOVE(&ast_channel_audiohooks(chan)->spy_list, audiohook, list);
    } else if (audiohook->type == AST_AUDIOHOOK_TYPE_WHISPER) {
        AST_LIST_REMOVE(&ast_channel_audiohooks(chan)->whisper_list, audiohook, list);
    } else if (audiohook->type == AST_AUDIOHOOK_TYPE_MANIPULATE) {
        AST_LIST_REMOVE(&ast_channel_audiohooks(chan)->manipulate_list, audiohook, list);
    }
 
    audiohook_list_set_samplerate_compatibility(ast_channel_audiohooks(chan));
    ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_DONE);
 
    if (ast_channel_is_bridged(chan)) {
        ast_channel_set_unbridged_nolock(chan, 1);
    }
 
    ast_channel_unlock(chan);
 
    return 0;
}

References AST_AUDIOHOOK_STATUS_DONE, AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_audiohook_update_status(), ast_channel_audiohooks(), ast_channel_is_bridged(), ast_channel_lock, ast_channel_set_unbridged_nolock(), ast_channel_unlock, AST_LIST_REMOVE, audiohook_list_set_samplerate_compatibility(), ast_audiohook::list, and ast_audiohook::type.

Referenced by audiohook_move(), remove_detect(), remove_scrambler(), remove_talk_detect(), and speex_write().

ast_audiohook_set_frame_feed_direction()

int ast_audiohook_set_frame_feed_direction	(	struct ast_audiohook *	audiohook,
		enum ast_audiohook_direction	direction
	)

Sets direction on audiohook.

Parameters

audiohook
direction	In which direction should the audiohook feed frames, ie if we are snooping 'in', set direction to READ so that only the 'in' frames are fed to the slin factory

Return values

0	on success
-1	on failure due to audiohook already in use or in shutdown. Can only set direction on NEW audiohooks

Definition at line 150 of file audiohook.c.

{
    /* Only set the direction on new audiohooks */
    if (audiohook->status != AST_AUDIOHOOK_STATUS_NEW) {
        ast_debug(3, "Can not set direction on attached Audiohook %p\n", audiohook);
        return -1;
    }
 
    audiohook->direction = direction;
    return 0;
}

References AST_AUDIOHOOK_STATUS_NEW, ast_debug, ast_audiohook::direction, and ast_audiohook::status.

Referenced by snoop_setup_audiohook(), start_spying(), and start_spying().

ast_audiohook_set_mute()

int ast_audiohook_set_mute	(	struct ast_channel *	chan,
		const char *	source,
		enum ast_audiohook_flags	flag,
		int	clear
	)

Mute frames read from or written to a channel.

Parameters

chan	Channel to muck with
source	Type of audiohook
flag	which direction to set / clear
clear	set or clear muted frames on direction based on flag parameter

Return values

0	success
-1	failure

Definition at line 1405 of file audiohook.c.

{
    struct ast_audiohook *audiohook = NULL;
 
    ast_channel_lock(chan);
 
    /* Ensure the channel has audiohooks on it */
    if (!ast_channel_audiohooks(chan)) {
        ast_channel_unlock(chan);
        return -1;
    }
 
    audiohook = find_audiohook_by_source(ast_channel_audiohooks(chan), source);
 
    if (audiohook) {
        if (clear) {
            ast_clear_flag(audiohook, flag);
        } else {
            ast_set_flag(audiohook, flag);
        }
    }
 
    ast_channel_unlock(chan);
 
    return (audiohook ? 0 : -1);
}

References ast_channel_audiohooks(), ast_channel_lock, ast_channel_unlock, ast_clear_flag, ast_set_flag, find_audiohook_by_source(), NULL, and ast_audiohook::source.

ast_audiohook_set_mute_all()

int ast_audiohook_set_mute_all	(	struct ast_channel *	chan,
		const char *	source,
		enum ast_audiohook_flags	flag,
		int	clear
	)

Mute frames read from or written for all audiohooks on a channel.

Parameters

chan	Channel to muck with
source	Type of audiohooks
flag	which direction to set / clear
clear	set or clear muted frames on direction based on flag parameter

Return values

>=0	number of muted audiohooks
-1	failure

Definition at line 1432 of file audiohook.c.

{
    struct ast_audiohook *audiohook = NULL;
    int count = 0;
 
    ast_channel_lock(chan);
 
    if (!ast_channel_audiohooks(chan)) {
        ast_channel_unlock(chan);
        return -1;
    }
 
    AST_LIST_TRAVERSE(&ast_channel_audiohooks(chan)->spy_list, audiohook, list) {
        if (!strcasecmp(audiohook->source, source)) {
            count++;
            if (clearmute) {
                ast_clear_flag(audiohook, flag);
            } else {
                ast_set_flag(audiohook, flag);
            }
        }
    }
 
    ast_test_suite_event_notify("AUDIOHOOK_GROUP_MUTE_TOGGLE", "Channel: %s\r\nSource: %s\r\nCount: %d\r\n",
                                    ast_channel_name(chan), source, count);
 
    ast_channel_unlock(chan);
 
    return count;
}

References ast_channel_audiohooks(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_clear_flag, AST_LIST_TRAVERSE, ast_set_flag, ast_test_suite_event_notify, ast_audiohook::list, NULL, and ast_audiohook::source.

Referenced by manager_mute_mixmonitor().

ast_audiohook_trigger_wait()

void ast_audiohook_trigger_wait

(

struct ast_audiohook *

audiohook

)

Wait for audiohook trigger to be triggered.

Parameters

audiohook

Audiohook to wait on

Definition at line 1131 of file audiohook.c.

{
    struct timeval wait;
    struct timespec ts;
 
    wait = ast_tvadd(ast_tvnow(), ast_samp2tv(50000, 1000));
    ts.tv_sec = wait.tv_sec;
    ts.tv_nsec = wait.tv_usec * 1000;
 
    ast_cond_timedwait(&audiohook->trigger, &audiohook->lock, &ts);
 
    return;
}

References ast_cond_timedwait, ast_samp2tv(), ast_tvadd(), ast_tvnow(), ast_audiohook::lock, and ast_audiohook::trigger.

Referenced by ast_audiohook_detach(), and mixmonitor_thread().

ast_audiohook_update_status()

void ast_audiohook_update_status	(	struct ast_audiohook *	audiohook,
		enum ast_audiohook_status	status
	)

Update audiohook's status.

Parameters

audiohook
status

Note

once status is updated to DONE, this function can not be used to set the status back to any other setting. Setting DONE effectively locks the status as such.

Definition at line 577 of file audiohook.c.

{
    ast_audiohook_lock(audiohook);
    if (audiohook->status != AST_AUDIOHOOK_STATUS_DONE) {
        audiohook->status = status;
        ast_cond_signal(&audiohook->trigger);
    }
    ast_audiohook_unlock(audiohook);
}

References ast_audiohook_lock, AST_AUDIOHOOK_STATUS_DONE, ast_audiohook_unlock, ast_cond_signal, status, ast_audiohook::status, and ast_audiohook::trigger.

Referenced by ast_audiohook_attach(), ast_audiohook_detach(), ast_audiohook_detach_list(), ast_audiohook_detach_source(), ast_audiohook_init(), ast_audiohook_remove(), audio_audiohook_write_list(), dtmf_audiohook_write_list(), and stop_mixmonitor_full().

ast_audiohook_volume_adjust()

int ast_audiohook_volume_adjust	(	struct ast_channel *	chan,
		enum ast_audiohook_direction	direction,
		int	volume
	)

Adjust the volume on frames read from or written to a channel.

Parameters

chan	Channel to muck with
direction	Direction to increase
volume	Value to adjust the adjustment by

Return values

0	on success
-1	on failure

Since

1.6.1

Definition at line 1380 of file audiohook.c.

{
    return ast_audiohook_volume_adjust_float(chan, direction, (float) volume);
}

References ast_audiohook_volume_adjust_float().

Referenced by execute_menu_entry().

ast_audiohook_volume_adjust_float()

int ast_audiohook_volume_adjust_float	(	struct ast_channel *	chan,
		enum ast_audiohook_direction	direction,
		float	volume
	)

Adjust the volume on frames read from or written to a channel.

Parameters

chan	Channel to muck with
direction	Direction to increase
volume	Value to adjust the adjustment by

Return values

0	on success
-1	on failure

Definition at line 1385 of file audiohook.c.

{
    struct audiohook_volume *audiohook_volume = NULL;
 
    /* Attempt to find the audiohook volume information, and create an audiohook if none exists */
    if (!(audiohook_volume = audiohook_volume_get(chan, 1))) {
        return -1;
    }
 
    /* Based on the direction change the specific adjustment value */
    if (direction == AST_AUDIOHOOK_DIRECTION_READ || direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
        audiohook_volume->read_adjustment += volume;
    }
    if (direction == AST_AUDIOHOOK_DIRECTION_WRITE || direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
        audiohook_volume->write_adjustment += volume;
    }
 
    return 0;
}

References AST_AUDIOHOOK_DIRECTION_BOTH, AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, audiohook_volume_get(), NULL, audiohook_volume::read_adjustment, and audiohook_volume::write_adjustment.

Referenced by ast_audiohook_volume_adjust(), and ast_audiohook_volume_set().

ast_audiohook_volume_get()

int ast_audiohook_volume_get	(	struct ast_channel *	chan,
		enum ast_audiohook_direction	direction
	)

Retrieve the volume adjustment value on frames read from or written to a channel.

Parameters

chan	Channel to retrieve volume adjustment from
direction	Direction to retrieve

Returns

adjustment value

Since

1.6.1

Definition at line 1355 of file audiohook.c.

{
    return (int) ast_audiohook_volume_get_float(chan, direction);
}

References ast_audiohook_volume_get_float().

Referenced by confbridge_exec().

ast_audiohook_volume_get_float()

float ast_audiohook_volume_get_float	(	struct ast_channel *	chan,
		enum ast_audiohook_direction	direction
	)

Retrieve the volume adjustment value on frames read from or written to a channel.

Parameters

chan	Channel to retrieve volume adjustment from
direction	Direction to retrieve

Returns

adjustment value

Definition at line 1360 of file audiohook.c.

{
    struct audiohook_volume *audiohook_volume = NULL;
    float adjustment = 0;
 
    /* Attempt to find the audiohook volume information, but do not create it as we only want to look at the values */
    if (!(audiohook_volume = audiohook_volume_get(chan, 0))) {
        return 0;
    }
 
    /* Grab the adjustment value based on direction given */
    if (direction == AST_AUDIOHOOK_DIRECTION_READ) {
        adjustment = audiohook_volume->read_adjustment;
    } else if (direction == AST_AUDIOHOOK_DIRECTION_WRITE) {
        adjustment = audiohook_volume->write_adjustment;
    }
 
    return adjustment;
}

References AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, audiohook_volume_get(), NULL, audiohook_volume::read_adjustment, and audiohook_volume::write_adjustment.

Referenced by ast_audiohook_volume_get().

ast_audiohook_volume_set()

int ast_audiohook_volume_set	(	struct ast_channel *	chan,
		enum ast_audiohook_direction	direction,
		int	volume
	)

Adjust the volume on frames read from or written to a channel.

Parameters

chan	Channel to muck with
direction	Direction to set on
volume	Value to adjust the volume by

Return values

0	on success
-1	on failure

Since

1.6.1

Definition at line 1330 of file audiohook.c.

{
    return ast_audiohook_volume_adjust_float(chan, direction, (float) volume);
}

References ast_audiohook_volume_adjust_float().

Referenced by confbridge_exec(), and execute_menu_entry().

ast_audiohook_volume_set_float()

int ast_audiohook_volume_set_float	(	struct ast_channel *	chan,
		enum ast_audiohook_direction	direction,
		float	volume
	)

Adjust the volume on frames read from or written to a channel.

Parameters

chan	Channel to muck with
direction	Direction to set on
volume	Value to adjust the volume by

Return values

0	on success
-1	on failure

Definition at line 1335 of file audiohook.c.

{
    struct audiohook_volume *audiohook_volume = NULL;
 
    /* Attempt to find the audiohook volume information, but only create it if we are not setting the adjustment value to zero */
    if (!(audiohook_volume = audiohook_volume_get(chan, (volume ? 1 : 0)))) {
        return -1;
    }
 
    /* Now based on the direction set the proper value */
    if (direction == AST_AUDIOHOOK_DIRECTION_READ || direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
        audiohook_volume->read_adjustment = volume;
    }
    if (direction == AST_AUDIOHOOK_DIRECTION_WRITE || direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
        audiohook_volume->write_adjustment = volume;
    }
 
    return 0;
}

References AST_AUDIOHOOK_DIRECTION_BOTH, AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, audiohook_volume_get(), NULL, audiohook_volume::read_adjustment, and audiohook_volume::write_adjustment.

ast_audiohook_write_frame()

int ast_audiohook_write_frame	(	struct ast_audiohook *	audiohook,
		enum ast_audiohook_direction	direction,
		struct ast_frame *	frame
	)

Writes a frame into the audiohook structure.

Parameters

audiohook
direction	Direction the audio frame came from
frame	Frame to write in

Return values

0	on success
-1	on failure

Definition at line 167 of file audiohook.c.

{
    struct ast_slinfactory *factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_factory : &audiohook->write_factory);
    struct ast_slinfactory *other_factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->write_factory : &audiohook->read_factory);
    struct timeval *rwtime = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_time : &audiohook->write_time), previous_time = *rwtime;
    int our_factory_samples;
    int our_factory_ms;
    int other_factory_samples;
    int other_factory_ms;
 
    /* Don't feed the frame if we are set to read and this is a write frame or if set to
       write and this is a read frame as we don't want it. Plus, it can cause mis-resampling
       if the READ and WRITE frames have different bitrates */
    if (audiohook->direction != AST_AUDIOHOOK_DIRECTION_BOTH && audiohook->direction != direction) {
        return 0;
    }
 
    /* Update last feeding time to be current */
    *rwtime = ast_tvnow();
 
    our_factory_samples = ast_slinfactory_available(factory);
    our_factory_ms = ast_tvdiff_ms(*rwtime, previous_time) + (our_factory_samples / (audiohook->hook_internal_samp_rate / 1000));
    other_factory_samples = ast_slinfactory_available(other_factory);
    other_factory_ms = other_factory_samples / (audiohook->hook_internal_samp_rate / 1000);
 
    if (ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_SYNC) && (our_factory_ms - other_factory_ms > AST_AUDIOHOOK_SYNC_TOLERANCE)) {
        ast_debug(4, "Flushing audiohook %p so it remains in sync\n", audiohook);
        ast_slinfactory_flush(factory);
        ast_slinfactory_flush(other_factory);
    }
 
    if (ast_test_flag(audiohook, AST_AUDIOHOOK_SMALL_QUEUE) && ((our_factory_ms > AST_AUDIOHOOK_SMALL_QUEUE_TOLERANCE) || (other_factory_ms > AST_AUDIOHOOK_SMALL_QUEUE_TOLERANCE))) {
        ast_debug(4, "Audiohook %p has stale audio in its factories. Flushing them both\n", audiohook);
        ast_slinfactory_flush(factory);
        ast_slinfactory_flush(other_factory);
    } else if ((our_factory_ms > AST_AUDIOHOOK_LONG_QUEUE_TOLERANCE) || (other_factory_ms > AST_AUDIOHOOK_LONG_QUEUE_TOLERANCE)) {
        ast_debug(4, "Audiohook %p has stale audio in its factories. Flushing them both\n", audiohook);
        ast_slinfactory_flush(factory);
        ast_slinfactory_flush(other_factory);
    }
 
    /* Write frame out to respective factory */
    ast_slinfactory_feed(factory, frame);
 
    /* If we need to notify the respective handler of this audiohook, do so */
    if ((ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_MODE) == AST_AUDIOHOOK_TRIGGER_READ) && (direction == AST_AUDIOHOOK_DIRECTION_READ)) {
        ast_cond_signal(&audiohook->trigger);
    } else if ((ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_MODE) == AST_AUDIOHOOK_TRIGGER_WRITE) && (direction == AST_AUDIOHOOK_DIRECTION_WRITE)) {
        ast_cond_signal(&audiohook->trigger);
    } else if (ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_SYNC)) {
        ast_cond_signal(&audiohook->trigger);
    }
 
    return 0;
}

References AST_AUDIOHOOK_DIRECTION_BOTH, AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, AST_AUDIOHOOK_LONG_QUEUE_TOLERANCE, AST_AUDIOHOOK_SMALL_QUEUE, AST_AUDIOHOOK_SMALL_QUEUE_TOLERANCE, AST_AUDIOHOOK_SYNC_TOLERANCE, AST_AUDIOHOOK_TRIGGER_MODE, AST_AUDIOHOOK_TRIGGER_READ, AST_AUDIOHOOK_TRIGGER_SYNC, AST_AUDIOHOOK_TRIGGER_WRITE, ast_cond_signal, ast_debug, ast_slinfactory_available(), ast_slinfactory_feed(), ast_slinfactory_flush(), ast_test_flag, ast_tvdiff_ms(), ast_tvnow(), ast_audiohook::direction, ast_audiohook::hook_internal_samp_rate, ast_audiohook::read_factory, ast_audiohook::read_time, ast_audiohook::trigger, ast_audiohook::write_factory, and ast_audiohook::write_time.

Referenced by audio_audiohook_write_list(), channel_spy(), do_broadcast(), and snoop_write().

ast_audiohook_write_list()

struct ast_frame * ast_audiohook_write_list	(	struct ast_channel *	chan,
		struct ast_audiohook_list *	audiohook_list,
		enum ast_audiohook_direction	direction,
		struct ast_frame *	frame
	)

Pass a frame off to be handled by the audiohook core.

Parameters

chan	Channel that the list is coming off of
audiohook_list	List of audiohooks
direction	Direction frame is coming in from
frame	The frame itself

Returns

frame on success

Return values

NULL	on failure

Definition at line 1116 of file audiohook.c.

{
    /* Pass off frame to it's respective list write function */
    if (frame->frametype == AST_FRAME_VOICE) {
        return audio_audiohook_write_list(chan, audiohook_list, direction, frame);
    } else if (frame->frametype == AST_FRAME_DTMF) {
        return dtmf_audiohook_write_list(chan, audiohook_list, direction, frame);
    } else {
        return frame;
    }
}

References AST_FRAME_DTMF, AST_FRAME_VOICE, audio_audiohook_write_list(), dtmf_audiohook_write_list(), and ast_frame::frametype.

Referenced by __ast_read(), and ast_write_stream().

ast_audiohook_write_list_empty()

int ast_audiohook_write_list_empty

(

struct ast_audiohook_list *

audiohook_list

)

Determine if a audiohook_list is empty or not.

Parameters

audiohook_list

Audiohook to check. (NULL also means empty)

Return values

0	false
1	true

Definition at line 1108 of file audiohook.c.

{
    return !audiohook_list
        || (AST_LIST_EMPTY(&audiohook_list->spy_list)
            && AST_LIST_EMPTY(&audiohook_list->whisper_list)
            && AST_LIST_EMPTY(&audiohook_list->manipulate_list));
}

References AST_LIST_EMPTY, ast_audiohook_list::manipulate_list, ast_audiohook_list::spy_list, and ast_audiohook_list::whisper_list.

Referenced by __ast_read(), ast_channel_has_audio_frame_or_monitor(), ast_channel_has_hook_requiring_audio(), and ast_write_stream().

ast_channel_audiohook_count_by_source()

int ast_channel_audiohook_count_by_source	(	struct ast_channel *	chan,
		const char *	source,
		enum ast_audiohook_type	type
	)

Find out how many audiohooks from a certain source exist on a given channel, regardless of status.

Parameters

chan	The channel on which to find the spies
source	The audiohook's source
type	The type of audiohook

Returns

number of audiohooks which are from the source specified

Note: Function performs nlocking.

Definition at line 1146 of file audiohook.c.

{
    int count = 0;
    struct ast_audiohook *ah = NULL;
 
    if (!ast_channel_audiohooks(chan)) {
        return -1;
    }
 
    switch (type) {
        case AST_AUDIOHOOK_TYPE_SPY:
            AST_LIST_TRAVERSE(&ast_channel_audiohooks(chan)->spy_list, ah, list) {
                if (!strcmp(ah->source, source)) {
                    count++;
                }
            }
            break;
        case AST_AUDIOHOOK_TYPE_WHISPER:
            AST_LIST_TRAVERSE(&ast_channel_audiohooks(chan)->whisper_list, ah, list) {
                if (!strcmp(ah->source, source)) {
                    count++;
                }
            }
            break;
        case AST_AUDIOHOOK_TYPE_MANIPULATE:
            AST_LIST_TRAVERSE(&ast_channel_audiohooks(chan)->manipulate_list, ah, list) {
                if (!strcmp(ah->source, source)) {
                    count++;
                }
            }
            break;
        default:
            ast_debug(1, "Invalid audiohook type supplied, (%u)\n", type);
            return -1;
    }
 
    return count;
}

References AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_channel_audiohooks(), ast_debug, AST_LIST_TRAVERSE, ast_audiohook::list, NULL, ast_audiohook::source, and type.

Referenced by feature_automixmonitor().

ast_channel_audiohook_count_by_source_running()

int ast_channel_audiohook_count_by_source_running	(	struct ast_channel *	chan,
		const char *	source,
		enum ast_audiohook_type	type
	)

Find out how many spies of a certain type exist on a given channel, and are in state running.

Parameters

chan	The channel on which to find the spies
source	The source of the audiohook
type	The type of spy to look for

Returns

number of running audiohooks which are from the source specified

Note: Function performs no locking.

Definition at line 1186 of file audiohook.c.

{
    int count = 0;
    struct ast_audiohook *ah = NULL;
    if (!ast_channel_audiohooks(chan))
        return -1;
 
    switch (type) {
        case AST_AUDIOHOOK_TYPE_SPY:
            AST_LIST_TRAVERSE(&ast_channel_audiohooks(chan)->spy_list, ah, list) {
                if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
                    count++;
            }
            break;
        case AST_AUDIOHOOK_TYPE_WHISPER:
            AST_LIST_TRAVERSE(&ast_channel_audiohooks(chan)->whisper_list, ah, list) {
                if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
                    count++;
            }
            break;
        case AST_AUDIOHOOK_TYPE_MANIPULATE:
            AST_LIST_TRAVERSE(&ast_channel_audiohooks(chan)->manipulate_list, ah, list) {
                if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
                    count++;
            }
            break;
        default:
            ast_debug(1, "Invalid audiohook type supplied, (%u)\n", type);
            return -1;
    }
    return count;
}

References AST_AUDIOHOOK_STATUS_RUNNING, AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_channel_audiohooks(), ast_debug, AST_LIST_TRAVERSE, ast_audiohook::list, NULL, ast_audiohook::source, ast_audiohook::status, and type.