audiohook.c File Reference

Audiohooks Architecture. More...

#include "asterisk.h"
#include <signal.h>
#include "asterisk/channel.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/audiohook.h"
#include "asterisk/slinfactory.h"
#include "asterisk/frame.h"
#include "asterisk/translate.h"
#include "asterisk/format_cache.h"
#include "asterisk/framehook.h"
#include "asterisk/timing.h"
#include "asterisk/test.h"

Include dependency graph for audiohook.c:

Go to the source code of this file.

Data Structures
struct	ast_audiohook_list
struct	ast_audiohook_translate
struct	audiohook_volume
	Audiohook volume adjustment structure. More...
struct	whisper_framehook_data

Macros
#define	AST_AUDIOHOOK_LONG_QUEUE_TOLERANCE   500
#define	AST_AUDIOHOOK_SMALL_QUEUE_TOLERANCE   100
#define	AST_AUDIOHOOK_SYNC_TOLERANCE   100
#define	AST_WHISPER_TIMER_CLAMP(interval)
#define	AST_WHISPER_TIMER_INTERVAL   20
#define	AST_WHISPER_TIMER_INTERVAL_MAX   60
#define	AST_WHISPER_TIMER_INTERVAL_MIN   10
#define	AST_WHISPER_TIMER_SRC   "audiohook whisper timer"
#define	DEFAULT_INTERNAL_SAMPLE_RATE   8000
#define	SHOULD_MUTE(hook, dir)

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 init_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 clearmute)
	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.
static struct ast_frame *	audio_audiohook_write_list (struct ast_channel *chan, struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *frame)
	Pass an AUDIO frame off to be handled by the audiohook core.
static void	audiohook_list_set_hook_rate (struct ast_audiohook_list *audiohook_list, struct ast_audiohook *audiohook, int *rate)
	Set the audiohook's internal sample rate to the audiohook_list's rate, but only when native slin compatibility is turned on.
static void	audiohook_list_set_samplerate_compatibility (struct ast_audiohook_list *audiohook_list)
static struct ast_frame *	audiohook_list_translate_to_native (struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *slin_frame, struct ast_format *outformat)
static struct ast_frame *	audiohook_list_translate_to_slin (struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *frame)
static void	audiohook_move (struct ast_channel *old_chan, struct ast_channel *new_chan, struct ast_audiohook *audiohook)
static struct ast_frame *	audiohook_read_frame_both (struct ast_audiohook *audiohook, size_t samples, struct ast_frame **read_reference, struct ast_frame **write_reference)
static struct ast_frame *	audiohook_read_frame_helper (struct ast_audiohook *audiohook, size_t samples, enum ast_audiohook_direction direction, struct ast_format *format, struct ast_frame **read_reference, struct ast_frame **write_reference)
static struct ast_frame *	audiohook_read_frame_single (struct ast_audiohook *audiohook, size_t samples, enum ast_audiohook_direction direction)
static int	audiohook_set_internal_rate (struct ast_audiohook *audiohook, int rate, int reset)
static int	audiohook_volume_callback (struct ast_audiohook *audiohook, struct ast_channel *chan, struct ast_frame *frame, enum ast_audiohook_direction direction)
	Helper function which actually gets called by audiohooks to perform the adjustment.
static void	audiohook_volume_destroy (void *data)
	Callback used to destroy the audiohook volume datastore.
static struct audiohook_volume *	audiohook_volume_get (struct ast_channel *chan, int create)
	Helper function which finds and optionally creates an audiohook_volume_datastore datastore on a channel.
static struct ast_frame *	dtmf_audiohook_write_list (struct ast_channel *chan, struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *frame)
	Pass a DTMF frame off to be handled by the audiohook core.
static struct ast_audiohook *	find_audiohook_by_source (struct ast_audiohook_list *audiohook_list, const char *source)
	find an audiohook based on its source
static int	whisper_framehook_attach (struct ast_channel *chan, struct ast_audiohook_list *audiohook_list)
static void	whisper_framehook_breakdown (void *data, int framehook_id, struct ast_channel *old_chan, struct ast_channel *new_chan)
static void	whisper_framehook_clear_fd (struct ast_channel *chan, struct whisper_framehook_data *hook_data)
static void	whisper_framehook_destroy_cb (void *data)
static void	whisper_framehook_detach (struct ast_channel *chan, struct ast_audiohook_list *audiohook_list)
static struct ast_frame *	whisper_framehook_event_cb (struct ast_channel *chan, struct ast_frame *frame, enum ast_framehook_event event, void *data)
static void	whisper_framehook_fixup (void *data, int framehook_id, struct ast_channel *old_chan, struct ast_channel *new_chan)
static void	whisper_framehook_stop (struct ast_channel *chan, struct whisper_framehook_data *hook_data)
static void	whisper_framehook_timer_start (struct ast_channel *chan, struct whisper_framehook_data *hook_data)
static void	whisper_framehook_timer_stop (struct ast_channel *chan, struct whisper_framehook_data *hook_data)
static void	whisper_framehook_timer_update (struct ast_audiohook_list *audiohook_list, struct ast_frame *start_frame, int internal_sample_rate, int samples)

Variables
static const struct ast_datastore_info	audiohook_volume_datastore
	Datastore used to store audiohook volume information.

Detailed Description

Audiohooks Architecture.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file audiohook.c.

Macro Definition Documentation

AST_AUDIOHOOK_LONG_QUEUE_TOLERANCE

#define AST_AUDIOHOOK_LONG_QUEUE_TOLERANCE   500

Otheriwise we still don't want the queue to grow indefinitely

Definition at line 48 of file audiohook.c.

AST_AUDIOHOOK_SMALL_QUEUE_TOLERANCE

#define AST_AUDIOHOOK_SMALL_QUEUE_TOLERANCE   100

When small queue is enabled, this is the maximum amount of audio that can remain queued at a time.

Definition at line 47 of file audiohook.c.

AST_AUDIOHOOK_SYNC_TOLERANCE

#define AST_AUDIOHOOK_SYNC_TOLERANCE   100

Tolerance in milliseconds for audiohooks synchronization

Definition at line 46 of file audiohook.c.

AST_WHISPER_TIMER_CLAMP

#define AST_WHISPER_TIMER_CLAMP

(

interval

)

Value:

    ((interval) < AST_WHISPER_TIMER_INTERVAL_MIN ? AST_WHISPER_TIMER_INTERVAL_MIN : \
    ((interval) > AST_WHISPER_TIMER_INTERVAL_MAX ? AST_WHISPER_TIMER_INTERVAL_MAX : (interval)))

Definition at line 52 of file audiohook.c.

                                                                                  : \
    ((interval) > AST_WHISPER_TIMER_INTERVAL_MAX ? AST_WHISPER_TIMER_INTERVAL_MAX : (interval)))

AST_WHISPER_TIMER_INTERVAL

#define AST_WHISPER_TIMER_INTERVAL   20

Definition at line 49 of file audiohook.c.

AST_WHISPER_TIMER_INTERVAL_MAX

#define AST_WHISPER_TIMER_INTERVAL_MAX   60

Definition at line 51 of file audiohook.c.

AST_WHISPER_TIMER_INTERVAL_MIN

#define AST_WHISPER_TIMER_INTERVAL_MIN   10

Definition at line 50 of file audiohook.c.

AST_WHISPER_TIMER_SRC

#define AST_WHISPER_TIMER_SRC   "audiohook whisper timer"

Definition at line 55 of file audiohook.c.

DEFAULT_INTERNAL_SAMPLE_RATE

#define DEFAULT_INTERNAL_SAMPLE_RATE   8000

Definition at line 57 of file audiohook.c.

SHOULD_MUTE

#define SHOULD_MUTE	(		hook,
			dir
	)

Value:

    ((ast_test_flag(hook, AST_AUDIOHOOK_MUTE_READ) && (dir == AST_AUDIOHOOK_DIRECTION_READ)) || \
    (ast_test_flag(hook, AST_AUDIOHOOK_MUTE_WRITE) && (dir == AST_AUDIOHOOK_DIRECTION_WRITE)) || \
    (ast_test_flag(hook, AST_AUDIOHOOK_MUTE_READ | AST_AUDIOHOOK_MUTE_WRITE) == (AST_AUDIOHOOK_MUTE_READ | AST_AUDIOHOOK_MUTE_WRITE)))

Definition at line 460 of file audiohook.c.

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 819 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;
        ast_channel_audiohooks(chan)->whisper_framehook_id = -1;
    }
 
    /* 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) {
        int was_empty = AST_LIST_EMPTY(&ast_channel_audiohooks(chan)->whisper_list);
        AST_LIST_INSERT_TAIL(&ast_channel_audiohooks(chan)->whisper_list, audiohook, list);
        /* Only attach the framehook on the first whisper audiohook */
        if (was_empty) {
            if (whisper_framehook_attach(chan, ast_channel_audiohooks(chan))) {
                AST_LIST_REMOVE(&ast_channel_audiohooks(chan)->whisper_list, audiohook, list);
                ast_channel_unlock(chan);
                return -1;
            }
        }
    } 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_EMPTY, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE, 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, whisper_framehook_attach(), ast_audiohook_list::whisper_framehook_id, 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 422 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(), mixmonitor_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 895 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 910 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 1051 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 398 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 1025 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 1009 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 781 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

Note

The read_frame and write_frame may be in a different format from what was specified in format depending on the sample rate of the hooked channel's codec - ie; if we are requesting slin, but are hooked on channel using a 16K codec like g722, the read and write frames will be slin16.

Definition at line 786 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 1074 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);
        /* Detach the framehook if this was the last whisper audiohook */
        if (AST_LIST_EMPTY(&ast_channel_audiohooks(chan)->whisper_list)) {
            whisper_framehook_detach(chan, ast_channel_audiohooks(chan));
        }
    } 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_EMPTY, AST_LIST_REMOVE, audiohook_list_set_samplerate_compatibility(), ast_audiohook::list, ast_audiohook::type, and whisper_framehook_detach().

Referenced by audiohook_move(), mixmonitor_thread(), 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 448 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 1736 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 1763 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 1462 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 885 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 1711 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 1716 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 1686 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 1691 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 1661 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 1666 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 465 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 1447 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 1439 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 1477 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 1517 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.

audio_audiohook_write_list()

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

static

Pass an AUDIO frame off to be handled by the audiohook core.

This function has 3 ast_frames and 3 parts to handle each. At the beginning of this function all 3 frames, start_frame, middle_frame, and end_frame point to the initial input frame.

Part_1: Translate the start_frame into SLINEAR audio if it is not already in that format. The result of this part is middle_frame is guaranteed to be in SLINEAR format for Part_2. Part_2: Send middle_frame off to spies and manipulators. At this point middle_frame is either a new frame as result of the translation, or points directly to the start_frame because no translation to SLINEAR audio was required. Part_3: Translate end_frame's audio back into the format of start frame if necessary. This is only necessary if manipulation of middle_frame occurred.

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 1271 of file audiohook.c.

{
    struct ast_frame *start_frame = frame, *middle_frame = frame, *end_frame = frame;
    struct ast_audiohook *audiohook = NULL;
    int samples;
    int middle_frame_manipulated = 0;
    int removed = 0;
    int internal_sample_rate;
 
    /* ---Part_1. translate start_frame to SLINEAR if necessary. */
    if (!(middle_frame = audiohook_list_translate_to_slin(audiohook_list, direction, start_frame))) {
        return frame;
    }
 
    /* If the translation resulted in an interpolated frame then immediately return as audiohooks
     * rely on actual media being present to do things.
     */
    if (!middle_frame->data.ptr) {
        if (middle_frame != start_frame) {
            ast_frfree(middle_frame);
        }
        return start_frame;
    }
 
    samples = middle_frame->samples;
 
    /*
     * While processing each audiohook check to see if the internal sample rate needs
     * to be adjusted (it should be the highest rate specified between formats and
     * hooks). The given audiohook_list's internal sample rate is then set to the
     * updated value before returning.
     *
     * If slin compatibility mode is turned on then an audiohook's internal sample
     * rate is set to its audiohook_list's rate. If an audiohook_list's rate is
     * adjusted during this pass then the change is picked up by the audiohooks
     * on the next pass.
     */
    internal_sample_rate = audiohook_list->list_internal_samp_rate;
 
    /* ---Part_2: Send middle_frame to spy and manipulator lists.  middle_frame is guaranteed to be SLINEAR here.*/
    /* Queue up signed linear frame to each spy */
    AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->spy_list, audiohook, list) {
        ast_audiohook_lock(audiohook);
        if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) {
            AST_LIST_REMOVE_CURRENT(list);
            removed = 1;
            ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_DONE);
            ast_audiohook_unlock(audiohook);
            if (ast_channel_is_bridged(chan)) {
                ast_channel_set_unbridged_nolock(chan, 1);
            }
            continue;
        }
        audiohook_list_set_hook_rate(audiohook_list, audiohook, &internal_sample_rate);
        ast_audiohook_write_frame(audiohook, direction, middle_frame);
        ast_audiohook_unlock(audiohook);
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    /* If this frame is being written out to the channel then we need to use whisper sources */
    if (!AST_LIST_EMPTY(&audiohook_list->whisper_list)) {
        int i = 0;
        short read_buf[samples], combine_buf[samples], *data1 = NULL, *data2 = NULL;
        memset(&combine_buf, 0, sizeof(combine_buf));
        AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->whisper_list, audiohook, list) {
            struct ast_slinfactory *factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_factory : &audiohook->write_factory);
            ast_audiohook_lock(audiohook);
            if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) {
                AST_LIST_REMOVE_CURRENT(list);
                removed = 1;
                ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_DONE);
                ast_audiohook_unlock(audiohook);
                if (ast_channel_is_bridged(chan)) {
                    ast_channel_set_unbridged_nolock(chan, 1);
                }
                continue;
            }
            audiohook_list_set_hook_rate(audiohook_list, audiohook, &internal_sample_rate);
            if (ast_slinfactory_available(factory) >= samples && ast_slinfactory_read(factory, read_buf, samples)) {
                /* Take audio from this whisper source and combine it into our main buffer */
                for (i = 0, data1 = combine_buf, data2 = read_buf; i < samples; i++, data1++, data2++) {
                    ast_slinear_saturated_add(data1, data2);
                }
            }
            ast_audiohook_unlock(audiohook);
        }
        AST_LIST_TRAVERSE_SAFE_END;
        /* We take all of the combined whisper sources and combine them into the audio being written out */
        for (i = 0, data1 = middle_frame->data.ptr, data2 = combine_buf; i < samples; i++, data1++, data2++) {
            ast_slinear_saturated_add(data1, data2);
        }
        middle_frame_manipulated = 1;
    }
 
    /* Pass off frame to manipulate audiohooks */
    if (!AST_LIST_EMPTY(&audiohook_list->manipulate_list)) {
        AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->manipulate_list, audiohook, list) {
            ast_audiohook_lock(audiohook);
            if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) {
                AST_LIST_REMOVE_CURRENT(list);
                removed = 1;
                ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_DONE);
                ast_audiohook_unlock(audiohook);
                /* We basically drop all of our links to the manipulate audiohook and prod it to do it's own destructive things */
                audiohook->manipulate_callback(audiohook, chan, NULL, direction);
                if (ast_channel_is_bridged(chan)) {
                    ast_channel_set_unbridged_nolock(chan, 1);
                }
                continue;
            }
            audiohook_list_set_hook_rate(audiohook_list, audiohook, &internal_sample_rate);
            /*
             * Feed in frame to manipulation.
             */
            if (!audiohook->manipulate_callback(audiohook, chan, middle_frame, direction)) {
                /*
                 * XXX FAILURES ARE IGNORED XXX
                 * If the manipulation fails then the frame will be returned in its original state.
                 * Since there are potentially more manipulator callbacks in the list, no action should
                 * be taken here to exit early.
                 */
                middle_frame_manipulated = 1;
            }
            ast_audiohook_unlock(audiohook);
        }
        AST_LIST_TRAVERSE_SAFE_END;
    }
 
    /* ---Part_3: Decide what to do with the end_frame (whether to transcode or not) */
    if (middle_frame_manipulated) {
        if (!(end_frame = audiohook_list_translate_to_native(audiohook_list, direction, middle_frame, start_frame->subclass.format))) {
            /* translation failed, so just pass back the input frame */
            end_frame = start_frame;
        }
    } else {
        end_frame = start_frame;
    }
    /* clean up our middle_frame if required */
    if (middle_frame != end_frame) {
        ast_frfree(middle_frame);
        middle_frame = NULL;
    }
 
    /* Before returning, if an audiohook got removed, reset samplerate compatibility */
    if (removed) {
        if (AST_LIST_EMPTY(&audiohook_list->whisper_list)) {
            whisper_framehook_detach(chan, audiohook_list);
        }
        audiohook_list_set_samplerate_compatibility(audiohook_list);
    } else {
        /*
         * Set the audiohook_list's rate to the updated rate. Note that if a hook
         * was removed then the list's internal rate is reset to the default.
         */
        audiohook_list->list_internal_samp_rate = internal_sample_rate;
        /*
         * Update the whisper timer with the internal sample rate on WRITE only to
         * avoid overlapping writes.
         */
        if (direction == AST_AUDIOHOOK_DIRECTION_WRITE) {
            whisper_framehook_timer_update(audiohook_list, start_frame,
                internal_sample_rate, samples);
        }
    }
 
    return end_frame;
}

References AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, ast_audiohook_lock, AST_AUDIOHOOK_STATUS_DONE, AST_AUDIOHOOK_STATUS_RUNNING, ast_audiohook_unlock, ast_audiohook_update_status(), ast_audiohook_write_frame(), ast_channel_is_bridged(), ast_channel_set_unbridged_nolock(), ast_frfree, AST_LIST_EMPTY, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_slinear_saturated_add(), ast_slinfactory_available(), ast_slinfactory_read(), audiohook_list_set_hook_rate(), audiohook_list_set_samplerate_compatibility(), audiohook_list_translate_to_native(), audiohook_list_translate_to_slin(), ast_frame_subclass::format, ast_audiohook::list, ast_audiohook_list::list_internal_samp_rate, ast_audiohook::manipulate_callback, ast_audiohook_list::manipulate_list, NULL, ast_audiohook::read_factory, ast_frame::samples, ast_audiohook_list::spy_list, ast_audiohook::status, ast_frame::subclass, whisper_framehook_detach(), whisper_framehook_timer_update(), ast_audiohook_list::whisper_list, and ast_audiohook::write_factory.

Referenced by ast_audiohook_write_list().

audiohook_list_set_hook_rate()

static void audiohook_list_set_hook_rate ( struct ast_audiohook_list *  audiohook_list, struct ast_audiohook *  audiohook, int *  rate  )

static

Set the audiohook's internal sample rate to the audiohook_list's rate, but only when native slin compatibility is turned on.

Parameters

audiohook_list	audiohook_list data object
audiohook	the audiohook to update
rate	the current max internal sample rate

Definition at line 1225 of file audiohook.c.

{
    /* The rate should always be the max between itself and the hook */
    if (audiohook->hook_internal_samp_rate > *rate) {
        *rate = audiohook->hook_internal_samp_rate;
    }
 
    /*
     * If native slin compatibility is turned on then update the audiohook
     * with the audiohook_list's current rate. Note, the audiohook's rate is
     * set to the audiohook_list's rate and not the given rate. If there is
     * a change in rate the hook's rate is changed on its next check.
     */
    if (audiohook_list->native_slin_compatible) {
        ast_set_flag(audiohook, AST_AUDIOHOOK_COMPATIBLE);
        audiohook_set_internal_rate(audiohook, audiohook_list->list_internal_samp_rate, 1);
    } else {
        ast_clear_flag(audiohook, AST_AUDIOHOOK_COMPATIBLE);
    }
}

References AST_AUDIOHOOK_COMPATIBLE, ast_clear_flag, ast_set_flag, audiohook_set_internal_rate(), ast_audiohook::hook_internal_samp_rate, ast_audiohook_list::list_internal_samp_rate, and ast_audiohook_list::native_slin_compatible.

Referenced by audio_audiohook_write_list().

audiohook_list_set_samplerate_compatibility()

static void audiohook_list_set_samplerate_compatibility ( struct ast_audiohook_list *  audiohook_list )

static

Definition at line 791 of file audiohook.c.

{
    struct ast_audiohook *ah = NULL;
 
    /*
     * Anytime the samplerate compatibility is set (attach/remove an audiohook) the
     * list's internal sample rate needs to be reset so that the next time processing
     * through write_list, if needed, it will get updated to the correct rate.
     *
     * A list's internal rate always chooses the higher between its own rate and a
     * given rate. If the current rate is being driven by an audiohook that wanted a
     * higher rate then when this audiohook is removed the list's rate would remain
     * at that level when it should be lower, and with no way to lower it since any
     * rate compared against it would be lower.
     *
     * By setting it back to the lowest rate it can recalculate the new highest rate.
     */
    audiohook_list->list_internal_samp_rate = DEFAULT_INTERNAL_SAMPLE_RATE;
 
    audiohook_list->native_slin_compatible = 1;
    AST_LIST_TRAVERSE(&audiohook_list->manipulate_list, ah, list) {
        if (!(ah->init_flags & AST_AUDIOHOOK_MANIPULATE_ALL_RATES)) {
            audiohook_list->native_slin_compatible = 0;
            return;
        }
    }
}

References AST_AUDIOHOOK_MANIPULATE_ALL_RATES, AST_LIST_TRAVERSE, DEFAULT_INTERNAL_SAMPLE_RATE, ast_audiohook::init_flags, ast_audiohook::list, ast_audiohook_list::list_internal_samp_rate, ast_audiohook_list::manipulate_list, ast_audiohook_list::native_slin_compatible, and NULL.

Referenced by ast_audiohook_attach(), ast_audiohook_remove(), audio_audiohook_write_list(), and dtmf_audiohook_write_list().

audiohook_list_translate_to_native()

static struct ast_frame * audiohook_list_translate_to_native ( struct ast_audiohook_list *  audiohook_list, enum ast_audiohook_direction  direction, struct ast_frame *  slin_frame, struct ast_format *  outformat  )

static

Definition at line 1193 of file audiohook.c.

{
    struct ast_audiohook_translate *out_translate = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook_list->out_translate[0] : &audiohook_list->out_translate[1]);
    struct ast_frame *outframe = NULL;
    if (ast_format_cmp(slin_frame->subclass.format, outformat) == AST_FORMAT_CMP_NOT_EQUAL) {
        /* rebuild translators if necessary */
        if (ast_format_cmp(out_translate->format, outformat) == AST_FORMAT_CMP_NOT_EQUAL) {
            if (out_translate->trans_pvt) {
                ast_translator_free_path(out_translate->trans_pvt);
            }
            if (!(out_translate->trans_pvt = ast_translator_build_path(outformat, slin_frame->subclass.format))) {
                return NULL;
            }
            ao2_replace(out_translate->format, outformat);
        }
        /* translate back to the format the frame came in as. */
        if (!(outframe = ast_translate(out_translate->trans_pvt, slin_frame, 0))) {
            return NULL;
        }
    }
    return outframe;
}

References ao2_replace, AST_AUDIOHOOK_DIRECTION_READ, ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, ast_translate(), ast_translator_build_path(), ast_translator_free_path(), ast_frame_subclass::format, ast_audiohook_translate::format, NULL, ast_audiohook_list::out_translate, ast_frame::subclass, and ast_audiohook_translate::trans_pvt.

Referenced by audio_audiohook_write_list().

audiohook_list_translate_to_slin()

static struct ast_frame * audiohook_list_translate_to_slin ( struct ast_audiohook_list *  audiohook_list, enum ast_audiohook_direction  direction, struct ast_frame *  frame  )

static

Definition at line 1147 of file audiohook.c.

{
    struct ast_audiohook_translate *in_translate = (direction == AST_AUDIOHOOK_DIRECTION_READ ?
        &audiohook_list->in_translate[0] : &audiohook_list->in_translate[1]);
    struct ast_frame *new_frame = frame;
    struct ast_format *slin;
 
    /*
     * If we are capable of sample rates other that 8khz, update the internal
     * audiohook_list's rate and higher sample rate audio arrives. If native
     * slin compatibility is turned on all audiohooks in the list will be
     * updated as well during read/write processing.
     */
    audiohook_list->list_internal_samp_rate =
        MAX(ast_format_get_sample_rate(frame->subclass.format), audiohook_list->list_internal_samp_rate);
 
    slin = ast_format_cache_get_slin_by_rate(audiohook_list->list_internal_samp_rate);
    if (ast_format_cmp(frame->subclass.format, slin) == AST_FORMAT_CMP_EQUAL) {
        return new_frame;
    }
 
    if (!in_translate->format ||
        ast_format_cmp(frame->subclass.format, in_translate->format) != AST_FORMAT_CMP_EQUAL) {
        struct ast_trans_pvt *new_trans;
 
        new_trans = ast_translator_build_path(slin, frame->subclass.format);
        if (!new_trans) {
            return NULL;
        }
 
        if (in_translate->trans_pvt) {
            ast_translator_free_path(in_translate->trans_pvt);
        }
        in_translate->trans_pvt = new_trans;
 
        ao2_replace(in_translate->format, frame->subclass.format);
    }
 
    if (!(new_frame = ast_translate(in_translate->trans_pvt, frame, 0))) {
        return NULL;
    }
 
    return new_frame;
}

References ao2_replace, AST_AUDIOHOOK_DIRECTION_READ, ast_format_cache_get_slin_by_rate(), ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_get_sample_rate(), ast_translate(), ast_translator_build_path(), ast_translator_free_path(), ast_frame_subclass::format, ast_audiohook_translate::format, ast_audiohook_list::in_translate, ast_audiohook_list::list_internal_samp_rate, MAX, NULL, ast_frame::subclass, and ast_audiohook_translate::trans_pvt.

Referenced by audio_audiohook_write_list().

audiohook_move()

static void audiohook_move ( struct ast_channel *  old_chan, struct ast_channel *  new_chan, struct ast_audiohook *  audiohook  )

static

Definition at line 982 of file audiohook.c.

{
    enum ast_audiohook_status oldstatus;
 
    /* By locking both channels and the audiohook, we can assure that
     * another thread will not have a chance to read the audiohook's status
     * as done, even though ast_audiohook_remove signals the trigger
     * condition.
     */
    ast_audiohook_lock(audiohook);
    oldstatus = audiohook->status;
 
    ast_audiohook_remove(old_chan, audiohook);
    if (ast_audiohook_attach(new_chan, audiohook)) {
        /*
         * The audiohook is no longer on either channel. Leave it set to
         * AST_AUDIOHOOK_STATUS_DONE as set by ast_audiohook_remove(), so
         * that its owner does not wait forever.
         */
        ast_log(LOG_WARNING, "Unable to move audiohook '%s' to %s\n",
            audiohook->source, ast_channel_name(new_chan));
    } else {
        audiohook->status = oldstatus;
    }
    ast_audiohook_unlock(audiohook);
}

References ast_audiohook_attach(), ast_audiohook_lock, ast_audiohook_remove(), ast_audiohook_unlock, ast_channel_name(), ast_log, LOG_WARNING, ast_audiohook::source, and ast_audiohook::status.

Referenced by ast_audiohook_move_all(), and ast_audiohook_move_by_source().

audiohook_read_frame_both()

static struct ast_frame * audiohook_read_frame_both ( struct ast_audiohook *  audiohook, size_t  samples, struct ast_frame **  read_reference, struct ast_frame **  write_reference  )

static

Definition at line 555 of file audiohook.c.

{
    int count;
    int usable_read;
    int usable_write;
    short adjust_value;
    short buf1[samples];
    short buf2[samples];
    short *read_buf = NULL;
    short *write_buf = NULL;
    struct ast_frame frame = {
        .frametype = AST_FRAME_VOICE,
        .datalen = sizeof(buf1),
        .samples = samples,
    };
 
    /* Make sure both factories have the required samples */
    usable_read = (ast_slinfactory_available(&audiohook->read_factory) >= samples ? 1 : 0);
    usable_write = (ast_slinfactory_available(&audiohook->write_factory) >= samples ? 1 : 0);
 
    if (!usable_read && !usable_write) {
        /* If both factories are unusable bail out */
        ast_debug(3, "Read factory %p and write factory %p both fail to provide %zu samples\n", &audiohook->read_factory, &audiohook->write_factory, samples);
        return NULL;
    }
 
    /* usable_read=1: indicates that read factory have the required samples
     * usable_write=0: indicates that write factory have not the required samples
     * usable_write, follows:
     * 1. Due to RTT issues, the direction write frame has not been received,
     *    and it may take more than (samples/8)*2ms to receive it.
     * 2. Due to packet loss, the direction write frame could not been received.
     *
     * (ast_tvdiff_ms(ast_tvnow(), audiohook->write_time) < (samples/8)*2)(Expression A): This ensures that
     *    packets on both sides can be read correctly even with RTT; however, if the RTT exceeds
     *    (samples/8)*2ms, it may result in the number of packets reading on both sides being greater than the
     *    actual number of packets. for example, this may cause the recording length of mixmonitor to be greater
     *    than the actual duration. Additionally, when RTT = 0 and packet loss is 50%, some packets in the
     *    write direction will never arrive. In this case, continuously waiting will only cause the read
     *    factory to exceed the safe length limit, resulting in both the read factory and write factory
     *    being cleared, thus same packets received in the read direction cannot be read.
     *
     * (ast_slinfactory_available(&audiohook->read_factory) < 2 * samples)(Expression B): This ensures that
     *    packets on both sides can be read correctly, even in the presence of packet loss; regardless of
     *    the amount of packet loss.
     *
     * (Expression A)&&(Expression B): This combination can comprehensively solve both RTT and packet loss
     *    issues; however when RTT exceeds (samples/8)*2ms, it may result in the number of packets read
     *    on both sides being greater than the actual number of packets, causing the recording length of
     *    mixmonitor to be longer than the actual duration. We can adjust (ast_tvdiff_ms(ast_tvnow(),
     *    audiohook->write_time)<(samples/8)*2) && (ast_slinfactory_available(&audiohook->read_factory) <
     *    2 * samples) according to actual needs, for example, setting it to (ast_tvdiff_ms(ast_tvnow(),
     *    audiohook->write_time) < (samples/8)*4) && (ast_slinfactory_available(&audiohook->read_factory)
     *    < 4 * samples).
     *
     *    Update:
     *       Increased time and sample thresholds allow for better handling of asymmetric streams
     *       (e.g., mixed codecs like alaw and G.722) and high RTT conditions.
     *       This avoids premature frame reads when one direction is delayed, which can cause
     *       audio tearing or broken recordings.
     *       Specifically addresses issues with MixMonitor when recording directly on a channel
     *       that is part of a bridge with different sample rates or codecs.
     *       A slight overrun in recording duration is acceptable in exchange for audio stability.
     */
    if (usable_read && !usable_write && (ast_tvdiff_ms(ast_tvnow(), audiohook->write_time) < (samples/8)*4) && (ast_slinfactory_available(&audiohook->read_factory) < 4 * samples)) {
        ast_debug(3, "Write factory %p was pretty quick last time, waiting for them.\n", &audiohook->write_factory);
        return NULL;
    }
 
    /* As shown in the above comment. */
    if (usable_write && !usable_read && (ast_tvdiff_ms(ast_tvnow(), audiohook->read_time) < (samples/8)*4) && (ast_slinfactory_available(&audiohook->write_factory) < 4 * samples)) {
        ast_debug(3, "Read factory %p was pretty quick last time, waiting for them.\n", &audiohook->read_factory);
        return NULL;
    }
 
    /* Start with the read factory... if there are enough samples, read them in */
    if (usable_read) {
        if (ast_slinfactory_read(&audiohook->read_factory, buf1, samples)) {
            read_buf = buf1;
 
            if ((ast_test_flag(audiohook, AST_AUDIOHOOK_MUTE_READ))) {
                /* Clear the frame data if we are muting */
                memset(buf1, 0, sizeof(buf1));
            } else if (audiohook->options.read_volume) {
                /* Adjust read volume if need be */
                adjust_value = abs(audiohook->options.read_volume);
                for (count = 0; count < samples; count++) {
                    if (audiohook->options.read_volume > 0) {
                        ast_slinear_saturated_multiply(&buf1[count], &adjust_value);
                    } else if (audiohook->options.read_volume < 0) {
                        ast_slinear_saturated_divide(&buf1[count], &adjust_value);
                    }
                }
            }
        }
    } else {
        ast_debug(1, "Failed to get %d samples from read factory %p\n", (int)samples, &audiohook->read_factory);
    }
 
    /* Move on to the write factory... if there are enough samples, read them in */
    if (usable_write) {
        if (ast_slinfactory_read(&audiohook->write_factory, buf2, samples)) {
            write_buf = buf2;
 
            if ((ast_test_flag(audiohook, AST_AUDIOHOOK_MUTE_WRITE))) {
                /* Clear the frame data if we are muting */
                memset(buf2, 0, sizeof(buf2));
            } else if (audiohook->options.write_volume) {
                /* Adjust write volume if need be */
                adjust_value = abs(audiohook->options.write_volume);
                for (count = 0; count < samples; count++) {
                    if (audiohook->options.write_volume > 0) {
                        ast_slinear_saturated_multiply(&buf2[count], &adjust_value);
                    } else if (audiohook->options.write_volume < 0) {
                        ast_slinear_saturated_divide(&buf2[count], &adjust_value);
                    }
                }
            }
        }
    } else {
        ast_debug(3, "Failed to get %d samples from write factory %p\n", (int)samples, &audiohook->write_factory);
    }
 
    frame.subclass.format = ast_format_cache_get_slin_by_rate(audiohook->hook_internal_samp_rate);
 
    /* Should we substitute silence if one side lacks audio? */
    if ((ast_test_flag(audiohook, AST_AUDIOHOOK_SUBSTITUTE_SILENCE))) {
        if (read_reference && !read_buf && write_buf) {
            read_buf = buf1;
            memset(buf1, 0, sizeof(buf1));
        } else if (write_reference && read_buf && !write_buf) {
            write_buf = buf2;
            memset(buf2, 0, sizeof(buf2));
        }
    }
 
    /* Basically we figure out which buffer to use... and if mixing can be done here */
    if (read_buf && read_reference) {
        frame.data.ptr = read_buf;
        *read_reference = ast_frdup(&frame);
    }
    if (write_buf && write_reference) {
        frame.data.ptr = write_buf;
        *write_reference = ast_frdup(&frame);
    }
 
    /* Make the correct buffer part of the built frame, so it gets duplicated. */
    if (read_buf) {
        frame.data.ptr = read_buf;
        if (write_buf) {
            for (count = 0; count < samples; count++) {
                ast_slinear_saturated_add(read_buf++, write_buf++);
            }
        }
    } else if (write_buf) {
        frame.data.ptr = write_buf;
    } else {
        return NULL;
    }
 
    /* Yahoo, a combined copy of the audio! */
    return ast_frdup(&frame);
}

References abs, AST_AUDIOHOOK_MUTE_READ, AST_AUDIOHOOK_MUTE_WRITE, AST_AUDIOHOOK_SUBSTITUTE_SILENCE, ast_debug, ast_format_cache_get_slin_by_rate(), AST_FRAME_VOICE, ast_frdup, ast_slinear_saturated_add(), ast_slinear_saturated_divide(), ast_slinear_saturated_multiply(), ast_slinfactory_available(), ast_slinfactory_read(), ast_test_flag, ast_tvdiff_ms(), ast_tvnow(), ast_frame::data, ast_frame_subclass::format, ast_frame::frametype, ast_audiohook::hook_internal_samp_rate, NULL, ast_audiohook::options, ast_frame::ptr, ast_audiohook::read_factory, ast_audiohook::read_time, ast_audiohook_options::read_volume, ast_frame::samples, ast_frame::subclass, write_buf(), ast_audiohook::write_factory, ast_audiohook::write_time, and ast_audiohook_options::write_volume.

Referenced by audiohook_read_frame_helper().

audiohook_read_frame_helper()

static struct ast_frame * audiohook_read_frame_helper ( struct ast_audiohook *  audiohook, size_t  samples, enum ast_audiohook_direction  direction, struct ast_format *  format, struct ast_frame **  read_reference, struct ast_frame **  write_reference  )

static

Definition at line 719 of file audiohook.c.

{
    struct ast_frame *read_frame = NULL, *final_frame = NULL;
    struct ast_format *slin;
 
    /*
     * Update the rate if compatibility mode is turned off or if it is
     * turned on and the format rate is higher than the current rate.
     *
     * This makes it so any unnecessary rate switching/resetting does
     * not take place and also any associated audiohook_list's internal
     * sample rate maintains the highest sample rate between hooks.
     */
    if (!ast_test_flag(audiohook, AST_AUDIOHOOK_COMPATIBLE) ||
        (ast_test_flag(audiohook, AST_AUDIOHOOK_COMPATIBLE) &&
          ast_format_get_sample_rate(format) > audiohook->hook_internal_samp_rate)) {
        audiohook_set_internal_rate(audiohook, ast_format_get_sample_rate(format), 1);
    }
 
    /* If the sample rate of the requested format differs from that of the underlying audiohook
     * sample rate determine how many samples we actually need to get from the audiohook. This
     * needs to occur as the signed linear factory stores them at the rate of the audiohook.
     * We do this by determining the duration of audio they've requested and then determining
     * how many samples that would be in the audiohook format.
     */
    if (ast_format_get_sample_rate(format) != audiohook->hook_internal_samp_rate) {
        samples = (audiohook->hook_internal_samp_rate / 1000) * (samples / (ast_format_get_sample_rate(format) / 1000));
    }
 
    if (!(read_frame = (direction == AST_AUDIOHOOK_DIRECTION_BOTH ?
        audiohook_read_frame_both(audiohook, samples, read_reference, write_reference) :
        audiohook_read_frame_single(audiohook, samples, direction)))) {
        return NULL;
    }
 
    slin = ast_format_cache_get_slin_by_rate(audiohook->hook_internal_samp_rate);
 
    /* If they don't want signed linear back out, we'll have to send it through the translation path */
    if (ast_format_cmp(format, slin) != AST_FORMAT_CMP_EQUAL) {
        /* Rebuild translation path if different format then previously */
        if (ast_format_cmp(format, audiohook->format) == AST_FORMAT_CMP_NOT_EQUAL) {
            if (audiohook->trans_pvt) {
                ast_translator_free_path(audiohook->trans_pvt);
                audiohook->trans_pvt = NULL;
            }
 
            /* Setup new translation path for this format... if we fail we can't very well return signed linear so free the frame and return nothing */
            if (!(audiohook->trans_pvt = ast_translator_build_path(format, slin))) {
                ast_frfree(read_frame);
                return NULL;
            }
            ao2_replace(audiohook->format, format);
        }
        /* Convert to requested format, and allow the read in frame to be freed */
        final_frame = ast_translate(audiohook->trans_pvt, read_frame, 1);
    } else {
        final_frame = read_frame;
    }
 
    return final_frame;
}

References ao2_replace, AST_AUDIOHOOK_COMPATIBLE, AST_AUDIOHOOK_DIRECTION_BOTH, ast_format_cache_get_slin_by_rate(), ast_format_cmp(), AST_FORMAT_CMP_EQUAL, AST_FORMAT_CMP_NOT_EQUAL, ast_format_get_sample_rate(), ast_frfree, ast_test_flag, ast_translate(), ast_translator_build_path(), ast_translator_free_path(), audiohook_read_frame_both(), audiohook_read_frame_single(), audiohook_set_internal_rate(), ast_audiohook::format, ast_audiohook::hook_internal_samp_rate, NULL, read_frame(), and ast_audiohook::trans_pvt.

Referenced by ast_audiohook_read_frame(), and ast_audiohook_read_frame_all().

audiohook_read_frame_single()

static struct ast_frame * audiohook_read_frame_single ( struct ast_audiohook *  audiohook, size_t  samples, enum ast_audiohook_direction  direction  )

static

Definition at line 521 of file audiohook.c.

{
    struct ast_slinfactory *factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_factory : &audiohook->write_factory);
    int vol = (direction == AST_AUDIOHOOK_DIRECTION_READ ? audiohook->options.read_volume : audiohook->options.write_volume);
    short buf[samples];
    struct ast_frame frame = {
        .frametype = AST_FRAME_VOICE,
        .subclass.format = ast_format_cache_get_slin_by_rate(audiohook->hook_internal_samp_rate),
        .data.ptr = buf,
        .datalen = sizeof(buf),
        .samples = samples,
    };
 
    /* Ensure the factory is able to give us the samples we want */
    if (samples > ast_slinfactory_available(factory)) {
        return NULL;
    }
 
    /* Read data in from factory */
    if (!ast_slinfactory_read(factory, buf, samples)) {
        return NULL;
    }
 
    if (SHOULD_MUTE(audiohook, direction)) {
        /* Swap frame data for zeros if mute is required */
        ast_frame_clear(&frame);
    } else if (vol) {
        /* If a volume adjustment needs to be applied apply it */
        ast_frame_adjust_volume(&frame, vol);
    }
 
    return ast_frdup(&frame);
}

References AST_AUDIOHOOK_DIRECTION_READ, ast_format_cache_get_slin_by_rate(), ast_frame_adjust_volume(), ast_frame_clear(), AST_FRAME_VOICE, ast_frdup, ast_slinfactory_available(), ast_slinfactory_read(), buf, ast_frame::frametype, ast_audiohook::hook_internal_samp_rate, NULL, ast_audiohook::options, ast_audiohook::read_factory, ast_audiohook_options::read_volume, ast_frame::samples, SHOULD_MUTE, ast_audiohook::write_factory, and ast_audiohook_options::write_volume.

Referenced by audiohook_read_frame_helper().

audiohook_set_internal_rate()

static int audiohook_set_internal_rate ( struct ast_audiohook *  audiohook, int  rate, int  reset  )

static

Definition at line 368 of file audiohook.c.

{
    struct ast_format *slin;
 
    if (audiohook->hook_internal_samp_rate == rate) {
        return 0;
    }
 
    audiohook->hook_internal_samp_rate = rate;
 
    slin = ast_format_cache_get_slin_by_rate(rate);
 
    /* Setup the factories that are needed for this audiohook type */
    switch (audiohook->type) {
    case AST_AUDIOHOOK_TYPE_SPY:
    case AST_AUDIOHOOK_TYPE_WHISPER:
        if (reset) {
            ast_slinfactory_destroy(&audiohook->read_factory);
            ast_slinfactory_destroy(&audiohook->write_factory);
        }
        ast_slinfactory_init_with_format(&audiohook->read_factory, slin);
        ast_slinfactory_init_with_format(&audiohook->write_factory, slin);
        break;
    default:
        break;
    }
 
    return 0;
}

References AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_format_cache_get_slin_by_rate(), ast_slinfactory_destroy(), ast_slinfactory_init_with_format(), ast_audiohook::hook_internal_samp_rate, ast_audiohook::read_factory, ast_audiohook::type, and ast_audiohook::write_factory.

Referenced by ast_audiohook_attach(), ast_audiohook_init(), audiohook_list_set_hook_rate(), and audiohook_read_frame_helper().

audiohook_volume_callback()

static int audiohook_volume_callback ( struct ast_audiohook *  audiohook, struct ast_channel *  chan, struct ast_frame *  frame, enum ast_audiohook_direction  direction  )

static

Helper function which actually gets called by audiohooks to perform the adjustment.

Parameters

audiohook	Audiohook attached to the channel
chan	Channel we are attached to
frame	Frame of audio we want to manipulate
direction	Direction the audio came in from

Return values

0	on success
-1	on failure

Definition at line 1587 of file audiohook.c.

{
    struct ast_datastore *datastore = NULL;
    struct audiohook_volume *audiohook_volume = NULL;
    float *gain = NULL;
 
    /* If the audiohook is shutting down don't even bother */
    if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE) {
        return 0;
    }
 
    /* Try to find the datastore containing adjustment information, if we can't just bail out */
    if (!(datastore = ast_channel_datastore_find(chan, &audiohook_volume_datastore, NULL))) {
        return 0;
    }
 
    audiohook_volume = datastore->data;
 
    /* Based on direction grab the appropriate adjustment value */
    if (direction == AST_AUDIOHOOK_DIRECTION_READ) {
        gain = &audiohook_volume->read_adjustment;
    } else if (direction == AST_AUDIOHOOK_DIRECTION_WRITE) {
        gain = &audiohook_volume->write_adjustment;
    }
 
    /* If an adjustment value is present modify the frame */
    if (gain && *gain) {
        ast_frame_adjust_volume_float(frame, *gain);
    }
 
    return 0;
}

References AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, AST_AUDIOHOOK_STATUS_DONE, ast_channel_datastore_find(), ast_frame_adjust_volume_float(), audiohook_volume::audiohook, audiohook_volume_datastore, ast_datastore::data, NULL, audiohook_volume::read_adjustment, ast_audiohook::status, and audiohook_volume::write_adjustment.

Referenced by audiohook_volume_get().

audiohook_volume_destroy()

static void audiohook_volume_destroy ( void *  data )

static

Callback used to destroy the audiohook volume datastore.

Parameters

data	Volume information structure

Definition at line 1560 of file audiohook.c.

{
    struct audiohook_volume *audiohook_volume = data;
 
    /* Destroy the audiohook as it is no longer in use */
    ast_audiohook_destroy(&audiohook_volume->audiohook);
 
    /* Finally free ourselves, we are of no more use */
    ast_free(audiohook_volume);
 
    return;
}

References ast_audiohook_destroy(), ast_free, and audiohook_volume::audiohook.

audiohook_volume_get()

static struct audiohook_volume * audiohook_volume_get ( struct ast_channel *  chan, int  create  )

static

Helper function which finds and optionally creates an audiohook_volume_datastore datastore on a channel.

Parameters

chan	Channel to look on
create	Whether to create the datastore if not found

Returns

audiohook_volume structure on success

Return values

NULL	on failure

Definition at line 1626 of file audiohook.c.

{
    struct ast_datastore *datastore = NULL;
    struct audiohook_volume *audiohook_volume = NULL;
 
    /* If we are able to find the datastore return the contents (which is actually an audiohook_volume structure) */
    if ((datastore = ast_channel_datastore_find(chan, &audiohook_volume_datastore, NULL))) {
        return datastore->data;
    }
 
    /* If we are not allowed to create a datastore or if we fail to create a datastore, bail out now as we have nothing for them */
    if (!create || !(datastore = ast_datastore_alloc(&audiohook_volume_datastore, NULL))) {
        return NULL;
    }
 
    /* Create a new audiohook_volume structure to contain our adjustments and audiohook */
    if (!(audiohook_volume = ast_calloc(1, sizeof(*audiohook_volume)))) {
        ast_datastore_free(datastore);
        return NULL;
    }
 
    /* Setup our audiohook structure so we can manipulate the audio */
    ast_audiohook_init(&audiohook_volume->audiohook, AST_AUDIOHOOK_TYPE_MANIPULATE, "Volume", AST_AUDIOHOOK_MANIPULATE_ALL_RATES);
    audiohook_volume->audiohook.manipulate_callback = audiohook_volume_callback;
 
    /* Attach the audiohook_volume blob to the datastore and attach to the channel */
    datastore->data = audiohook_volume;
    ast_channel_datastore_add(chan, datastore);
 
    /* All is well... put the audiohook into motion */
    ast_audiohook_attach(chan, &audiohook_volume->audiohook);
 
    return audiohook_volume;
}

References ast_audiohook_attach(), ast_audiohook_init(), AST_AUDIOHOOK_MANIPULATE_ALL_RATES, AST_AUDIOHOOK_TYPE_MANIPULATE, ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_datastore_alloc, ast_datastore_free(), audiohook_volume::audiohook, audiohook_volume_callback(), audiohook_volume_datastore, ast_datastore::data, ast_audiohook::manipulate_callback, and NULL.

Referenced by ast_audiohook_volume_adjust_float(), ast_audiohook_volume_get_float(), and ast_audiohook_volume_set_float().

dtmf_audiohook_write_list()

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

static

Pass a DTMF 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 1115 of file audiohook.c.

{
    struct ast_audiohook *audiohook = NULL;
    int removed = 0;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->manipulate_list, audiohook, list) {
        ast_audiohook_lock(audiohook);
        if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) {
            AST_LIST_REMOVE_CURRENT(list);
            removed = 1;
            ast_audiohook_update_status(audiohook, AST_AUDIOHOOK_STATUS_DONE);
            ast_audiohook_unlock(audiohook);
            audiohook->manipulate_callback(audiohook, NULL, NULL, 0);
            if (ast_channel_is_bridged(chan)) {
                ast_channel_set_unbridged_nolock(chan, 1);
            }
            continue;
        }
        if (ast_test_flag(audiohook, AST_AUDIOHOOK_WANTS_DTMF)) {
            audiohook->manipulate_callback(audiohook, chan, frame, direction);
        }
        ast_audiohook_unlock(audiohook);
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    /* if an audiohook got removed, reset samplerate compatibility */
    if (removed) {
        audiohook_list_set_samplerate_compatibility(audiohook_list);
    }
    return frame;
}

References ast_audiohook_lock, AST_AUDIOHOOK_STATUS_DONE, AST_AUDIOHOOK_STATUS_RUNNING, ast_audiohook_unlock, ast_audiohook_update_status(), AST_AUDIOHOOK_WANTS_DTMF, ast_channel_is_bridged(), ast_channel_set_unbridged_nolock(), AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_test_flag, audiohook_list_set_samplerate_compatibility(), ast_audiohook::list, ast_audiohook::manipulate_callback, ast_audiohook_list::manipulate_list, NULL, and ast_audiohook::status.

Referenced by ast_audiohook_write_list().

find_audiohook_by_source()

static struct ast_audiohook * find_audiohook_by_source ( struct ast_audiohook_list *  audiohook_list, const char *  source  )

static

find an audiohook based on its source

Parameters

audiohook_list	The list of audiohooks to search in
source	The source of the audiohook we wish to find

Returns

corresponding audiohook

Return values

NULL	if it cannot be found

Definition at line 957 of file audiohook.c.

{
    struct ast_audiohook *audiohook = NULL;
 
    AST_LIST_TRAVERSE(&audiohook_list->spy_list, audiohook, list) {
        if (!strcasecmp(audiohook->source, source)) {
            return audiohook;
        }
    }
 
    AST_LIST_TRAVERSE(&audiohook_list->whisper_list, audiohook, list) {
        if (!strcasecmp(audiohook->source, source)) {
            return audiohook;
        }
    }
 
    AST_LIST_TRAVERSE(&audiohook_list->manipulate_list, audiohook, list) {
        if (!strcasecmp(audiohook->source, source)) {
            return audiohook;
        }
    }
 
    return NULL;
}

References AST_LIST_TRAVERSE, ast_audiohook::list, ast_audiohook_list::manipulate_list, NULL, ast_audiohook::source, ast_audiohook_list::spy_list, and ast_audiohook_list::whisper_list.

Referenced by ast_audiohook_detach_source(), ast_audiohook_move_by_source(), and ast_audiohook_set_mute().

whisper_framehook_attach()

static int whisper_framehook_attach ( struct ast_channel *  chan, struct ast_audiohook_list *  audiohook_list  )

static

Definition at line 316 of file audiohook.c.

{
    struct ast_framehook_interface interface = {
        .version = AST_FRAMEHOOK_INTERFACE_VERSION,
        .event_cb = whisper_framehook_event_cb,
        .destroy_cb = whisper_framehook_destroy_cb,
        .chan_fixup_cb = whisper_framehook_fixup,
        .chan_breakdown_cb = whisper_framehook_breakdown,
    };
    struct whisper_framehook_data *hook_data;
    int framehook_id;
 
    if (audiohook_list->whisper_framehook_id >= 0) {
        return 0;
    }
 
    hook_data = ast_calloc(1, sizeof(*hook_data));
    if (!hook_data) {
        return -1;
    }
    hook_data->timer_fd = -1;
    hook_data->timer_fd_slot = -1;
    hook_data->timer_interval = AST_WHISPER_TIMER_INTERVAL;
    whisper_framehook_timer_start(chan, hook_data);
 
    interface.data = hook_data;
    framehook_id = ast_framehook_attach(chan, &interface);
    if (framehook_id < 0) {
        whisper_framehook_timer_stop(chan, hook_data);
        ast_free(hook_data);
        return -1;
    }
 
    audiohook_list->whisper_framehook_id = framehook_id;
    audiohook_list->whisper_framehook_data = hook_data;
 
    return 0;
}

References ast_calloc, ast_framehook_attach(), AST_FRAMEHOOK_INTERFACE_VERSION, ast_free, AST_WHISPER_TIMER_INTERVAL, ast_framehook_interface::data, whisper_framehook_data::timer_fd, whisper_framehook_data::timer_fd_slot, whisper_framehook_data::timer_interval, ast_framehook_interface::version, whisper_framehook_breakdown(), ast_audiohook_list::whisper_framehook_data, whisper_framehook_destroy_cb(), whisper_framehook_event_cb(), whisper_framehook_fixup(), ast_audiohook_list::whisper_framehook_id, whisper_framehook_timer_start(), and whisper_framehook_timer_stop().

Referenced by ast_audiohook_attach().

whisper_framehook_breakdown()

static void whisper_framehook_breakdown ( void *  data, int  framehook_id, struct ast_channel *  old_chan, struct ast_channel *  new_chan  )

static

Definition at line 195 of file audiohook.c.

{
    struct whisper_framehook_data *hook_data = data;
 
    /* The destination's original descriptor array has been overwritten. */
    if (!hook_data->timer) {
        return;
    }
    hook_data->timer_fd_slot = ast_channel_fd_add(new_chan, hook_data->timer_fd);
    if (hook_data->timer_fd_slot < 0) {
        /*
         * Keep the framehook attached so that the whisper audiohooks still
         * have one.
         */
        whisper_framehook_timer_stop(new_chan, hook_data);
        ast_log(LOG_WARNING, "Unable to register whisper timer on %s after masquerade\n",
            ast_channel_name(new_chan));
    }
}

References ast_channel_fd_add(), ast_channel_name(), ast_log, LOG_WARNING, whisper_framehook_data::timer, whisper_framehook_data::timer_fd, whisper_framehook_data::timer_fd_slot, and whisper_framehook_timer_stop().

Referenced by whisper_framehook_attach().

whisper_framehook_clear_fd()

static void whisper_framehook_clear_fd ( struct ast_channel *  chan, struct whisper_framehook_data *  hook_data  )

static

Definition at line 122 of file audiohook.c.

{
    /* A masquerade may have replaced this slot with another descriptor. */
    if (hook_data->timer_fd_slot >= 0
        && ast_channel_fd(chan, hook_data->timer_fd_slot) == hook_data->timer_fd) {
        ast_channel_set_fd(chan, hook_data->timer_fd_slot, -1);
    }
}

References ast_channel_fd(), ast_channel_set_fd(), whisper_framehook_data::timer_fd, and whisper_framehook_data::timer_fd_slot.

Referenced by whisper_framehook_fixup(), and whisper_framehook_timer_stop().

whisper_framehook_destroy_cb()

static void whisper_framehook_destroy_cb ( void *  data )

static

Definition at line 117 of file audiohook.c.

{
    ast_free(data);
}

References ast_free.

Referenced by whisper_framehook_attach().

whisper_framehook_detach()

static void whisper_framehook_detach ( struct ast_channel *  chan, struct ast_audiohook_list *  audiohook_list  )

static

Definition at line 355 of file audiohook.c.

{
    if (audiohook_list->whisper_framehook_id < 0) {
        return;
    }
 
    ast_framehook_detach(chan, audiohook_list->whisper_framehook_id);
    /* Detachment is deferred, but the timer must stop before its slot is reused. */
    whisper_framehook_timer_stop(chan, audiohook_list->whisper_framehook_data);
    audiohook_list->whisper_framehook_id = -1;
    audiohook_list->whisper_framehook_data = NULL;
}

References ast_framehook_detach(), NULL, ast_audiohook_list::whisper_framehook_data, ast_audiohook_list::whisper_framehook_id, and whisper_framehook_timer_stop().

Referenced by ast_audiohook_remove(), and audio_audiohook_write_list().

whisper_framehook_event_cb()

static struct ast_frame * whisper_framehook_event_cb ( struct ast_channel *  chan, struct ast_frame *  frame, enum ast_framehook_event  event, void *  data  )

static

Definition at line 216 of file audiohook.c.

{
    struct whisper_framehook_data *hook_data = data;
    struct ast_audiohook_list *audiohook_list;
    int rate;
    int samples;
    short buf[AST_WHISPER_TIMER_INTERVAL_MAX * 48];
    struct ast_frame tmp_frame = {
        .frametype = AST_FRAME_VOICE,
        .offset = AST_FRIENDLY_OFFSET,
        .data.ptr = buf,
        .datalen = sizeof(buf),
        .src = AST_WHISPER_TIMER_SRC,
    };
    struct ast_frame *dup;
 
    switch (event) {
    case AST_FRAMEHOOK_EVENT_READ:
        /* We only care about timer driven READ events */
        if (ast_channel_fdno(chan) != hook_data->timer_fd_slot
            || !hook_data->timer
            || ast_timer_ack(hook_data->timer, 1) < 0) {
            return frame;
        }
        break;
    case AST_FRAMEHOOK_EVENT_WRITE:
        /*
         * Track WRITEs that are not triggered by the framehook so we can
         * avoid overlapping with WRITEs that are triggered by the framehook.
         */
        if (frame && frame->frametype == AST_FRAME_VOICE
            && (!frame->src || strcmp(frame->src, AST_WHISPER_TIMER_SRC))) {
            hook_data->last_external_write_tv = ast_tvnow();
        }
        return frame;
    case AST_FRAMEHOOK_EVENT_ATTACHED:
        return frame;
    case AST_FRAMEHOOK_EVENT_DETACHED:
        whisper_framehook_stop(chan, hook_data);
        return frame;
    }
 
    /*
     * If normal outbound media frames are actively flowing (determined by tracking the
     * WRITE events above,) skip timer-based fallback injection. This avoids overlapping
     * WRITE frames and the resulting garbled audio.
     */
    if (!ast_tvzero(hook_data->last_external_write_tv)
        && ast_tvdiff_ms(ast_tvnow(), hook_data->last_external_write_tv)
        <= (hook_data->timer_interval * 2)) {
        return frame;
    }
 
    audiohook_list = ast_channel_audiohooks(chan);
 
    /*
     * As this framehook is dependant on the whisper audiohook(s) existing, this check
     * should never fail.
     */
    if (!audiohook_list || AST_LIST_EMPTY(&audiohook_list->whisper_list)) {
        return frame;
    }
 
    rate = audiohook_list->list_internal_samp_rate;
    if (rate <= 0) {
        rate = DEFAULT_INTERNAL_SAMPLE_RATE;
    }
    samples = (rate / 1000) * hook_data->timer_interval;
    if (!samples || samples > ARRAY_LEN(buf)) {
        return frame;
    }
 
    memset(buf, 0, samples * sizeof(buf[0]));
    tmp_frame.subclass.format = ast_format_cache_get_slin_by_rate(rate);
    tmp_frame.samples = samples;
    tmp_frame.datalen = samples * sizeof(buf[0]);
 
    dup = ast_frdup(&tmp_frame);
    if (!dup) {
        return frame;
    }
 
    /*
     * Invoke a write on the channel with our frame to trigger mixing in
     * audio from the whisper audiohook list.
     */
    ast_channel_unlock(chan);
    ast_write(chan, dup);
    ast_channel_lock(chan);
 
    /* ast_write does not consume the frame, even when the write succeeds. */
    ast_frfree(dup);
 
    /* The timer may have coincided with a queued media or control frame. */
    return frame;
}

References ARRAY_LEN, ast_channel_audiohooks(), ast_channel_fdno(), ast_channel_lock, ast_channel_unlock, ast_format_cache_get_slin_by_rate(), AST_FRAME_VOICE, AST_FRAMEHOOK_EVENT_ATTACHED, AST_FRAMEHOOK_EVENT_DETACHED, AST_FRAMEHOOK_EVENT_READ, AST_FRAMEHOOK_EVENT_WRITE, ast_frdup, ast_frfree, AST_FRIENDLY_OFFSET, AST_LIST_EMPTY, ast_timer_ack(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), AST_WHISPER_TIMER_INTERVAL_MAX, AST_WHISPER_TIMER_SRC, ast_write(), buf, ast_frame::datalen, DEFAULT_INTERNAL_SAMPLE_RATE, ast_frame_subclass::format, ast_frame::frametype, whisper_framehook_data::last_external_write_tv, ast_audiohook_list::list_internal_samp_rate, ast_frame::samples, ast_frame::src, ast_frame::subclass, whisper_framehook_data::timer, whisper_framehook_data::timer_fd_slot, whisper_framehook_data::timer_interval, whisper_framehook_stop(), and ast_audiohook_list::whisper_list.

Referenced by whisper_framehook_attach().

whisper_framehook_fixup()

static void whisper_framehook_fixup ( void *  data, int  framehook_id, struct ast_channel *  old_chan, struct ast_channel *  new_chan  )

static

Definition at line 180 of file audiohook.c.

{
    struct whisper_framehook_data *hook_data = data;
 
    /*
     * The descriptors have already been copied, but the audiohooks have not
     * moved yet. Retire this inherited framehook on both channels. Moving the
     * audiohooks will attach a new one if the destination needs it.
     */
    whisper_framehook_clear_fd(new_chan, hook_data);
    whisper_framehook_stop(old_chan, hook_data);
    ast_framehook_detach(new_chan, framehook_id);
}

References ast_framehook_detach(), whisper_framehook_clear_fd(), and whisper_framehook_stop().

Referenced by whisper_framehook_attach().

whisper_framehook_stop()

static void whisper_framehook_stop ( struct ast_channel *  chan, struct whisper_framehook_data *  hook_data  )

static

Definition at line 167 of file audiohook.c.

{
    struct ast_audiohook_list *audiohook_list = ast_channel_audiohooks(chan);
 
    whisper_framehook_timer_stop(chan, hook_data);
    /* Only remove the framehook if the channel's list still refers to it. */
    if (audiohook_list && audiohook_list->whisper_framehook_data == hook_data) {
        audiohook_list->whisper_framehook_id = -1;
        audiohook_list->whisper_framehook_data = NULL;
    }
}

References ast_channel_audiohooks(), NULL, ast_audiohook_list::whisper_framehook_data, ast_audiohook_list::whisper_framehook_id, and whisper_framehook_timer_stop().

Referenced by whisper_framehook_event_cb(), and whisper_framehook_fixup().

whisper_framehook_timer_start()

static void whisper_framehook_timer_start ( struct ast_channel *  chan, struct whisper_framehook_data *  hook_data  )

static

Definition at line 144 of file audiohook.c.

{
    /*
     * The timer is optional. Without it, whisper audio is still mixed into
     * outbound media, but nothing is sent while the channel has none.
     */
    hook_data->timer = ast_timer_open();
    if (!hook_data->timer) {
        ast_log(LOG_WARNING, "Unable to open whisper timer on %s\n",
            ast_channel_name(chan));
        return;
    }
    hook_data->timer_fd = ast_timer_fd(hook_data->timer);
    hook_data->timer_fd_slot = ast_channel_fd_add(chan, hook_data->timer_fd);
    if (hook_data->timer_fd_slot < 0
        || ast_timer_set_rate(hook_data->timer, 1000 / hook_data->timer_interval)) {
        whisper_framehook_timer_stop(chan, hook_data);
        ast_log(LOG_WARNING, "Unable to start whisper timer on %s\n",
            ast_channel_name(chan));
    }
}

References ast_channel_fd_add(), ast_channel_name(), ast_log, ast_timer_fd(), ast_timer_open(), ast_timer_set_rate(), LOG_WARNING, whisper_framehook_data::timer, whisper_framehook_data::timer_fd, whisper_framehook_data::timer_fd_slot, whisper_framehook_data::timer_interval, and whisper_framehook_timer_stop().

Referenced by whisper_framehook_attach().

whisper_framehook_timer_stop()

static void whisper_framehook_timer_stop ( struct ast_channel *  chan, struct whisper_framehook_data *  hook_data  )

static

Definition at line 132 of file audiohook.c.

{
    whisper_framehook_clear_fd(chan, hook_data);
    if (hook_data->timer) {
        ast_timer_close(hook_data->timer);
        hook_data->timer = NULL;
    }
    hook_data->timer_fd = -1;
    hook_data->timer_fd_slot = -1;
}

References ast_timer_close(), NULL, whisper_framehook_data::timer, whisper_framehook_data::timer_fd, whisper_framehook_data::timer_fd_slot, and whisper_framehook_clear_fd().

Referenced by whisper_framehook_attach(), whisper_framehook_breakdown(), whisper_framehook_detach(), whisper_framehook_stop(), and whisper_framehook_timer_start().

whisper_framehook_timer_update()

static void whisper_framehook_timer_update ( struct ast_audiohook_list *  audiohook_list, struct ast_frame *  start_frame, int  internal_sample_rate, int  samples  )

static

Definition at line 89 of file audiohook.c.

{
    struct whisper_framehook_data *hook_data;
    int interval;
 
    hook_data = audiohook_list->whisper_framehook_data;
    if (!hook_data || internal_sample_rate <= 0 || samples <= 0) {
        return;
    }
 
    if (start_frame->src && !strcmp(start_frame->src, AST_WHISPER_TIMER_SRC)) {
        return;
    }
 
    interval = AST_WHISPER_TIMER_CLAMP((samples * 1000) / internal_sample_rate);
    if (interval == hook_data->timer_interval) {
        return;
    }
 
    hook_data->timer_interval = interval;
    if (hook_data->timer) {
        ast_timer_set_rate(hook_data->timer, 1000 / interval);
    }
}

References ast_timer_set_rate(), AST_WHISPER_TIMER_CLAMP, AST_WHISPER_TIMER_SRC, ast_frame::src, whisper_framehook_data::timer, whisper_framehook_data::timer_interval, and ast_audiohook_list::whisper_framehook_data.

Referenced by audio_audiohook_write_list().

Variable Documentation

audiohook_volume_datastore

const struct ast_datastore_info audiohook_volume_datastore

static

Initial value:

= {
    .type = "Volume",
    .destroy = audiohook_volume_destroy,
}

Datastore used to store audiohook volume information.

Definition at line 1574 of file audiohook.c.

                                                                    {
    .type = "Volume",
    .destroy = audiohook_volume_destroy,
};

Referenced by audiohook_volume_callback(), and audiohook_volume_get().