Wed Oct 28 11:51:43 2009

Asterisk developer's documentation


audiohook.h File Reference

Audiohooks Architecture. More...

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

Include dependency graph for audiohook.h:

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

Go to the source code of this file.

Data Structures

struct  ast_audiohook
struct  ast_audiohook_options

Defines

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

Typedefs

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

Enumerations

enum  ast_audiohook_direction { AST_AUDIOHOOK_DIRECTION_READ = 0, AST_AUDIOHOOK_DIRECTION_WRITE, AST_AUDIOHOOK_DIRECTION_BOTH }
enum  ast_audiohook_flags {
  AST_AUDIOHOOK_TRIGGER_MODE = (3 << 0), AST_AUDIOHOOK_TRIGGER_READ = (1 << 0), AST_AUDIOHOOK_TRIGGER_WRITE = (2 << 0), AST_AUDIOHOOK_WANTS_DTMF = (1 << 1),
  AST_AUDIOHOOK_TRIGGER_SYNC = (1 << 2), AST_AUDIOHOOK_SMALL_QUEUE = (1 << 3)
}
enum  ast_audiohook_status { AST_AUDIOHOOK_STATUS_NEW = 0, AST_AUDIOHOOK_STATUS_RUNNING, AST_AUDIOHOOK_STATUS_SHUTDOWN, AST_AUDIOHOOK_STATUS_DONE }
enum  ast_audiohook_type { AST_AUDIOHOOK_TYPE_SPY = 0, AST_AUDIOHOOK_TYPE_WHISPER, AST_AUDIOHOOK_TYPE_MANIPULATE }

Functions

int ast_audiohook_attach (struct ast_channel *chan, struct ast_audiohook *audiohook)
 Attach audiohook to channel.
int ast_audiohook_destroy (struct ast_audiohook *audiohook)
 Destroys an audiohook structure.
int ast_audiohook_detach (struct ast_audiohook *audiohook)
 Detach audiohook from channel.
int 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)
 Initialize an audiohook structure.
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_frameast_audiohook_read_frame (struct ast_audiohook *audiohook, size_t samples, enum ast_audiohook_direction direction, int format)
 Reads a frame in from the audiohook structure.
int ast_audiohook_remove (struct ast_channel *chan, struct ast_audiohook *audiohook)
 Remove an audiohook from a specified channel.
void ast_audiohook_trigger_wait (struct ast_audiohook *audiohook)
 Wait for audiohook trigger to be triggered.
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_get (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_write_frame (struct ast_audiohook *audiohook, enum ast_audiohook_direction direction, struct ast_frame *frame)
 Writes a frame into the audiohook structure.
struct ast_frameast_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_channel_audiohook_count_by_source (struct ast_channel *chan, const char *source, enum ast_audiohook_type type)
 Find out how many audiohooks from a certain source exist on a given channel, regardless of status.
int ast_channel_audiohook_count_by_source_running (struct ast_channel *chan, const char *source, enum ast_audiohook_type type)
 Find out how many spies of a certain type exist on a given channel, and are in state running.


Detailed Description

Audiohooks Architecture.

Definition in file audiohook.h.


Define Documentation

#define ast_audiohook_lock ( ah   )     ast_mutex_lock(&(ah)->lock)

#define AST_AUDIOHOOK_SYNC_TOLERANCE   100

Definition at line 67 of file audiohook.h.

Referenced by ast_audiohook_write_frame().

#define ast_audiohook_unlock ( ah   )     ast_mutex_unlock(&(ah)->lock)


Typedef Documentation

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

Callback function for manipulate audiohook type.

Parameters:
audiohook Audiohook structure
chan Channel
frame Frame of audio to manipulate
direction Direction frame came from
Returns:
Returns 0 on success, -1 on failure
Note:
An audiohook does not have any reference to a private data structure for manipulate types. It is up to the manipulate callback to store this data via it's own method. An example would be datastores.

Definition at line 80 of file audiohook.h.


Enumeration Type Documentation

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

Definition at line 49 of file audiohook.h.

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

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

Definition at line 55 of file audiohook.h.

00055                          {
00056    AST_AUDIOHOOK_TRIGGER_MODE = (3 << 0),  /*!< When audiohook should be triggered to do something */
00057    AST_AUDIOHOOK_TRIGGER_READ = (1 << 0),  /*!< Audiohook wants to be triggered when reading audio in */
00058    AST_AUDIOHOOK_TRIGGER_WRITE = (2 << 0), /*!< Audiohook wants to be triggered when writing audio out */
00059    AST_AUDIOHOOK_WANTS_DTMF = (1 << 1),    /*!< Audiohook also wants to receive DTMF frames */
00060    AST_AUDIOHOOK_TRIGGER_SYNC = (1 << 2),  /*!< Audiohook wants to be triggered when both sides have combined audio available */
00061    /*! Audiohooks with this flag set will not allow for a large amount of samples to build up on its
00062     * slinfactories. We will flush the factories if they contain too many samples.
00063     */
00064    AST_AUDIOHOOK_SMALL_QUEUE = (1 << 3),
00065 };

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

Definition at line 42 of file audiohook.h.

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

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

Definition at line 36 of file audiohook.h.

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


Function Documentation

int ast_audiohook_attach ( struct ast_channel chan,
struct ast_audiohook audiohook 
)

Attach audiohook to channel.

Parameters:
chan Channel
audiohook Audiohook structure
Returns:
Returns 0 on success, -1 on failure

Definition at line 330 of file audiohook.c.

References AST_AUDIOHOOK_STATUS_RUNNING, AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_calloc, ast_channel_lock, ast_channel_unlock, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, ast_channel::audiohooks, ast_audiohook_list::manipulate_list, ast_audiohook_list::spy_list, ast_audiohook::status, ast_audiohook::type, and ast_audiohook_list::whisper_list.

Referenced by ast_audiohook_move_by_source(), audiohook_volume_get(), enable_jack_hook(), speex_write(), start_spying(), startmon(), and volume_write().

00331 {
00332    ast_channel_lock(chan);
00333 
00334    if (!chan->audiohooks) {
00335       /* Whoops... allocate a new structure */
00336       if (!(chan->audiohooks = ast_calloc(1, sizeof(*chan->audiohooks)))) {
00337          ast_channel_unlock(chan);
00338          return -1;
00339       }
00340       AST_LIST_HEAD_INIT_NOLOCK(&chan->audiohooks->spy_list);
00341       AST_LIST_HEAD_INIT_NOLOCK(&chan->audiohooks->whisper_list);
00342       AST_LIST_HEAD_INIT_NOLOCK(&chan->audiohooks->manipulate_list);
00343    }
00344 
00345    /* Drop into respective list */
00346    if (audiohook->type == AST_AUDIOHOOK_TYPE_SPY)
00347       AST_LIST_INSERT_TAIL(&chan->audiohooks->spy_list, audiohook, list);
00348    else if (audiohook->type == AST_AUDIOHOOK_TYPE_WHISPER)
00349       AST_LIST_INSERT_TAIL(&chan->audiohooks->whisper_list, audiohook, list);
00350    else if (audiohook->type == AST_AUDIOHOOK_TYPE_MANIPULATE)
00351       AST_LIST_INSERT_TAIL(&chan->audiohooks->manipulate_list, audiohook, list);
00352 
00353    /* Change status over to running since it is now attached */
00354    audiohook->status = AST_AUDIOHOOK_STATUS_RUNNING;
00355 
00356    ast_channel_unlock(chan);
00357 
00358    return 0;
00359 }

int ast_audiohook_destroy ( struct ast_audiohook audiohook  ) 

Destroys an audiohook structure.

Parameters:
audiohook Audiohook structure
Returns:
Returns 0 on success, -1 on failure

Definition at line 91 of file audiohook.c.

References AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_cond_destroy(), ast_mutex_destroy(), ast_slinfactory_destroy(), ast_translator_free_path(), 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(), destroy_callback(), destroy_jack_data(), launch_monitor_thread(), and mixmonitor_thread().

00092 {
00093    /* Drop the factories used by this audiohook type */
00094    switch (audiohook->type) {
00095    case AST_AUDIOHOOK_TYPE_SPY:
00096       ast_slinfactory_destroy(&audiohook->read_factory);
00097    case AST_AUDIOHOOK_TYPE_WHISPER:
00098       ast_slinfactory_destroy(&audiohook->write_factory);
00099       break;
00100    default:
00101       break;
00102    }
00103 
00104    /* Destroy translation path if present */
00105    if (audiohook->trans_pvt)
00106       ast_translator_free_path(audiohook->trans_pvt);
00107 
00108    /* Lock and trigger be gone! */
00109    ast_cond_destroy(&audiohook->trigger);
00110    ast_mutex_destroy(&audiohook->lock);
00111 
00112    return 0;
00113 }

int ast_audiohook_detach ( struct ast_audiohook audiohook  ) 

Detach audiohook from channel.

Parameters:
audiohook Audiohook structure
Returns:
Returns 0 on success, -1 on failure

Definition at line 365 of file audiohook.c.

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

Referenced by channel_spy(), disable_jack_hook(), mixmonitor_thread(), and speex_write().

00366 {
00367    if (audiohook->status == AST_AUDIOHOOK_STATUS_NEW || audiohook->status == AST_AUDIOHOOK_STATUS_DONE)
00368       return 0;
00369 
00370    audiohook->status = AST_AUDIOHOOK_STATUS_SHUTDOWN;
00371 
00372    while (audiohook->status != AST_AUDIOHOOK_STATUS_DONE)
00373       ast_audiohook_trigger_wait(audiohook);
00374 
00375    return 0;
00376 }

int ast_audiohook_detach_list ( struct ast_audiohook_list audiohook_list  ) 

Detach audiohooks from list and destroy said list.

Parameters:
audiohook_list List of audiohooks
Returns:
Returns 0 on success, -1 on failure

Definition at line 382 of file audiohook.c.

References ast_audiohook_lock, AST_AUDIOHOOK_STATUS_DONE, ast_audiohook_unlock, ast_cond_signal(), ast_free, AST_LIST_REMOVE_HEAD, ast_translator_free_path(), ast_audiohook_list::in_translate, ast_audiohook::list, ast_audiohook::manipulate_callback, ast_audiohook_list::manipulate_list, ast_audiohook_list::out_translate, ast_audiohook_list::spy_list, ast_audiohook::status, ast_audiohook_translate::trans_pvt, ast_audiohook::trigger, and ast_audiohook_list::whisper_list.

Referenced by ast_hangup().

00383 {
00384    int i = 0;
00385    struct ast_audiohook *audiohook = NULL;
00386 
00387    /* Drop any spies */
00388    while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->spy_list, list))) {
00389       ast_audiohook_lock(audiohook);
00390       audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
00391       ast_cond_signal(&audiohook->trigger);
00392       ast_audiohook_unlock(audiohook);
00393    }
00394 
00395    /* Drop any whispering sources */
00396    while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->whisper_list, list))) {
00397       ast_audiohook_lock(audiohook);
00398       audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
00399       ast_cond_signal(&audiohook->trigger);
00400       ast_audiohook_unlock(audiohook);
00401    }
00402 
00403    /* Drop any manipulaters */
00404    while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->manipulate_list, list))) {
00405       ast_audiohook_lock(audiohook);
00406       audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
00407       ast_audiohook_unlock(audiohook);
00408       audiohook->manipulate_callback(audiohook, NULL, NULL, 0);
00409    }
00410 
00411    /* Drop translation paths if present */
00412    for (i = 0; i < 2; i++) {
00413       if (audiohook_list->in_translate[i].trans_pvt)
00414          ast_translator_free_path(audiohook_list->in_translate[i].trans_pvt);
00415       if (audiohook_list->out_translate[i].trans_pvt)
00416          ast_translator_free_path(audiohook_list->out_translate[i].trans_pvt);
00417    }
00418    
00419    /* Free ourselves */
00420    ast_free(audiohook_list);
00421 
00422    return 0;
00423 }

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
Returns:
Returns 0 on success, -1 on failure
Note:
The channel does not need to be locked before calling this function.
Parameters:
chan Channel to detach from
source Name of source to detach
Returns:
Returns 0 on success, -1 on failure

Definition at line 476 of file audiohook.c.

References AST_AUDIOHOOK_STATUS_DONE, AST_AUDIOHOOK_STATUS_SHUTDOWN, ast_channel_lock, ast_channel_unlock, ast_channel::audiohooks, find_audiohook_by_source(), and ast_audiohook::status.

Referenced by handle_cli_mixmonitor(), and stop_mixmonitor_exec().

00477 {
00478    struct ast_audiohook *audiohook = NULL;
00479 
00480    ast_channel_lock(chan);
00481 
00482    /* Ensure the channel has audiohooks on it */
00483    if (!chan->audiohooks) {
00484       ast_channel_unlock(chan);
00485       return -1;
00486    }
00487 
00488    audiohook = find_audiohook_by_source(chan->audiohooks, source);
00489 
00490    ast_channel_unlock(chan);
00491 
00492    if (audiohook && audiohook->status != AST_AUDIOHOOK_STATUS_DONE)
00493       audiohook->status = AST_AUDIOHOOK_STATUS_SHUTDOWN;
00494 
00495    return (audiohook ? 0 : -1);
00496 }

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

Initialize an audiohook structure.

Parameters:
audiohook Audiohook structure
type Type of audiohook to initialize this as
source Who is initializing this audiohook
Returns:
Returns 0 on success, -1 on failure
Parameters:
audiohook Audiohook structure
type 
source 
Returns:
Returns 0 on success, -1 on failure

Definition at line 60 of file audiohook.c.

References AST_AUDIOHOOK_STATUS_NEW, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_cond_init(), ast_mutex_init(), and ast_slinfactory_init().

Referenced by audiohook_volume_get(), channel_spy(), enable_jack_hook(), launch_monitor_thread(), speex_write(), and volume_write().

00061 {
00062    /* Need to keep the type and source */
00063    audiohook->type = type;
00064    audiohook->source = source;
00065 
00066    /* Initialize lock that protects our audiohook */
00067    ast_mutex_init(&audiohook->lock);
00068    ast_cond_init(&audiohook->trigger, NULL);
00069 
00070    /* Setup the factories that are needed for this audiohook type */
00071    switch (type) {
00072    case AST_AUDIOHOOK_TYPE_SPY:
00073       ast_slinfactory_init(&audiohook->read_factory);
00074    case AST_AUDIOHOOK_TYPE_WHISPER:
00075       ast_slinfactory_init(&audiohook->write_factory);
00076       break;
00077    default:
00078       break;
00079    }
00080 
00081    /* Since we are just starting out... this audiohook is new */
00082    audiohook->status = AST_AUDIOHOOK_STATUS_NEW;
00083 
00084    return 0;
00085 }

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

References ast_audiohook_attach(), ast_audiohook_lock, ast_audiohook_remove(), ast_audiohook_unlock, ast_channel::audiohooks, and find_audiohook_by_source().

Referenced by audiohook_inheritance_fixup().

00453 {
00454    struct ast_audiohook *audiohook;
00455 
00456    if (!old_chan->audiohooks || !(audiohook = find_audiohook_by_source(old_chan->audiohooks, source))) {
00457       return;
00458    }
00459 
00460    /* By locking both channels and the audiohook, we can assure that
00461     * another thread will not have a chance to read the audiohook's status
00462     * as done, even though ast_audiohook_remove signals the trigger
00463     * condition
00464     */
00465    ast_audiohook_lock(audiohook);
00466    ast_audiohook_remove(old_chan, audiohook);
00467    ast_audiohook_attach(new_chan, audiohook);
00468    ast_audiohook_unlock(audiohook);
00469 }

struct ast_frame* ast_audiohook_read_frame ( struct ast_audiohook audiohook,
size_t  samples,
enum ast_audiohook_direction  direction,
int  format 
) [read]

Reads a frame in from the audiohook structure.

Parameters:
audiohook Audiohook structure
samples Number of samples wanted
direction Direction the audio frame came from
format Format of frame remote side wants back
Returns:
Returns frame on success, NULL on failure

Definition at line 295 of file audiohook.c.

References AST_AUDIOHOOK_DIRECTION_BOTH, AST_FORMAT_SLINEAR, ast_frfree, ast_translate(), ast_translator_build_path(), ast_translator_free_path(), audiohook_read_frame_both(), audiohook_read_frame_single(), ast_audiohook::format, read_frame(), and ast_audiohook::trans_pvt.

Referenced by mixmonitor_thread(), and spy_generate().

00296 {
00297    struct ast_frame *read_frame = NULL, *final_frame = NULL;
00298 
00299    if (!(read_frame = (direction == AST_AUDIOHOOK_DIRECTION_BOTH ? audiohook_read_frame_both(audiohook, samples) : audiohook_read_frame_single(audiohook, samples, direction))))
00300       return NULL;
00301 
00302    /* If they don't want signed linear back out, we'll have to send it through the translation path */
00303    if (format != AST_FORMAT_SLINEAR) {
00304       /* Rebuild translation path if different format then previously */
00305       if (audiohook->format != format) {
00306          if (audiohook->trans_pvt) {
00307             ast_translator_free_path(audiohook->trans_pvt);
00308             audiohook->trans_pvt = NULL;
00309          }
00310          /* 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 */
00311          if (!(audiohook->trans_pvt = ast_translator_build_path(format, AST_FORMAT_SLINEAR))) {
00312             ast_frfree(read_frame);
00313             return NULL;
00314          }
00315       }
00316       /* Convert to requested format, and allow the read in frame to be freed */
00317       final_frame = ast_translate(audiohook->trans_pvt, read_frame, 1);
00318    } else {
00319       final_frame = read_frame;
00320    }
00321 
00322    return final_frame;
00323 }

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
Returns:
Returns 0 on success, -1 on failure
Note:
The channel does not need to be locked before calling this function

Definition at line 508 of file audiohook.c.

References ast_audiohook_lock, AST_AUDIOHOOK_STATUS_DONE, AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_audiohook_unlock, ast_channel_lock, ast_channel_unlock, ast_cond_signal(), AST_LIST_REMOVE, ast_channel::audiohooks, ast_audiohook::list, ast_audiohook_list::manipulate_list, ast_audiohook_list::spy_list, ast_audiohook::status, ast_audiohook::trigger, ast_audiohook::type, and ast_audiohook_list::whisper_list.

Referenced by ast_audiohook_move_by_source(), and speex_write().

00509 {
00510    ast_channel_lock(chan);
00511 
00512    if (!chan->audiohooks) {
00513       ast_channel_unlock(chan);
00514       return -1;
00515    }
00516 
00517    if (audiohook->type == AST_AUDIOHOOK_TYPE_SPY)
00518       AST_LIST_REMOVE(&chan->audiohooks->spy_list, audiohook, list);
00519    else if (audiohook->type == AST_AUDIOHOOK_TYPE_WHISPER)
00520       AST_LIST_REMOVE(&chan->audiohooks->whisper_list, audiohook, list);
00521    else if (audiohook->type == AST_AUDIOHOOK_TYPE_MANIPULATE)
00522       AST_LIST_REMOVE(&chan->audiohooks->manipulate_list, audiohook, list);
00523 
00524    ast_audiohook_lock(audiohook);
00525    audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
00526    ast_cond_signal(&audiohook->trigger);
00527    ast_audiohook_unlock(audiohook);
00528 
00529    ast_channel_unlock(chan);
00530 
00531    return 0;
00532 }

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

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().

00716 {
00717    struct timeval wait;
00718    struct timespec ts;
00719 
00720    wait = ast_tvadd(ast_tvnow(), ast_samp2tv(50000, 1000));
00721    ts.tv_sec = wait.tv_sec;
00722    ts.tv_nsec = wait.tv_usec * 1000;
00723    
00724    ast_cond_timedwait(&audiohook->trigger, &audiohook->lock, &ts);
00725    
00726    return;
00727 }

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
Returns:
Returns 0 on success, -1 on failure
Since:
1.6.1
Parameters:
chan Channel to muck with
direction Direction to increase
volume Value to adjust the adjustment by
Returns:
Returns 0 on success, -1 on failure

Definition at line 975 of file audiohook.c.

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

00976 {
00977    struct audiohook_volume *audiohook_volume = NULL;
00978 
00979    /* Attempt to find the audiohook volume information, and create an audiohook if none exists */
00980    if (!(audiohook_volume = audiohook_volume_get(chan, 1))) {
00981       return -1;
00982    }
00983 
00984    /* Based on the direction change the specific adjustment value */
00985    if (direction == AST_AUDIOHOOK_DIRECTION_READ || direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
00986       audiohook_volume->read_adjustment += volume;
00987    }
00988    if (direction == AST_AUDIOHOOK_DIRECTION_WRITE || direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
00989       audiohook_volume->write_adjustment += volume;
00990    }
00991 
00992    return 0;
00993 }

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:
Returns adjustment value
Since:
1.6.1
Parameters:
chan Channel to retrieve volume adjustment from
direction Direction to retrieve
Returns:
Returns adjustment value

Definition at line 949 of file audiohook.c.

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

00950 {
00951    struct audiohook_volume *audiohook_volume = NULL;
00952    int adjustment = 0;
00953 
00954    /* Attempt to find the audiohook volume information, but do not create it as we only want to look at the values */
00955    if (!(audiohook_volume = audiohook_volume_get(chan, 0))) {
00956       return 0;
00957    }
00958 
00959    /* Grab the adjustment value based on direction given */
00960    if (direction == AST_AUDIOHOOK_DIRECTION_READ) {
00961       adjustment = audiohook_volume->read_adjustment;
00962    } else if (direction == AST_AUDIOHOOK_DIRECTION_WRITE) {
00963       adjustment = audiohook_volume->write_adjustment;
00964    }
00965 
00966    return adjustment;
00967 }

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
Returns:
Returns 0 on success, -1 on failure
Since:
1.6.1
Parameters:
chan Channel to muck with
direction Direction to set on
volume Value to adjust the volume by
Returns:
Returns 0 on success, -1 on failure

Definition at line 924 of file audiohook.c.

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

00925 {
00926    struct audiohook_volume *audiohook_volume = NULL;
00927 
00928    /* Attempt to find the audiohook volume information, but only create it if we are not setting the adjustment value to zero */
00929    if (!(audiohook_volume = audiohook_volume_get(chan, (volume ? 1 : 0)))) {
00930       return -1;
00931    }
00932 
00933    /* Now based on the direction set the proper value */
00934    if (direction == AST_AUDIOHOOK_DIRECTION_READ || direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
00935       audiohook_volume->read_adjustment = volume;
00936    }
00937    if (direction == AST_AUDIOHOOK_DIRECTION_WRITE || direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
00938       audiohook_volume->write_adjustment = volume;
00939    }
00940 
00941    return 0;
00942 }

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 Audiohook structure
direction Direction the audio frame came from
frame Frame to write in
Returns:
Returns 0 on success, -1 on failure

Definition at line 121 of file audiohook.c.

References AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, AST_AUDIOHOOK_SMALL_QUEUE, AST_AUDIOHOOK_SYNC_TOLERANCE, AST_AUDIOHOOK_TRIGGER_MODE, AST_AUDIOHOOK_TRIGGER_READ, AST_AUDIOHOOK_TRIGGER_SYNC, AST_AUDIOHOOK_TRIGGER_WRITE, ast_cond_signal(), ast_log(), ast_slinfactory_available(), ast_slinfactory_feed(), ast_slinfactory_flush(), ast_test_flag, ast_tvdiff_ms(), ast_tvnow(), LOG_DEBUG, option_debug, 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(), and channel_spy().

00122 {
00123    struct ast_slinfactory *factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_factory : &audiohook->write_factory);
00124    struct ast_slinfactory *other_factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->write_factory : &audiohook->read_factory);
00125    struct timeval *rwtime = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_time : &audiohook->write_time), previous_time = *rwtime;
00126    int our_factory_samples;
00127    int our_factory_ms;
00128    int other_factory_samples;
00129    int other_factory_ms;
00130 
00131    /* Update last feeding time to be current */
00132    *rwtime = ast_tvnow();
00133 
00134    our_factory_samples = ast_slinfactory_available(factory);
00135    our_factory_ms = ast_tvdiff_ms(*rwtime, previous_time) + (our_factory_samples / 8);
00136    other_factory_samples = ast_slinfactory_available(other_factory);
00137    other_factory_ms = other_factory_samples / 8;
00138 
00139    if (ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_SYNC) && other_factory_samples && (our_factory_ms - other_factory_ms > AST_AUDIOHOOK_SYNC_TOLERANCE)) {
00140       if (option_debug)
00141          ast_log(LOG_DEBUG, "Flushing audiohook %p so it remains in sync\n", audiohook);
00142       ast_slinfactory_flush(factory);
00143       ast_slinfactory_flush(other_factory);
00144    }
00145 
00146    if (ast_test_flag(audiohook, AST_AUDIOHOOK_SMALL_QUEUE) && (our_factory_samples > 640 || other_factory_samples > 640)) {
00147       if (option_debug) {
00148          ast_log(LOG_DEBUG, "Audiohook %p has stale audio in its factories. Flushing them both\n", audiohook);
00149       }
00150       ast_slinfactory_flush(factory);
00151       ast_slinfactory_flush(other_factory);
00152    }
00153 
00154    /* Write frame out to respective factory */
00155    ast_slinfactory_feed(factory, frame);
00156 
00157    /* If we need to notify the respective handler of this audiohook, do so */
00158    if ((ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_MODE) == AST_AUDIOHOOK_TRIGGER_READ) && (direction == AST_AUDIOHOOK_DIRECTION_READ)) {
00159       ast_cond_signal(&audiohook->trigger);
00160    } else if ((ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_MODE) == AST_AUDIOHOOK_TRIGGER_WRITE) && (direction == AST_AUDIOHOOK_DIRECTION_WRITE)) {
00161       ast_cond_signal(&audiohook->trigger);
00162    } else if (ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_SYNC)) {
00163       ast_cond_signal(&audiohook->trigger);
00164    }
00165 
00166    return 0;
00167 }

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 
) [read]

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:
Return frame on success, NULL on failure

Definition at line 700 of file audiohook.c.

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().

00701 {
00702    /* Pass off frame to it's respective list write function */
00703    if (frame->frametype == AST_FRAME_VOICE)
00704       return audio_audiohook_write_list(chan, audiohook_list, direction, frame);
00705    else if (frame->frametype == AST_FRAME_DTMF)
00706       return dtmf_audiohook_write_list(chan, audiohook_list, direction, frame);
00707    else
00708       return frame;
00709 }

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:
Return the number of audiohooks which are from the source specified
Note: Function performs nlocking.

Definition at line 730 of file audiohook.c.

References AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), ast_channel::audiohooks, ast_audiohook::list, LOG_DEBUG, ast_audiohook_list::manipulate_list, ast_audiohook::source, ast_audiohook_list::spy_list, and ast_audiohook_list::whisper_list.

Referenced by builtin_automixmonitor().

00731 {
00732    int count = 0;
00733    struct ast_audiohook *ah = NULL;
00734 
00735    if (!chan->audiohooks)
00736       return -1;
00737 
00738    switch (type) {
00739       case AST_AUDIOHOOK_TYPE_SPY:
00740          AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->spy_list, ah, list) {
00741             if (!strcmp(ah->source, source)) {
00742                count++;
00743             }
00744          }
00745          AST_LIST_TRAVERSE_SAFE_END;
00746          break;
00747       case AST_AUDIOHOOK_TYPE_WHISPER:
00748          AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->whisper_list, ah, list) {
00749             if (!strcmp(ah->source, source)) {
00750                count++;
00751             }
00752          }
00753          AST_LIST_TRAVERSE_SAFE_END;
00754          break;
00755       case AST_AUDIOHOOK_TYPE_MANIPULATE:
00756          AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->manipulate_list, ah, list) {
00757             if (!strcmp(ah->source, source)) {
00758                count++;
00759             }
00760          }
00761          AST_LIST_TRAVERSE_SAFE_END;
00762          break;
00763       default:
00764          ast_log(LOG_DEBUG, "Invalid audiohook type supplied, (%d)\n", type);
00765          return -1;
00766    }
00767 
00768    return count;
00769 }

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:
Return the number of running audiohooks which are from the source specified
Note: Function performs no locking.

Definition at line 772 of file audiohook.c.

References AST_AUDIOHOOK_STATUS_RUNNING, AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), ast_channel::audiohooks, ast_audiohook::list, LOG_DEBUG, ast_audiohook_list::manipulate_list, ast_audiohook::source, ast_audiohook_list::spy_list, ast_audiohook::status, and ast_audiohook_list::whisper_list.

Referenced by builtin_automixmonitor().

00773 {
00774    int count = 0;
00775    struct ast_audiohook *ah = NULL;
00776    if (!chan->audiohooks)
00777       return -1;
00778 
00779    switch (type) {
00780       case AST_AUDIOHOOK_TYPE_SPY:
00781          AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->spy_list, ah, list) {
00782             if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
00783                count++;
00784          }
00785          AST_LIST_TRAVERSE_SAFE_END;
00786          break;
00787       case AST_AUDIOHOOK_TYPE_WHISPER:
00788          AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->whisper_list, ah, list) {
00789             if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
00790                count++;
00791          }
00792          AST_LIST_TRAVERSE_SAFE_END;
00793          break;
00794       case AST_AUDIOHOOK_TYPE_MANIPULATE:
00795          AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->manipulate_list, ah, list) {
00796             if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
00797                count++;
00798          }
00799          AST_LIST_TRAVERSE_SAFE_END;
00800          break;
00801       default:
00802          ast_log(LOG_DEBUG, "Invalid audiohook type supplied, (%d)\n", type);
00803          return -1;
00804    }
00805    return count;
00806 }


Generated on Wed Oct 28 11:51:43 2009 for Asterisk - the Open Source PBX by  doxygen 1.5.6