Thu Oct 11 06:43:36 2012

Asterisk developer's documentation


frame.h File Reference

Asterisk internal frame definitions. More...

#include <sys/types.h>
#include <sys/time.h>
#include "asterisk/compiler.h"
#include "asterisk/endian.h"
#include "asterisk/linkedlists.h"

Include dependency graph for frame.h:

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

Go to the source code of this file.

Data Structures

struct  ast_codec_pref
struct  ast_format_list
 Definition of supported media formats (codecs). More...
struct  ast_frame
 Data structure associated with a single frame of data. More...
struct  ast_option_header
struct  oprmode

Defines

#define AST_FORMAT_ADPCM   (1 << 5)
#define AST_FORMAT_ALAW   (1 << 3)
#define AST_FORMAT_AUDIO_MASK   ((1 << 16)-1)
#define AST_FORMAT_AUDIO_UNDEFINED   ((1 << 13) | (1 << 14) | (1 << 15))
#define AST_FORMAT_G722   (1 << 12)
#define AST_FORMAT_G723_1   (1 << 0)
#define AST_FORMAT_G726   (1 << 11)
#define AST_FORMAT_G726_AAL2   (1 << 4)
#define AST_FORMAT_G729A   (1 << 8)
#define AST_FORMAT_GSM   (1 << 1)
#define AST_FORMAT_H261   (1 << 18)
#define AST_FORMAT_H263   (1 << 19)
#define AST_FORMAT_H263_PLUS   (1 << 20)
#define AST_FORMAT_H264   (1 << 21)
#define AST_FORMAT_ILBC   (1 << 10)
#define AST_FORMAT_JPEG   (1 << 16)
#define AST_FORMAT_LPC10   (1 << 7)
#define AST_FORMAT_MAX_AUDIO   (1 << 15)
#define AST_FORMAT_MAX_VIDEO   (1 << 24)
#define AST_FORMAT_PNG   (1 << 17)
#define AST_FORMAT_SLINEAR   (1 << 6)
#define AST_FORMAT_SPEEX   (1 << 9)
#define AST_FORMAT_ULAW   (1 << 2)
#define AST_FORMAT_VIDEO_MASK   (((1 << 25)-1) & ~(AST_FORMAT_AUDIO_MASK))
#define ast_frame_byteswap_be(fr)   do { struct ast_frame *__f = (fr); ast_swapcopy_samples(__f->data, __f->data, __f->samples); } while(0)
#define ast_frame_byteswap_le(fr)   do { ; } while(0)
#define AST_FRAME_DTMF   AST_FRAME_DTMF_END
#define AST_FRAME_SET_BUFFER(fr, _base, _ofs, _datalen)
#define ast_frfree(fr)   ast_frame_free(fr, 1)
#define AST_FRIENDLY_OFFSET   64
#define AST_HTML_BEGIN   4
#define AST_HTML_DATA   2
#define AST_HTML_END   8
#define AST_HTML_LDCOMPLETE   16
#define AST_HTML_LINKREJECT   20
#define AST_HTML_LINKURL   18
#define AST_HTML_NOSUPPORT   17
#define AST_HTML_UNLINK   19
#define AST_HTML_URL   1
#define AST_MALLOCD_DATA   (1 << 1)
#define AST_MALLOCD_HDR   (1 << 0)
#define AST_MALLOCD_SRC   (1 << 2)
#define AST_MIN_OFFSET   32
#define AST_MODEM_T38   1
#define AST_MODEM_V150   2
#define AST_OPTION_AUDIO_MODE   4
#define AST_OPTION_CHANNEL_WRITE   9
 Handle channel write data If a channel needs to process the data from a func_channel write operation after func_channel_write executes, it can define the setoption callback and process this option. A pointer to an ast_chan_write_info_t will be passed.
#define AST_OPTION_ECHOCAN   8
#define AST_OPTION_FLAG_ACCEPT   1
#define AST_OPTION_FLAG_ANSWER   5
#define AST_OPTION_FLAG_QUERY   4
#define AST_OPTION_FLAG_REJECT   2
#define AST_OPTION_FLAG_REQUEST   0
#define AST_OPTION_FLAG_WTF   6
#define AST_OPTION_OPRMODE   7
#define AST_OPTION_RELAXDTMF   3
#define AST_OPTION_RXGAIN   6
#define AST_OPTION_TDD   2
#define AST_OPTION_TONE_VERIFY   1
#define AST_OPTION_TXGAIN   5
#define ast_smoother_feed(s, f)   __ast_smoother_feed(s, f, 0)
#define ast_smoother_feed_be(s, f)   __ast_smoother_feed(s, f, 1)
#define ast_smoother_feed_le(s, f)   __ast_smoother_feed(s, f, 0)
#define AST_SMOOTHER_FLAG_BE   (1 << 1)
#define AST_SMOOTHER_FLAG_G729   (1 << 0)

Enumerations

enum  { AST_FRFLAG_HAS_TIMING_INFO = (1 << 0) }
enum  ast_control_frame_type {
  AST_CONTROL_HANGUP = 1, AST_CONTROL_RING = 2, AST_CONTROL_RINGING = 3, AST_CONTROL_ANSWER = 4,
  AST_CONTROL_BUSY = 5, AST_CONTROL_TAKEOFFHOOK = 6, AST_CONTROL_OFFHOOK = 7, AST_CONTROL_CONGESTION = 8,
  AST_CONTROL_FLASH = 9, AST_CONTROL_WINK = 10, AST_CONTROL_OPTION = 11, AST_CONTROL_RADIO_KEY = 12,
  AST_CONTROL_RADIO_UNKEY = 13, AST_CONTROL_PROGRESS = 14, AST_CONTROL_PROCEEDING = 15, AST_CONTROL_HOLD = 16,
  AST_CONTROL_UNHOLD = 17, AST_CONTROL_VIDUPDATE = 18, AST_CONTROL_SRCUPDATE = 20, AST_CONTROL_SRCCHANGE = 21,
  AST_CONTROL_END_OF_Q = 22
}
enum  ast_frame_type {
  AST_FRAME_DTMF_END = 1, AST_FRAME_VOICE, AST_FRAME_VIDEO, AST_FRAME_CONTROL,
  AST_FRAME_NULL, AST_FRAME_IAX, AST_FRAME_TEXT, AST_FRAME_IMAGE,
  AST_FRAME_HTML, AST_FRAME_CNG, AST_FRAME_MODEM, AST_FRAME_DTMF_BEGIN
}
 Frame types. More...

Functions

int __ast_smoother_feed (struct ast_smoother *s, struct ast_frame *f, int swap)
char * ast_codec2str (int codec)
 Get a name from a format Gets a name from a format.
int ast_codec_choose (struct ast_codec_pref *pref, int formats, int find_best)
 Select the best audio format according to preference list from supplied options. If "find_best" is non-zero then if nothing is found, the "Best" format of the format list is selected, otherwise 0 is returned.
int ast_codec_get_len (int format, int samples)
 Returns the number of bytes for the number of samples of the given format.
int ast_codec_get_samples (struct ast_frame *f)
 Returns the number of samples contained in the frame.
static int ast_codec_interp_len (int format)
 Gets duration in ms of interpolation frame for a format.
int ast_codec_pref_append (struct ast_codec_pref *pref, int format)
 Append a audio codec to a preference list, removing it first if it was already there.
void ast_codec_pref_convert (struct ast_codec_pref *pref, char *buf, size_t size, int right)
 Shift an audio codec preference list up or down 65 bytes so that it becomes an ASCII string.
struct ast_format_list ast_codec_pref_getsize (struct ast_codec_pref *pref, int format)
 Get packet size for codec.
int ast_codec_pref_index (struct ast_codec_pref *pref, int index)
 Codec located at a particular place in the preference index See Audio Codec Preferences.
void ast_codec_pref_init (struct ast_codec_pref *pref)
 Initialize an audio codec preference to "no preference" See Audio Codec Preferences.
void ast_codec_pref_prepend (struct ast_codec_pref *pref, int format, int only_if_existing)
 Prepend an audio codec to a preference list, removing it first if it was already there.
void ast_codec_pref_remove (struct ast_codec_pref *pref, int format)
 Remove audio a codec from a preference list.
int ast_codec_pref_setsize (struct ast_codec_pref *pref, int format, int framems)
 Set packet size for codec.
int ast_codec_pref_string (struct ast_codec_pref *pref, char *buf, size_t size)
 Dump audio codec preference list into a string.
static force_inline int ast_format_rate (int format)
 Get the sample rate for a given format.
int ast_frame_adjust_volume (struct ast_frame *f, int adjustment)
 Adjusts the volume of the audio samples contained in a frame.
void ast_frame_dump (const char *name, struct ast_frame *f, char *prefix)
struct ast_frameast_frame_enqueue (struct ast_frame *head, struct ast_frame *f, int maxlen, int dupe)
 Appends a frame to the end of a list of frames, truncating the maximum length of the list.
void ast_frame_free (struct ast_frame *fr, int cache)
 Requests a frame to be allocated.
int ast_frame_slinear_sum (struct ast_frame *f1, struct ast_frame *f2)
 Sums two frames of audio samples.
struct ast_frameast_frdup (const struct ast_frame *fr)
 Copies a frame.
struct ast_frameast_frisolate (struct ast_frame *fr)
 Makes a frame independent of any static storage.
struct ast_format_listast_get_format_list (size_t *size)
struct ast_format_listast_get_format_list_index (int index)
int ast_getformatbyname (const char *name)
 Gets a format from a name.
char * ast_getformatname (int format)
 Get the name of a format.
char * ast_getformatname_multiple (char *buf, size_t size, int format)
 Get the names of a set of formats.
void ast_parse_allow_disallow (struct ast_codec_pref *pref, int *mask, const char *list, int allowing)
 Parse an "allow" or "deny" line in a channel or device configuration and update the capabilities mask and pref if provided. Video codecs are not added to codec preference lists, since we can not transcode.
void ast_smoother_free (struct ast_smoother *s)
int ast_smoother_get_flags (struct ast_smoother *smoother)
struct ast_smootherast_smoother_new (int bytes)
struct ast_frameast_smoother_read (struct ast_smoother *s)
void ast_smoother_reconfigure (struct ast_smoother *s, int bytes)
 Reconfigure an existing smoother to output a different number of bytes per frame.
void ast_smoother_reset (struct ast_smoother *s, int bytes)
void ast_smoother_set_flags (struct ast_smoother *smoother, int flags)
int ast_smoother_test_flag (struct ast_smoother *s, int flag)
void ast_swapcopy_samples (void *dst, const void *src, int samples)

Variables

struct ast_frame ast_null_frame


Detailed Description

Asterisk internal frame definitions.

Definition in file frame.h.


Define Documentation

#define AST_FORMAT_ADPCM   (1 << 5)

#define AST_FORMAT_ALAW   (1 << 3)

#define AST_FORMAT_AUDIO_MASK   ((1 << 16)-1)

#define AST_FORMAT_AUDIO_UNDEFINED   ((1 << 13) | (1 << 14) | (1 << 15))

Unsupported audio bits

Definition at line 253 of file frame.h.

#define AST_FORMAT_G722   (1 << 12)

#define AST_FORMAT_G723_1   (1 << 0)

#define AST_FORMAT_G726   (1 << 11)

ADPCM (G.726, 32kbps, RFC3551 codeword packing)

Definition at line 249 of file frame.h.

Referenced by ast_best_codec(), ast_codec_get_len(), ast_codec_get_samples(), ast_rtp_set_rtpmap_type(), g726_read(), g726_write(), and g726tolin_sample().

#define AST_FORMAT_G726_AAL2   (1 << 4)

ADPCM (G.726, 32kbps, AAL2 codeword packing)

Definition at line 235 of file frame.h.

Referenced by ast_best_codec(), ast_codec_get_len(), ast_codec_get_samples(), ast_rtp_lookup_mime_subtype(), ast_rtp_set_rtpmap_type(), codec_ast2skinny(), and codec_skinny2ast().

#define AST_FORMAT_G729A   (1 << 8)

#define AST_FORMAT_GSM   (1 << 1)

#define AST_FORMAT_H261   (1 << 18)

H.261 Video

Definition at line 263 of file frame.h.

Referenced by codec_ast2skinny(), and codec_skinny2ast().

#define AST_FORMAT_H263   (1 << 19)

H.263 Video

Definition at line 265 of file frame.h.

Referenced by codec_ast2skinny(), codec_skinny2ast(), h263_read(), and h263_write().

#define AST_FORMAT_H263_PLUS   (1 << 20)

H.263+ Video

Definition at line 267 of file frame.h.

#define AST_FORMAT_H264   (1 << 21)

H.264 Video

Definition at line 269 of file frame.h.

Referenced by h264_read(), and h264_write().

#define AST_FORMAT_ILBC   (1 << 10)

#define AST_FORMAT_JPEG   (1 << 16)

JPEG Images

Definition at line 259 of file frame.h.

Referenced by jpeg_read_image(), and jpeg_write_image().

#define AST_FORMAT_LPC10   (1 << 7)

LPC10, 180 samples/frame

Definition at line 241 of file frame.h.

Referenced by ast_best_codec(), ast_codec_get_samples(), and lpc10tolin_sample().

#define AST_FORMAT_MAX_AUDIO   (1 << 15)

#define AST_FORMAT_MAX_VIDEO   (1 << 24)

Maximum video format

Definition at line 271 of file frame.h.

Referenced by add_sdp(), ast_openvstream(), and ast_translate_available_formats().

#define AST_FORMAT_PNG   (1 << 17)

PNG Images

Definition at line 261 of file frame.h.

Referenced by phone_read().

#define AST_FORMAT_SLINEAR   (1 << 6)

Raw 16-bit Signed Linear (8000 Hz) PCM

Definition at line 239 of file frame.h.

Referenced by __ast_play_and_record(), action_originate(), agent_new(), alsa_new(), alsa_read(), alsa_request(), ast_audiohook_read_frame(), ast_best_codec(), ast_channel_make_compatible(), ast_channel_start_silence_generator(), ast_codec_get_len(), ast_codec_get_samples(), ast_dsp_call_progress(), ast_dsp_digitdetect(), ast_dsp_process(), ast_dsp_silence(), ast_frame_adjust_volume(), ast_frame_slinear_sum(), ast_rtp_read(), ast_slinfactory_feed(), ast_write(), attempt_reconnect(), audio_audiohook_write_list(), audiohook_read_frame_both(), audiohook_read_frame_single(), background_detect_exec(), build_conf(), chanspy_exec(), conf_run(), connect_link(), dahdi_read(), dahdi_translate(), dahdi_write(), dictate_exec(), do_waiting(), eagi_exec(), extenspy_exec(), find_transcoders(), handle_recordfile(), iax_frame_wrap(), ices_exec(), init_outgoing(), is_encoder(), isAnsweringMachine(), linear_alloc(), linear_generator(), lintoadpcm_sample(), lintoalaw_sample(), lintog726_sample(), lintogsm_sample(), lintoilbc_sample(), lintolpc10_sample(), lintospeex_sample(), lintoulaw_sample(), load_module(), load_moh_classes(), measurenoise(), mixmonitor_thread(), moh_class_malloc(), mp3_exec(), nbs_request(), nbs_xwrite(), NBScat_exec(), ogg_vorbis_read(), ogg_vorbis_write(), oh323_rtp_read(), orig_app(), orig_exten(), oss_new(), oss_read(), oss_request(), parkandannounce_exec(), phone_new(), phone_read(), phone_request(), phone_setup(), phone_write(), playtones_alloc(), playtones_generator(), record_exec(), rpt(), rpt_call(), rpt_exec(), rpt_tele_thread(), send_waveform_to_channel(), silence_generator_generate(), slinear_read(), slinear_write(), sms_exec(), sms_generate(), socket_process(), speech_background(), speech_create(), spy_generate(), tonepair_alloc(), tonepair_generator(), wav_read(), and wav_write().

#define AST_FORMAT_SPEEX   (1 << 9)

SpeeX Free Compression

Definition at line 245 of file frame.h.

Referenced by ast_best_codec(), ast_codec_get_samples(), ast_rtp_write(), convertcap(), and speextolin_sample().

#define AST_FORMAT_ULAW   (1 << 2)

#define AST_FORMAT_VIDEO_MASK   (((1 << 25)-1) & ~(AST_FORMAT_AUDIO_MASK))

#define ast_frame_byteswap_be ( fr   )     do { struct ast_frame *__f = (fr); ast_swapcopy_samples(__f->data, __f->data, __f->samples); } while(0)

Definition at line 437 of file frame.h.

Referenced by ast_rtp_read(), and socket_process().

#define ast_frame_byteswap_le ( fr   )     do { ; } while(0)

Definition at line 436 of file frame.h.

Referenced by phone_read().

#define AST_FRAME_DTMF   AST_FRAME_DTMF_END

#define AST_FRAME_SET_BUFFER ( fr,
_base,
_ofs,
_datalen   ) 

Value:

{              \
   (fr)->data = (char *)_base + (_ofs);   \
   (fr)->offset = (_ofs);        \
   (fr)->datalen = (_datalen);      \
   }
Set the various field of a frame to point to a buffer. Typically you set the base address of the buffer, the offset as AST_FRIENDLY_OFFSET, and the datalen as the amount of bytes queued. The remaining things (to be done manually) is set the number of samples, which cannot be derived from the datalen unless you know the number of bits per sample.

Definition at line 176 of file frame.h.

Referenced by g723_read(), g726_read(), g729_read(), gsm_read(), h263_read(), h264_read(), ilbc_read(), ogg_vorbis_read(), pcm_read(), slinear_read(), vox_read(), and wav_read().

#define ast_frfree ( fr   )     ast_frame_free(fr, 1)

Definition at line 407 of file frame.h.

Referenced by __adsi_transmit_messages(), __ast_play_and_record(), __ast_queue_frame(), __ast_read(), __ast_request_and_dial(), adsi_careful_send(), agent_ack_sleep(), agent_read(), app_exec(), ast_audiohook_read_frame(), ast_autoservice_stop(), ast_bridge_call(), ast_channel_clear_softhangup(), ast_channel_free(), ast_dsp_process(), ast_generic_bridge(), ast_jb_destroy(), ast_jb_put(), ast_readaudio_callback(), ast_readvideo_callback(), ast_recvtext(), ast_rtp_write(), ast_safe_sleep_conditional(), ast_send_image(), ast_slinfactory_destroy(), ast_slinfactory_feed(), ast_slinfactory_flush(), ast_slinfactory_read(), ast_tonepair(), ast_translate(), ast_udptl_bridge(), ast_waitfordigit_full(), ast_write(), ast_writestream(), async_wait(), audio_audiohook_write_list(), autoservice_run(), background_detect_exec(), bridge_native_loop(), bridge_p2p_loop(), calc_cost(), channel_spy(), check_goto_on_transfer(), cli_audio_convert(), cli_audio_convert_deprecated(), conf_exec(), conf_flush(), conf_free(), conf_run(), create_jb(), dahdi_bridge(), dictate_exec(), disa_exec(), do_parking_thread(), do_waiting(), echo_exec(), feature_request_and_dial(), find_cache(), gen_generate(), handle_recordfile(), iax2_bridge(), iax_park_thread(), ices_exec(), isAnsweringMachine(), jb_empty_and_reset_adaptive(), jb_empty_and_reset_fixed(), jb_get_and_deliver(), masq_park_call(), measurenoise(), moh_files_generator(), monitor_dial(), mp3_exec(), NBScat_exec(), read_frame(), receive_dtmf_digits(), record_exec(), recordthread(), rpt(), rpt_exec(), run_agi(), send_tone_burst(), send_waveform_to_channel(), sendurl_exec(), sms_exec(), speech_background(), spy_generate(), ss_thread(), wait_for_answer(), wait_for_hangup(), wait_for_winner(), waitforring_exec(), and waitstream_core().

#define AST_FRIENDLY_OFFSET   64

#define AST_HTML_BEGIN   4

Beginning frame

Definition at line 211 of file frame.h.

Referenced by ast_frame_dump().

#define AST_HTML_DATA   2

Data frame

Definition at line 209 of file frame.h.

Referenced by ast_frame_dump().

#define AST_HTML_END   8

End frame

Definition at line 213 of file frame.h.

Referenced by ast_frame_dump().

#define AST_HTML_LDCOMPLETE   16

Load is complete

Definition at line 215 of file frame.h.

Referenced by ast_frame_dump(), and sendurl_exec().

#define AST_HTML_LINKREJECT   20

Reject link request

Definition at line 223 of file frame.h.

Referenced by ast_frame_dump().

#define AST_HTML_LINKURL   18

Send URL, and track

Definition at line 219 of file frame.h.

Referenced by ast_frame_dump().

#define AST_HTML_NOSUPPORT   17

Peer is unable to support HTML

Definition at line 217 of file frame.h.

Referenced by ast_frame_dump(), and sendurl_exec().

#define AST_HTML_UNLINK   19

No more HTML linkage

Definition at line 221 of file frame.h.

Referenced by ast_frame_dump().

#define AST_HTML_URL   1

Sending a URL

Definition at line 207 of file frame.h.

Referenced by ast_channel_sendurl(), and ast_frame_dump().

#define AST_MALLOCD_DATA   (1 << 1)

Need the data be free'd?

Definition at line 195 of file frame.h.

Referenced by __frame_free(), and ast_frisolate().

#define AST_MALLOCD_HDR   (1 << 0)

Need the header be free'd?

Definition at line 193 of file frame.h.

Referenced by __frame_free(), ast_frame_header_new(), ast_frdup(), and ast_frisolate().

#define AST_MALLOCD_SRC   (1 << 2)

Need the source be free'd? (haha!)

Definition at line 197 of file frame.h.

Referenced by __frame_free(), and ast_frisolate().

#define AST_MIN_OFFSET   32

Definition at line 190 of file frame.h.

Referenced by __ast_smoother_feed().

#define AST_MODEM_T38   1

T.38 Fax-over-IP

Definition at line 201 of file frame.h.

Referenced by ast_frame_dump(), and udptl_rx_packet().

#define AST_MODEM_V150   2

V.150 Modem-over-IP

Definition at line 203 of file frame.h.

Referenced by ast_frame_dump().

#define AST_OPTION_AUDIO_MODE   4

Set (or clear) Audio (Not-Clear) Mode

Definition at line 320 of file frame.h.

Referenced by ast_bridge_call(), dahdi_hangup(), dahdi_setoption(), and iax2_setoption().

#define AST_OPTION_CHANNEL_WRITE   9

Handle channel write data If a channel needs to process the data from a func_channel write operation after func_channel_write executes, it can define the setoption callback and process this option. A pointer to an ast_chan_write_info_t will be passed.

Definition at line 349 of file frame.h.

Referenced by func_channel_write(), and local_setoption().

#define AST_OPTION_ECHOCAN   8

Explicitly enable or disable echo cancelation for the given channel

Definition at line 342 of file frame.h.

Referenced by dahdi_setoption().

#define AST_OPTION_FLAG_ACCEPT   1

Definition at line 303 of file frame.h.

#define AST_OPTION_FLAG_ANSWER   5

Definition at line 306 of file frame.h.

#define AST_OPTION_FLAG_QUERY   4

Definition at line 305 of file frame.h.

#define AST_OPTION_FLAG_REJECT   2

Definition at line 304 of file frame.h.

#define AST_OPTION_FLAG_REQUEST   0

Definition at line 302 of file frame.h.

Referenced by ast_bridge_call(), and iax2_setoption().

#define AST_OPTION_FLAG_WTF   6

Definition at line 307 of file frame.h.

#define AST_OPTION_OPRMODE   7

Definition at line 339 of file frame.h.

Referenced by dahdi_setoption().

#define AST_OPTION_RELAXDTMF   3

Relax the parameters for DTMF reception (mainly for radio use)

Definition at line 317 of file frame.h.

Referenced by ast_bridge_call(), dahdi_setoption(), iax2_setoption(), and rpt().

#define AST_OPTION_RXGAIN   6

Set channel receive gain Option data is a single signed char representing number of decibels (dB) to set gain to (on top of any gain specified in channel driver)

Definition at line 336 of file frame.h.

Referenced by dahdi_setoption(), func_channel_write_real(), iax2_setoption(), play_record_review(), reset_volumes(), set_talk_volume(), and vm_forwardoptions().

#define AST_OPTION_TDD   2

Put a compatible channel into TDD (TTY for the hearing-impared) mode

Definition at line 314 of file frame.h.

Referenced by ast_bridge_call(), dahdi_hangup(), dahdi_setoption(), handle_tddmode(), and iax2_setoption().

#define AST_OPTION_TONE_VERIFY   1

Verify touchtones by muting audio transmission (and reception) and verify the tone is still present

Definition at line 311 of file frame.h.

Referenced by ast_bridge_call(), conf_run(), dahdi_hangup(), dahdi_setoption(), iax2_setoption(), rpt(), rpt_exec(), and try_calling().

#define AST_OPTION_TXGAIN   5

Set channel transmit gain Option data is a single signed char representing number of decibels (dB) to set gain to (on top of any gain specified in channel driver)

Definition at line 328 of file frame.h.

Referenced by common_exec(), dahdi_setoption(), func_channel_write_real(), iax2_setoption(), reset_volumes(), and set_listen_volume().

#define ast_smoother_feed ( s,
f   )     __ast_smoother_feed(s, f, 0)

Definition at line 496 of file frame.h.

Referenced by ast_rtp_write().

#define ast_smoother_feed_be ( s,
f   )     __ast_smoother_feed(s, f, 1)

Definition at line 498 of file frame.h.

Referenced by ast_rtp_write().

#define ast_smoother_feed_le ( s,
f   )     __ast_smoother_feed(s, f, 0)

Definition at line 499 of file frame.h.

#define AST_SMOOTHER_FLAG_BE   (1 << 1)

Definition at line 299 of file frame.h.

Referenced by ast_rtp_write().

#define AST_SMOOTHER_FLAG_G729   (1 << 0)

Definition at line 298 of file frame.h.

Referenced by __ast_smoother_feed(), ast_smoother_read(), and smoother_frame_feed().


Enumeration Type Documentation

anonymous enum

Enumerator:
AST_FRFLAG_HAS_TIMING_INFO  This frame contains valid timing information

Definition at line 128 of file frame.h.

00128      {
00129    /*! This frame contains valid timing information */
00130    AST_FRFLAG_HAS_TIMING_INFO = (1 << 0),
00131 };

Enumerator:
AST_CONTROL_HANGUP  Other end has hungup
AST_CONTROL_RING  Local ring
AST_CONTROL_RINGING  Remote end is ringing
AST_CONTROL_ANSWER  Remote end has answered
AST_CONTROL_BUSY  Remote end is busy
AST_CONTROL_TAKEOFFHOOK  Make it go off hook
AST_CONTROL_OFFHOOK  Line is off hook
AST_CONTROL_CONGESTION  Congestion (circuits busy)
AST_CONTROL_FLASH  Flash hook
AST_CONTROL_WINK  Wink
AST_CONTROL_OPTION  Set a low-level option
AST_CONTROL_RADIO_KEY  Key Radio
AST_CONTROL_RADIO_UNKEY  Un-Key Radio
AST_CONTROL_PROGRESS  Indicate PROGRESS
AST_CONTROL_PROCEEDING  Indicate CALL PROCEEDING
AST_CONTROL_HOLD  Indicate call is placed on hold
AST_CONTROL_UNHOLD  Indicate call is left from hold
AST_CONTROL_VIDUPDATE  Indicate video frame update
AST_CONTROL_SRCUPDATE  Indicate source of media has changed
AST_CONTROL_SRCCHANGE  Media has changed and requires a new RTP SSRC
AST_CONTROL_END_OF_Q  Indicate that this position was the end of the channel queue for a softhangup.

Definition at line 274 of file frame.h.

00274                             {
00275    AST_CONTROL_HANGUP = 1,    /*!< Other end has hungup */
00276    AST_CONTROL_RING = 2,      /*!< Local ring */
00277    AST_CONTROL_RINGING = 3,   /*!< Remote end is ringing */
00278    AST_CONTROL_ANSWER = 4,    /*!< Remote end has answered */
00279    AST_CONTROL_BUSY = 5,      /*!< Remote end is busy */
00280    AST_CONTROL_TAKEOFFHOOK = 6,  /*!< Make it go off hook */
00281    AST_CONTROL_OFFHOOK = 7,   /*!< Line is off hook */
00282    AST_CONTROL_CONGESTION = 8,   /*!< Congestion (circuits busy) */
00283    AST_CONTROL_FLASH = 9,     /*!< Flash hook */
00284    AST_CONTROL_WINK = 10,     /*!< Wink */
00285    AST_CONTROL_OPTION = 11,   /*!< Set a low-level option */
00286    AST_CONTROL_RADIO_KEY = 12,   /*!< Key Radio */
00287    AST_CONTROL_RADIO_UNKEY = 13, /*!< Un-Key Radio */
00288    AST_CONTROL_PROGRESS = 14, /*!< Indicate PROGRESS */
00289    AST_CONTROL_PROCEEDING = 15,  /*!< Indicate CALL PROCEEDING */
00290    AST_CONTROL_HOLD = 16,     /*!< Indicate call is placed on hold */
00291    AST_CONTROL_UNHOLD = 17,   /*!< Indicate call is left from hold */
00292    AST_CONTROL_VIDUPDATE = 18,   /*!< Indicate video frame update */
00293    AST_CONTROL_SRCUPDATE = 20,     /*!< Indicate source of media has changed */
00294    AST_CONTROL_SRCCHANGE = 21,     /*!< Media has changed and requires a new RTP SSRC */
00295    AST_CONTROL_END_OF_Q = 22,    /*!< Indicate that this position was the end of the channel queue for a softhangup. */
00296 };

Frame types.

Note:
It is important that the values of each frame type are never changed, because it will break backwards compatability with older versions.
Enumerator:
AST_FRAME_DTMF_END  DTMF end event, subclass is the digit
AST_FRAME_VOICE  Voice data, subclass is AST_FORMAT_*
AST_FRAME_VIDEO  Video frame, maybe?? :)
AST_FRAME_CONTROL  A control frame, subclass is AST_CONTROL_*
AST_FRAME_NULL  An empty, useless frame
AST_FRAME_IAX  Inter Asterisk Exchange private frame type
AST_FRAME_TEXT  Text messages
AST_FRAME_IMAGE  Image Frames
AST_FRAME_HTML  HTML Frame
AST_FRAME_CNG  Comfort Noise frame (subclass is level of CNG in -dBov), body may include zero or more 8-bit quantization coefficients
AST_FRAME_MODEM  Modem-over-IP data streams
AST_FRAME_DTMF_BEGIN  DTMF begin event, subclass is the digit

Definition at line 99 of file frame.h.

00099                     {
00100    /*! DTMF end event, subclass is the digit */
00101    AST_FRAME_DTMF_END = 1,
00102    /*! Voice data, subclass is AST_FORMAT_* */
00103    AST_FRAME_VOICE,
00104    /*! Video frame, maybe?? :) */
00105    AST_FRAME_VIDEO,
00106    /*! A control frame, subclass is AST_CONTROL_* */
00107    AST_FRAME_CONTROL,
00108    /*! An empty, useless frame */
00109    AST_FRAME_NULL,
00110    /*! Inter Asterisk Exchange private frame type */
00111    AST_FRAME_IAX,
00112    /*! Text messages */
00113    AST_FRAME_TEXT,
00114    /*! Image Frames */
00115    AST_FRAME_IMAGE,
00116    /*! HTML Frame */
00117    AST_FRAME_HTML,
00118    /*! Comfort Noise frame (subclass is level of CNG in -dBov), 
00119        body may include zero or more 8-bit quantization coefficients */
00120    AST_FRAME_CNG,
00121    /*! Modem-over-IP data streams */
00122    AST_FRAME_MODEM,  
00123    /*! DTMF begin event, subclass is the digit */
00124    AST_FRAME_DTMF_BEGIN,
00125 };


Function Documentation

int __ast_smoother_feed ( struct ast_smoother s,
struct ast_frame f,
int  swap 
)

Definition at line 211 of file frame.c.

References AST_FRAME_VOICE, ast_log(), AST_MIN_OFFSET, AST_SMOOTHER_FLAG_G729, ast_swapcopy_samples(), ast_frame::data, ast_frame::datalen, ast_smoother::flags, ast_smoother::format, ast_frame::frametype, ast_smoother::len, LOG_WARNING, ast_frame::offset, ast_smoother::opt, ast_smoother::opt_needs_swap, ast_frame::samples, ast_smoother::samplesperbyte, ast_smoother::size, smoother_frame_feed(), SMOOTHER_SIZE, and ast_frame::subclass.

00212 {
00213    if (f->frametype != AST_FRAME_VOICE) {
00214       ast_log(LOG_WARNING, "Huh?  Can't smooth a non-voice frame!\n");
00215       return -1;
00216    }
00217    if (!s->format) {
00218       s->format = f->subclass;
00219       s->samplesperbyte = (float)f->samples / (float)f->datalen;
00220    } else if (s->format != f->subclass) {
00221       ast_log(LOG_WARNING, "Smoother was working on %d format frames, now trying to feed %d?\n", s->format, f->subclass);
00222       return -1;
00223    }
00224    if (s->len + f->datalen > SMOOTHER_SIZE) {
00225       ast_log(LOG_WARNING, "Out of smoother space\n");
00226       return -1;
00227    }
00228    if (((f->datalen == s->size) ||
00229         ((f->datalen < 10) && (s->flags & AST_SMOOTHER_FLAG_G729))) &&
00230        !s->opt &&
00231        !s->len &&
00232        (f->offset >= AST_MIN_OFFSET)) {
00233       /* Optimize by sending the frame we just got
00234          on the next read, thus eliminating the douple
00235          copy */
00236       if (swap)
00237          ast_swapcopy_samples(f->data, f->data, f->samples);
00238       s->opt = f;
00239       s->opt_needs_swap = swap ? 1 : 0;
00240       return 0;
00241    }
00242 
00243    return smoother_frame_feed(s, f, swap);
00244 }

char* ast_codec2str ( int  codec  ) 

Get a name from a format Gets a name from a format.

Parameters:
codec codec number (1,2,4,8,16,etc.)
Returns:
This returns a static string identifying the format on success, 0 on error.

Definition at line 645 of file frame.c.

References ast_format_list::desc.

Referenced by moh_alloc(), show_codec_n(), show_codec_n_deprecated(), show_codecs(), and show_codecs_deprecated().

00646 {
00647    int x;
00648    char *ret = "unknown";
00649    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
00650       if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == codec) {
00651          ret = AST_FORMAT_LIST[x].desc;
00652          break;
00653       }
00654    }
00655    return ret;
00656 }

int ast_codec_choose ( struct ast_codec_pref pref,
int  formats,
int  find_best 
)

Select the best audio format according to preference list from supplied options. If "find_best" is non-zero then if nothing is found, the "Best" format of the format list is selected, otherwise 0 is returned.

Definition at line 1272 of file frame.c.

References ast_best_codec(), AST_FORMAT_AUDIO_MASK, ast_log(), ast_format_list::bits, LOG_DEBUG, option_debug, and ast_codec_pref::order.

Referenced by __oh323_new(), gtalk_new(), process_sdp(), sip_new(), and socket_process().

01273 {
01274    int x, ret = 0, slot;
01275 
01276    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01277       slot = pref->order[x];
01278 
01279       if (!slot)
01280          break;
01281       if (formats & AST_FORMAT_LIST[slot-1].bits) {
01282          ret = AST_FORMAT_LIST[slot-1].bits;
01283          break;
01284       }
01285    }
01286    if(ret & AST_FORMAT_AUDIO_MASK)
01287       return ret;
01288 
01289    if (option_debug > 3)
01290       ast_log(LOG_DEBUG, "Could not find preferred codec - %s\n", find_best ? "Going for the best codec" : "Returning zero codec");
01291 
01292       return find_best ? ast_best_codec(formats) : 0;
01293 }

int ast_codec_get_len ( int  format,
int  samples 
)

Returns the number of bytes for the number of samples of the given format.

Definition at line 1533 of file frame.c.

References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G722, AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_ILBC, AST_FORMAT_SLINEAR, AST_FORMAT_ULAW, ast_getformatname(), ast_log(), len(), and LOG_WARNING.

Referenced by moh_generate(), and monmp3thread().

01534 {
01535    int len = 0;
01536 
01537    /* XXX Still need speex, g723, and lpc10 XXX */ 
01538    switch(format) {
01539    case AST_FORMAT_ILBC:
01540       len = (samples / 240) * 50;
01541       break;
01542    case AST_FORMAT_GSM:
01543       len = (samples / 160) * 33;
01544       break;
01545    case AST_FORMAT_G729A:
01546       len = samples / 8;
01547       break;
01548    case AST_FORMAT_SLINEAR:
01549       len = samples * 2;
01550       break;
01551    case AST_FORMAT_ULAW:
01552    case AST_FORMAT_ALAW:
01553       len = samples;
01554       break;
01555    case AST_FORMAT_G722:
01556    case AST_FORMAT_ADPCM:
01557    case AST_FORMAT_G726:
01558    case AST_FORMAT_G726_AAL2:
01559       len = samples / 2;
01560       break;
01561    default:
01562       ast_log(LOG_WARNING, "Unable to calculate sample length for format %s\n", ast_getformatname(format));
01563    }
01564 
01565    return len;
01566 }

int ast_codec_get_samples ( struct ast_frame f  ) 

Returns the number of samples contained in the frame.

Definition at line 1490 of file frame.c.

References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G722, AST_FORMAT_G723_1, AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_ILBC, AST_FORMAT_LPC10, AST_FORMAT_SLINEAR, AST_FORMAT_SPEEX, AST_FORMAT_ULAW, ast_getformatname(), ast_log(), ast_frame::data, ast_frame::datalen, g723_samples(), LOG_WARNING, speex_samples(), and ast_frame::subclass.

Referenced by ast_rtp_read(), isAnsweringMachine(), moh_generate(), schedule_delivery(), and socket_process().

01491 {
01492    int samples=0;
01493    switch(f->subclass) {
01494    case AST_FORMAT_SPEEX:
01495       samples = speex_samples(f->data, f->datalen);
01496       break;
01497    case AST_FORMAT_G723_1:
01498                 samples = g723_samples(f->data, f->datalen);
01499       break;
01500    case AST_FORMAT_ILBC:
01501       samples = 240 * (f->datalen / 50);
01502       break;
01503    case AST_FORMAT_GSM:
01504       samples = 160 * (f->datalen / 33);
01505       break;
01506    case AST_FORMAT_G729A:
01507       samples = f->datalen * 8;
01508       break;
01509    case AST_FORMAT_SLINEAR:
01510       samples = f->datalen / 2;
01511       break;
01512    case AST_FORMAT_LPC10:
01513                 /* assumes that the RTP packet contains one LPC10 frame */
01514       samples = 22 * 8;
01515       samples += (((char *)(f->data))[7] & 0x1) * 8;
01516       break;
01517    case AST_FORMAT_ULAW:
01518    case AST_FORMAT_ALAW:
01519       samples = f->datalen;
01520       break;
01521    case AST_FORMAT_G722:
01522    case AST_FORMAT_ADPCM:
01523    case AST_FORMAT_G726:
01524    case AST_FORMAT_G726_AAL2:
01525       samples = f->datalen * 2;
01526       break;
01527    default:
01528       ast_log(LOG_WARNING, "Unable to calculate samples for format %s\n", ast_getformatname(f->subclass));
01529    }
01530    return samples;
01531 }

static int ast_codec_interp_len ( int  format  )  [inline, static]

Gets duration in ms of interpolation frame for a format.

Definition at line 581 of file frame.h.

References AST_FORMAT_ILBC.

Referenced by __get_from_jb(), and jb_get_and_deliver().

00582 { 
00583    return (format == AST_FORMAT_ILBC) ? 30 : 20;
00584 }

int ast_codec_pref_append ( struct ast_codec_pref pref,
int  format 
)

Append a audio codec to a preference list, removing it first if it was already there.

Definition at line 1131 of file frame.c.

References ast_codec_pref_remove(), and ast_codec_pref::order.

Referenced by ast_parse_allow_disallow().

01132 {
01133    int x, newindex = 0;
01134 
01135    ast_codec_pref_remove(pref, format);
01136 
01137    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01138       if(AST_FORMAT_LIST[x].bits == format) {
01139          newindex = x + 1;
01140          break;
01141       }
01142    }
01143 
01144    if(newindex) {
01145       for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01146          if(!pref->order[x]) {
01147             pref->order[x] = newindex;
01148             break;
01149          }
01150       }
01151    }
01152 
01153    return x;
01154 }

void ast_codec_pref_convert ( struct ast_codec_pref pref,
char *  buf,
size_t  size,
int  right 
)

Shift an audio codec preference list up or down 65 bytes so that it becomes an ASCII string.

Note:
Due to a misunderstanding in how codec preferences are stored, this list starts at 'B', not 'A'. For backwards compatibility reasons, this cannot change.
Parameters:
pref A codec preference list structure
buf A string denoting codec preference, appropriate for use in line transmission
size Size of buf
right Boolean: if 0, convert from buf to pref; if 1, convert from pref to buf.

Definition at line 1033 of file frame.c.

References ast_codec_pref::order.

Referenced by check_access(), create_addr(), dump_prefs(), and socket_process().

01034 {
01035    int x, differential = (int) 'A', mem;
01036    char *from, *to;
01037 
01038    if(right) {
01039       from = pref->order;
01040       to = buf;
01041       mem = size;
01042    } else {
01043       to = pref->order;
01044       from = buf;
01045       mem = 32;
01046    }
01047 
01048    memset(to, 0, mem);
01049    for (x = 0; x < 32 ; x++) {
01050       if(!from[x])
01051          break;
01052       to[x] = right ? (from[x] + differential) : (from[x] - differential);
01053    }
01054 }

struct ast_format_list ast_codec_pref_getsize ( struct ast_codec_pref pref,
int  format 
) [read]

Get packet size for codec.

Definition at line 1233 of file frame.c.

References ast_format_list::bits, ast_format_list::cur_ms, ast_format_list::def_ms, format, ast_format_list::inc_ms, ast_format_list::max_ms, and ast_format_list::min_ms.

Referenced by add_codec_to_sdp(), ast_rtp_bridge(), ast_rtp_codec_setpref(), ast_rtp_write(), handle_open_receive_channel_ack_message(), and transmit_connect().

01234 {
01235    int x, index = -1, framems = 0;
01236    struct ast_format_list fmt = {0};
01237 
01238    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01239       if(AST_FORMAT_LIST[x].bits == format) {
01240          fmt = AST_FORMAT_LIST[x];
01241          index = x;
01242          break;
01243       }
01244    }
01245 
01246    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01247       if(pref->order[x] == (index + 1)) {
01248          framems = pref->framing[x];
01249          break;
01250       }
01251    }
01252 
01253    /* size validation */
01254    if(!framems)
01255       framems = AST_FORMAT_LIST[index].def_ms;
01256 
01257    if(AST_FORMAT_LIST[index].inc_ms && framems % AST_FORMAT_LIST[index].inc_ms) /* avoid division by zero */
01258       framems -= framems % AST_FORMAT_LIST[index].inc_ms;
01259 
01260    if(framems < AST_FORMAT_LIST[index].min_ms)
01261       framems = AST_FORMAT_LIST[index].min_ms;
01262 
01263    if(framems > AST_FORMAT_LIST[index].max_ms)
01264       framems = AST_FORMAT_LIST[index].max_ms;
01265 
01266    fmt.cur_ms = framems;
01267 
01268    return fmt;
01269 }

int ast_codec_pref_index ( struct ast_codec_pref pref,
int  index 
)

Codec located at a particular place in the preference index See Audio Codec Preferences.

Definition at line 1091 of file frame.c.

References ast_format_list::bits, and ast_codec_pref::order.

Referenced by _sip_show_peer(), add_sdp(), ast_codec_pref_string(), function_iaxpeer(), function_sippeer(), gtalk_invite(), iax2_show_peer(), print_codec_to_cli(), and socket_process().

01092 {
01093    int slot = 0;
01094 
01095    
01096    if((index >= 0) && (index < sizeof(pref->order))) {
01097       slot = pref->order[index];
01098    }
01099 
01100    return slot ? AST_FORMAT_LIST[slot-1].bits : 0;
01101 }

void ast_codec_pref_init ( struct ast_codec_pref pref  ) 

Initialize an audio codec preference to "no preference" See Audio Codec Preferences.

void ast_codec_pref_prepend ( struct ast_codec_pref pref,
int  format,
int  only_if_existing 
)

Prepend an audio codec to a preference list, removing it first if it was already there.

Definition at line 1157 of file frame.c.

References ARRAY_LEN, ast_codec_pref::framing, and ast_codec_pref::order.

Referenced by create_addr().

01158 {
01159    int x, newindex = 0;
01160 
01161    /* First step is to get the codecs "index number" */
01162    for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01163       if (AST_FORMAT_LIST[x].bits == format) {
01164          newindex = x + 1;
01165          break;
01166       }
01167    }
01168    /* Done if its unknown */
01169    if (!newindex)
01170       return;
01171 
01172    /* Now find any existing occurrence, or the end */
01173    for (x = 0; x < 32; x++) {
01174       if (!pref->order[x] || pref->order[x] == newindex)
01175          break;
01176    }
01177 
01178    if (only_if_existing && !pref->order[x])
01179       return;
01180 
01181    /* Move down to make space to insert - either all the way to the end,
01182       or as far as the existing location (which will be overwritten) */
01183    for (; x > 0; x--) {
01184       pref->order[x] = pref->order[x - 1];
01185       pref->framing[x] = pref->framing[x - 1];
01186    }
01187 
01188    /* And insert the new entry */
01189    pref->order[0] = newindex;
01190    pref->framing[0] = 0; /* ? */
01191 }

void ast_codec_pref_remove ( struct ast_codec_pref pref,
int  format 
)

Remove audio a codec from a preference list.

Definition at line 1104 of file frame.c.

References ast_codec_pref::framing, and ast_codec_pref::order.

Referenced by ast_codec_pref_append(), and ast_parse_allow_disallow().

01105 {
01106    struct ast_codec_pref oldorder;
01107    int x, y = 0;
01108    int slot;
01109    int size;
01110 
01111    if(!pref->order[0])
01112       return;
01113 
01114    memcpy(&oldorder, pref, sizeof(oldorder));
01115    memset(pref, 0, sizeof(*pref));
01116 
01117    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01118       slot = oldorder.order[x];
01119       size = oldorder.framing[x];
01120       if(! slot)
01121          break;
01122       if(AST_FORMAT_LIST[slot-1].bits != format) {
01123          pref->order[y] = slot;
01124          pref->framing[y++] = size;
01125       }
01126    }
01127    
01128 }

int ast_codec_pref_setsize ( struct ast_codec_pref pref,
int  format,
int  framems 
)

Set packet size for codec.

Definition at line 1194 of file frame.c.

References ast_format_list::def_ms, ast_codec_pref::framing, ast_format_list::inc_ms, ast_format_list::max_ms, ast_format_list::min_ms, and ast_codec_pref::order.

Referenced by ast_parse_allow_disallow(), and process_sdp_a_audio().

01195 {
01196    int x, index = -1;
01197 
01198    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01199       if(AST_FORMAT_LIST[x].bits == format) {
01200          index = x;
01201          break;
01202       }
01203    }
01204 
01205    if(index < 0)
01206       return -1;
01207 
01208    /* size validation */
01209    if(!framems)
01210       framems = AST_FORMAT_LIST[index].def_ms;
01211 
01212    if(AST_FORMAT_LIST[index].inc_ms && framems % AST_FORMAT_LIST[index].inc_ms) /* avoid division by zero */
01213       framems -= framems % AST_FORMAT_LIST[index].inc_ms;
01214 
01215    if(framems < AST_FORMAT_LIST[index].min_ms)
01216       framems = AST_FORMAT_LIST[index].min_ms;
01217 
01218    if(framems > AST_FORMAT_LIST[index].max_ms)
01219       framems = AST_FORMAT_LIST[index].max_ms;
01220 
01221 
01222    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01223       if(pref->order[x] == (index + 1)) {
01224          pref->framing[x] = framems;
01225          break;
01226       }
01227    }
01228 
01229    return x;
01230 }

int ast_codec_pref_string ( struct ast_codec_pref pref,
char *  buf,
size_t  size 
)

Dump audio codec preference list into a string.

Definition at line 1056 of file frame.c.

References ast_codec_pref_index(), and ast_getformatname().

Referenced by dump_prefs(), and socket_process().

01057 {
01058    int x, codec; 
01059    size_t total_len, slen;
01060    char *formatname;
01061    
01062    memset(buf,0,size);
01063    total_len = size;
01064    buf[0] = '(';
01065    total_len--;
01066    for(x = 0; x < 32 ; x++) {
01067       if(total_len <= 0)
01068          break;
01069       if(!(codec = ast_codec_pref_index(pref,x)))
01070          break;
01071       if((formatname = ast_getformatname(codec))) {
01072          slen = strlen(formatname);
01073          if(slen > total_len)
01074             break;
01075          strncat(buf, formatname, total_len - 1); /* safe */
01076          total_len -= slen;
01077       }
01078       if(total_len && x < 31 && ast_codec_pref_index(pref , x + 1)) {
01079          strncat(buf, "|", total_len - 1); /* safe */
01080          total_len--;
01081       }
01082    }
01083    if(total_len) {
01084       strncat(buf, ")", total_len - 1); /* safe */
01085       total_len--;
01086    }
01087 
01088    return size - total_len;
01089 }

static force_inline int ast_format_rate ( int  format  )  [static]

Get the sample rate for a given format.

Definition at line 608 of file frame.h.

References AST_FORMAT_G722.

Referenced by __get_from_jb(), ast_read_generator_actions(), ast_readaudio_callback(), ast_readvideo_callback(), ast_rtp_read(), ast_translate(), calc_cost(), calc_timestamp(), generator_force(), rtp_get_rate(), and schedule_delivery().

00609 {
00610    if (format == AST_FORMAT_G722)
00611       return 16000;
00612 
00613    return 8000;
00614 }

int ast_frame_adjust_volume ( struct ast_frame f,
int  adjustment 
)

Adjusts the volume of the audio samples contained in a frame.

Parameters:
f The frame containing the samples (must be AST_FRAME_VOICE and AST_FORMAT_SLINEAR)
adjustment The number of dB to adjust up or down.
Returns:
0 for success, non-zero for an error

Definition at line 1568 of file frame.c.

References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_slinear_saturated_divide(), ast_slinear_saturated_multiply(), ast_frame::data, ast_frame::frametype, ast_frame::samples, and ast_frame::subclass.

Referenced by audiohook_read_frame_single(), and conf_run().

01569 {
01570    int count;
01571    short *fdata = f->data;
01572    short adjust_value = abs(adjustment);
01573 
01574    if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR))
01575       return -1;
01576 
01577    if (!adjustment)
01578       return 0;
01579 
01580    for (count = 0; count < f->samples; count++) {
01581       if (adjustment > 0) {
01582          ast_slinear_saturated_multiply(&fdata[count], &adjust_value);
01583       } else if (adjustment < 0) {
01584          ast_slinear_saturated_divide(&fdata[count], &adjust_value);
01585       }
01586    }
01587 
01588    return 0;
01589 }

void ast_frame_dump ( const char *  name,
struct ast_frame f,
char *  prefix 
)

Dump a frame for debugging purposes

Definition at line 799 of file frame.c.

References AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_OFFHOOK, AST_CONTROL_OPTION, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_TAKEOFFHOOK, AST_CONTROL_WINK, ast_copy_string(), AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_HTML, AST_FRAME_IAX, AST_FRAME_IMAGE, AST_FRAME_MODEM, AST_FRAME_NULL, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_getformatname(), AST_HTML_BEGIN, AST_HTML_DATA, AST_HTML_END, AST_HTML_LDCOMPLETE, AST_HTML_LINKREJECT, AST_HTML_LINKURL, AST_HTML_NOSUPPORT, AST_HTML_UNLINK, AST_HTML_URL, AST_MODEM_T38, AST_MODEM_V150, ast_strlen_zero(), ast_verbose(), COLOR_BLACK, COLOR_BRCYAN, COLOR_BRGREEN, COLOR_BRMAGENTA, COLOR_BRRED, COLOR_YELLOW, ast_frame::data, ast_frame::frametype, ast_frame::subclass, and term_color().

Referenced by __ast_read(), and ast_write().

00800 {
00801    const char noname[] = "unknown";
00802    char ftype[40] = "Unknown Frametype";
00803    char cft[80];
00804    char subclass[40] = "Unknown Subclass";
00805    char csub[80];
00806    char moreinfo[40] = "";
00807    char cn[60];
00808    char cp[40];
00809    char cmn[40];
00810 
00811    if (!name)
00812       name = noname;
00813 
00814 
00815    if (!f) {
00816       ast_verbose("%s [ %s (NULL) ] [%s]\n", 
00817          term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00818          term_color(cft, "HANGUP", COLOR_BRRED, COLOR_BLACK, sizeof(cft)), 
00819          term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00820       return;
00821    }
00822    /* XXX We should probably print one each of voice and video when the format changes XXX */
00823    if (f->frametype == AST_FRAME_VOICE)
00824       return;
00825    if (f->frametype == AST_FRAME_VIDEO)
00826       return;
00827    switch(f->frametype) {
00828    case AST_FRAME_DTMF_BEGIN:
00829       strcpy(ftype, "DTMF Begin");
00830       subclass[0] = f->subclass;
00831       subclass[1] = '\0';
00832       break;
00833    case AST_FRAME_DTMF_END:
00834       strcpy(ftype, "DTMF End");
00835       subclass[0] = f->subclass;
00836       subclass[1] = '\0';
00837       break;
00838    case AST_FRAME_CONTROL:
00839       strcpy(ftype, "Control");
00840       switch(f->subclass) {
00841       case AST_CONTROL_HANGUP:
00842          strcpy(subclass, "Hangup");
00843          break;
00844       case AST_CONTROL_RING:
00845          strcpy(subclass, "Ring");
00846          break;
00847       case AST_CONTROL_RINGING:
00848          strcpy(subclass, "Ringing");
00849          break;
00850       case AST_CONTROL_ANSWER:
00851          strcpy(subclass, "Answer");
00852          break;
00853       case AST_CONTROL_BUSY:
00854          strcpy(subclass, "Busy");
00855          break;
00856       case AST_CONTROL_TAKEOFFHOOK:
00857          strcpy(subclass, "Take Off Hook");
00858          break;
00859       case AST_CONTROL_OFFHOOK:
00860          strcpy(subclass, "Line Off Hook");
00861          break;
00862       case AST_CONTROL_CONGESTION:
00863          strcpy(subclass, "Congestion");
00864          break;
00865       case AST_CONTROL_FLASH:
00866          strcpy(subclass, "Flash");
00867          break;
00868       case AST_CONTROL_WINK:
00869          strcpy(subclass, "Wink");
00870          break;
00871       case AST_CONTROL_OPTION:
00872          strcpy(subclass, "Option");
00873          break;
00874       case AST_CONTROL_RADIO_KEY:
00875          strcpy(subclass, "Key Radio");
00876          break;
00877       case AST_CONTROL_RADIO_UNKEY:
00878          strcpy(subclass, "Unkey Radio");
00879          break;
00880       case -1:
00881          strcpy(subclass, "Stop generators");
00882          break;
00883       default:
00884          snprintf(subclass, sizeof(subclass), "Unknown control '%d'", f->subclass);
00885       }
00886       break;
00887    case AST_FRAME_NULL:
00888       strcpy(ftype, "Null Frame");
00889       strcpy(subclass, "N/A");
00890       break;
00891    case AST_FRAME_IAX:
00892       /* Should never happen */
00893       strcpy(ftype, "IAX Specific");
00894       snprintf(subclass, sizeof(subclass), "IAX Frametype %d", f->subclass);
00895       break;
00896    case AST_FRAME_TEXT:
00897       strcpy(ftype, "Text");
00898       strcpy(subclass, "N/A");
00899       ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00900       break;
00901    case AST_FRAME_IMAGE:
00902       strcpy(ftype, "Image");
00903       snprintf(subclass, sizeof(subclass), "Image format %s\n", ast_getformatname(f->subclass));
00904       break;
00905    case AST_FRAME_HTML:
00906       strcpy(ftype, "HTML");
00907       switch(f->subclass) {
00908       case AST_HTML_URL:
00909          strcpy(subclass, "URL");
00910          ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00911          break;
00912       case AST_HTML_DATA:
00913          strcpy(subclass, "Data");
00914          break;
00915       case AST_HTML_BEGIN:
00916          strcpy(subclass, "Begin");
00917          break;
00918       case AST_HTML_END:
00919          strcpy(subclass, "End");
00920          break;
00921       case AST_HTML_LDCOMPLETE:
00922          strcpy(subclass, "Load Complete");
00923          break;
00924       case AST_HTML_NOSUPPORT:
00925          strcpy(subclass, "No Support");
00926          break;
00927       case AST_HTML_LINKURL:
00928          strcpy(subclass, "Link URL");
00929          ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00930          break;
00931       case AST_HTML_UNLINK:
00932          strcpy(subclass, "Unlink");
00933          break;
00934       case AST_HTML_LINKREJECT:
00935          strcpy(subclass, "Link Reject");
00936          break;
00937       default:
00938          snprintf(subclass, sizeof(subclass), "Unknown HTML frame '%d'\n", f->subclass);
00939          break;
00940       }
00941       break;
00942    case AST_FRAME_MODEM:
00943       strcpy(ftype, "Modem");
00944       switch (f->subclass) {
00945       case AST_MODEM_T38:
00946          strcpy(subclass, "T.38");
00947          break;
00948       case AST_MODEM_V150:
00949          strcpy(subclass, "V.150");
00950          break;
00951       default:
00952          snprintf(subclass, sizeof(subclass), "Unknown MODEM frame '%d'\n", f->subclass);
00953          break;
00954       }
00955       break;
00956    default:
00957       snprintf(ftype, sizeof(ftype), "Unknown Frametype '%d'", f->frametype);
00958    }
00959    if (!ast_strlen_zero(moreinfo))
00960       ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) '%s' ] [%s]\n",  
00961              term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00962              term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00963              f->frametype, 
00964              term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
00965              f->subclass, 
00966              term_color(cmn, moreinfo, COLOR_BRGREEN, COLOR_BLACK, sizeof(cmn)),
00967              term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00968    else
00969       ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) ] [%s]\n",  
00970              term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00971              term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00972              f->frametype, 
00973              term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
00974              f->subclass, 
00975              term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00976 }

struct ast_frame* ast_frame_enqueue ( struct ast_frame head,
struct ast_frame f,
int  maxlen,
int  dupe 
) [read]

Appends a frame to the end of a list of frames, truncating the maximum length of the list.

void ast_frame_free ( struct ast_frame fr,
int  cache 
)

Requests a frame to be allocated.

Parameters:
source Request a frame be allocated. source is an optional source of the frame, len is the requested length, or "0" if the caller will supply the buffer
Frees a frame or list of frames
Parameters:
fr Frame to free, or head of list to free
cache Whether to consider this frame for frame caching

Definition at line 377 of file frame.c.

References __frame_free(), AST_LIST_NEXT, and ast_frame::next.

Referenced by mixmonitor_thread().

00378 {
00379    struct ast_frame *next;
00380 
00381    for (next = AST_LIST_NEXT(frame, frame_list);
00382         frame;
00383         frame = next, next = frame ? AST_LIST_NEXT(frame, frame_list) : NULL) {
00384       __frame_free(frame, cache);
00385    }
00386 }

int ast_frame_slinear_sum ( struct ast_frame f1,
struct ast_frame f2 
)

Sums two frames of audio samples.

Parameters:
f1 The first frame (which will contain the result)
f2 The second frame
Returns:
0 for success, non-zero for an error
The frames must be AST_FRAME_VOICE and must contain AST_FORMAT_SLINEAR samples, and must contain the same number of samples.

Definition at line 1591 of file frame.c.

References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_slinear_saturated_add(), ast_frame::data, ast_frame::frametype, ast_frame::samples, and ast_frame::subclass.

01592 {
01593    int count;
01594    short *data1, *data2;
01595 
01596    if ((f1->frametype != AST_FRAME_VOICE) || (f1->subclass != AST_FORMAT_SLINEAR))
01597       return -1;
01598 
01599    if ((f2->frametype != AST_FRAME_VOICE) || (f2->subclass != AST_FORMAT_SLINEAR))
01600       return -1;
01601 
01602    if (f1->samples != f2->samples)
01603       return -1;
01604 
01605    for (count = 0, data1 = f1->data, data2 = f2->data;
01606         count < f1->samples;
01607         count++, data1++, data2++)
01608       ast_slinear_saturated_add(data1, data2);
01609 
01610    return 0;
01611 }

struct ast_frame* ast_frdup ( const struct ast_frame fr  )  [read]

Copies a frame.

Parameters:
fr frame to copy Duplicates a frame -- should only rarely be used, typically frisolate is good enough
Returns:
Returns a frame on success, NULL on error

Definition at line 471 of file frame.c.

References ast_calloc_cache, ast_copy_flags, AST_FRFLAG_HAS_TIMING_INFO, AST_FRIENDLY_OFFSET, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_MALLOCD_HDR, ast_threadstorage_get(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, frame_cache, frames, ast_frame::frametype, ast_frame::len, len(), ast_frame_cache::list, ast_frame::mallocd, ast_frame::mallocd_hdr_len, ast_frame::offset, ast_frame::samples, ast_frame::seqno, ast_frame_cache::size, ast_frame::src, ast_frame::subclass, and ast_frame::ts.

Referenced by __ast_queue_frame(), ast_frisolate(), ast_jb_put(), ast_rtp_write(), ast_slinfactory_feed(), audiohook_read_frame_both(), audiohook_read_frame_single(), autoservice_run(), process_rfc2833(), recordthread(), rpt(), and rpt_exec().

00472 {
00473    struct ast_frame *out = NULL;
00474    int len, srclen = 0;
00475    void *buf = NULL;
00476 
00477 #if !defined(LOW_MEMORY)
00478    struct ast_frame_cache *frames;
00479 #endif
00480 
00481    /* Start with standard stuff */
00482    len = sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
00483    /* If we have a source, add space for it */
00484    /*
00485     * XXX Watch out here - if we receive a src which is not terminated
00486     * properly, we can be easily attacked. Should limit the size we deal with.
00487     */
00488    if (f->src)
00489       srclen = strlen(f->src);
00490    if (srclen > 0)
00491       len += srclen + 1;
00492    
00493 #if !defined(LOW_MEMORY)
00494    if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
00495       AST_LIST_TRAVERSE_SAFE_BEGIN(&frames->list, out, frame_list) {
00496          if (out->mallocd_hdr_len >= len) {
00497             size_t mallocd_len = out->mallocd_hdr_len;
00498             AST_LIST_REMOVE_CURRENT(&frames->list, frame_list);
00499             memset(out, 0, sizeof(*out));
00500             out->mallocd_hdr_len = mallocd_len;
00501             buf = out;
00502             frames->size--;
00503             break;
00504          }
00505       }
00506       AST_LIST_TRAVERSE_SAFE_END;
00507    }
00508 #endif
00509 
00510    if (!buf) {
00511       if (!(buf = ast_calloc_cache(1, len)))
00512          return NULL;
00513       out = buf;
00514       out->mallocd_hdr_len = len;
00515    }
00516 
00517    out->frametype = f->frametype;
00518    out->subclass = f->subclass;
00519    out->datalen = f->datalen;
00520    out->samples = f->samples;
00521    out->delivery = f->delivery;
00522    /* Set us as having malloc'd header only, so it will eventually
00523       get freed. */
00524    out->mallocd = AST_MALLOCD_HDR;
00525    out->offset = AST_FRIENDLY_OFFSET;
00526    if (out->datalen) {
00527       out->data = buf + sizeof(*out) + AST_FRIENDLY_OFFSET;
00528       memcpy(out->data, f->data, out->datalen); 
00529    }
00530    if (srclen > 0) {
00531       /* This may seem a little strange, but it's to avoid a gcc (4.2.4) compiler warning */
00532       char *src;
00533       out->src = buf + sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
00534       src = (char *) out->src;
00535       /* Must have space since we allocated for it */
00536       strcpy(src, f->src);
00537    }
00538    ast_copy_flags(out, f, AST_FRFLAG_HAS_TIMING_INFO);
00539    out->ts = f->ts;
00540    out->len = f->len;
00541    out->seqno = f->seqno;
00542    return out;
00543 }

struct ast_frame* ast_frisolate ( struct ast_frame fr  )  [read]

Makes a frame independent of any static storage.

Parameters:
fr frame to act upon Take a frame, and if it's not been malloc'd, make a malloc'd copy and if the data hasn't been malloced then make the data malloc'd. If you need to store frames, say for queueing, then you should call this function.
Returns:
Returns a frame on success, NULL on error
Note:
This function may modify the frame passed to it, so you must not assume the frame will be intact after the isolated frame has been produced. In other words, calling this function on a frame should be the last operation you do with that frame before freeing it (or exiting the block, if the frame is on the stack.)

Definition at line 393 of file frame.c.

References ast_copy_flags, ast_frame_header_new(), ast_frdup(), AST_FRFLAG_HAS_TIMING_INFO, AST_FRIENDLY_OFFSET, ast_malloc, AST_MALLOCD_DATA, AST_MALLOCD_HDR, AST_MALLOCD_SRC, ast_strdup, ast_test_flag, ast_frame::data, ast_frame::datalen, ast_frame::frametype, free, ast_frame::len, ast_frame::mallocd, ast_frame::offset, ast_frame::samples, ast_frame::seqno, ast_frame::src, ast_frame::subclass, and ast_frame::ts.

Referenced by ast_dsp_process(), ast_rtp_read(), ast_safe_sleep_conditional(), ast_slinfactory_feed(), ast_trans_frameout(), ast_write(), autoservice_run(), dahdi_decoder_frameout(), dahdi_encoder_frameout(), feature_request_and_dial(), jpeg_read_image(), and read_frame().

00394 {
00395    struct ast_frame *out;
00396    void *newdata;
00397 
00398    /* if none of the existing frame is malloc'd, let ast_frdup() do it
00399       since it is more efficient
00400    */
00401    if (fr->mallocd == 0) {
00402       return ast_frdup(fr);
00403    }
00404 
00405    /* if everything is already malloc'd, we are done */
00406    if ((fr->mallocd & (AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA)) ==
00407        (AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA)) {
00408       return fr;
00409    }
00410 
00411    if (!(fr->mallocd & AST_MALLOCD_HDR)) {
00412       /* Allocate a new header if needed */
00413       if (!(out = ast_frame_header_new())) {
00414          return NULL;
00415       }
00416       out->frametype = fr->frametype;
00417       out->subclass = fr->subclass;
00418       out->datalen = fr->datalen;
00419       out->samples = fr->samples;
00420       out->offset = fr->offset;
00421       /* Copy the timing data */
00422       ast_copy_flags(out, fr, AST_FRFLAG_HAS_TIMING_INFO);
00423       if (ast_test_flag(fr, AST_FRFLAG_HAS_TIMING_INFO)) {
00424          out->ts = fr->ts;
00425          out->len = fr->len;
00426          out->seqno = fr->seqno;
00427       }
00428    } else {
00429       out = fr;
00430    }
00431    
00432    if (!(fr->mallocd & AST_MALLOCD_SRC) && fr->src) {
00433       if (!(out->src = ast_strdup(fr->src))) {
00434          if (out != fr) {
00435             free(out);
00436          }
00437          return NULL;
00438       }
00439    } else {
00440       out->src = fr->src;
00441       fr->src = NULL;
00442       fr->mallocd &= ~AST_MALLOCD_SRC;
00443    }
00444    
00445    if (!(fr->mallocd & AST_MALLOCD_DATA))  {
00446       if (!(newdata = ast_malloc(fr->datalen + AST_FRIENDLY_OFFSET))) {
00447          if (out->src != fr->src) {
00448             free((void *) out->src);
00449          }
00450          if (out != fr) {
00451             free(out);
00452          }
00453          return NULL;
00454       }
00455       newdata += AST_FRIENDLY_OFFSET;
00456       out->offset = AST_FRIENDLY_OFFSET;
00457       out->datalen = fr->datalen;
00458       memcpy(newdata, fr->data, fr->datalen);
00459       out->data = newdata;
00460    } else {
00461       out->data = fr->data;
00462       fr->data = NULL;
00463       fr->mallocd &= ~AST_MALLOCD_DATA;
00464    }
00465 
00466    out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA;
00467    
00468    return out;
00469 }

struct ast_format_list* ast_get_format_list ( size_t *  size  )  [read]

Definition at line 561 of file frame.c.

00562 {
00563    *size = (sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]));
00564    return AST_FORMAT_LIST;
00565 }

struct ast_format_list* ast_get_format_list_index ( int  index  )  [read]

Definition at line 556 of file frame.c.

00557 {
00558    return &AST_FORMAT_LIST[index];
00559 }

int ast_getformatbyname ( const char *  name  ) 

Gets a format from a name.

Parameters:
name string of format
Returns:
This returns the form of the format in binary on success, 0 on error.

Definition at line 627 of file frame.c.

References ast_expand_codec_alias(), ast_format_list::bits, and format.

Referenced by ast_parse_allow_disallow(), iax_template_parse(), load_moh_classes(), reload_config(), and try_suggested_sip_codec().

00628 {
00629    int x, all, format = 0;
00630 
00631    all = strcasecmp(name, "all") ? 0 : 1;
00632    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
00633       if(AST_FORMAT_LIST[x].visible && (all || 
00634            !strcasecmp(AST_FORMAT_LIST[x].name,name) ||
00635            !strcasecmp(AST_FORMAT_LIST[x].name,ast_expand_codec_alias(name)))) {
00636          format |= AST_FORMAT_LIST[x].bits;
00637          if(!all)
00638             break;
00639       }
00640    }
00641 
00642    return format;
00643 }

char* ast_getformatname ( int  format  ) 

Get the name of a format.

Parameters:
format id of format
Returns:
A static string containing the name of the format or "unknown" if unknown.

Definition at line 567 of file frame.c.

References ast_format_list::bits, ast_format_list::name, and ast_format_list::visible.

Referenced by __ast_play_and_record(), __ast_read(), __ast_register_translator(), __login_exec(), _sip_show_peer(), add_codec_to_answer(), add_codec_to_sdp(), agent_call(), ast_codec_get_len(), ast_codec_get_samples(), ast_codec_pref_string(), ast_dsp_process(), ast_frame_dump(), ast_openvstream(), ast_rtp_write(), ast_slinfactory_feed(), ast_streamfile(), ast_translator_build_path(), ast_unregister_translator(), ast_writestream(), background_detect_exec(), dahdi_read(), do_waiting(), eagi_exec(), func_channel_read(), function_iaxpeer(), function_sippeer(), gtalk_show_channels(), iax2_request(), iax2_show_channels(), iax2_show_peer(), iax_show_provisioning(), moh_classes_show(), moh_release(), oh323_rtp_read(), phone_setup(), print_codec_to_cli(), rebuild_matrix(), register_translator(), set_format(), set_local_capabilities(), set_peer_capabilities(), show_codecs(), show_codecs_deprecated(), show_file_formats(), show_file_formats_deprecated(), show_image_formats(), show_image_formats_deprecated(), show_translation(), show_translation_deprecated(), sip_request_call(), sip_rtp_read(), and socket_process().

00568 {
00569    int x;
00570    char *ret = "unknown";
00571    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
00572       if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == format) {
00573          ret = AST_FORMAT_LIST[x].name;
00574          break;
00575       }
00576    }
00577    return ret;
00578 }

char* ast_getformatname_multiple ( char *  buf,
size_t  size,
int  format 
)

Get the names of a set of formats.

Parameters:
buf a buffer for the output string
size size of buf (bytes)
format the format (combined IDs of codecs) Prints a list of readable codec names corresponding to "format". ex: for format=AST_FORMAT_GSM|AST_FORMAT_SPEEX|AST_FORMAT_ILBC it will return "0x602 (GSM|SPEEX|ILBC)"
Returns:
The return value is buf.

Definition at line 580 of file frame.c.

References ast_format_list::bits, len(), name, and ast_format_list::visible.

Referenced by __ast_read(), __sip_show_channels(), _sip_show_peer(), add_sdp(), ast_streamfile(), function_iaxpeer(), function_sippeer(), gtalk_is_answered(), gtalk_newcall(), handle_showchan(), handle_showchan_deprecated(), iax2_bridge(), iax2_show_peer(), process_sdp(), serialize_showchan(), set_format(), sip_new(), sip_request_call(), sip_show_channel(), sip_show_settings(), and sip_write().

00581 {
00582    int x;
00583    unsigned len;
00584    char *start, *end = buf;
00585 
00586    if (!size)
00587       return buf;
00588    snprintf(end, size, "0x%x (", format);
00589    len = strlen(end);
00590    end += len;
00591    size -= len;
00592    start = end;
00593    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
00594       if (AST_FORMAT_LIST[x].visible && (AST_FORMAT_LIST[x].bits & format)) {
00595          snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name);
00596          len = strlen(end);
00597          end += len;
00598          size -= len;
00599       }
00600    }
00601    if (start == end)
00602       snprintf(start, size, "nothing)");
00603    else if (size > 1)
00604       *(end -1) = ')';
00605    return buf;
00606 }

void ast_parse_allow_disallow ( struct ast_codec_pref pref,
int *  mask,
const char *  list,
int  allowing 
)

Parse an "allow" or "deny" line in a channel or device configuration and update the capabilities mask and pref if provided. Video codecs are not added to codec preference lists, since we can not transcode.

Definition at line 1295 of file frame.c.

References ast_codec_pref_append(), ast_codec_pref_remove(), ast_codec_pref_setsize(), AST_FORMAT_AUDIO_MASK, ast_getformatbyname(), ast_log(), ast_strdupa, format, LOG_DEBUG, LOG_WARNING, option_debug, and parse().

Referenced by action_originate(), apply_outgoing(), build_device(), build_peer(), build_user(), gtalk_create_member(), gtalk_load_config(), reload_config(), set_config(), and update_common_options().

01296 {
01297    char *parse = NULL, *this = NULL, *psize = NULL;
01298    int format = 0, framems = 0;
01299 
01300    parse = ast_strdupa(list);
01301    while ((this = strsep(&parse, ","))) {
01302       framems = 0;
01303       if ((psize = strrchr(this, ':'))) {
01304          *psize++ = '\0';
01305          if (option_debug)
01306             ast_log(LOG_DEBUG,"Packetization for codec: %s is %s\n", this, psize);
01307          framems = atoi(psize);
01308          if (framems < 0)
01309             framems = 0;
01310       }
01311       if (!(format = ast_getformatbyname(this))) {
01312          ast_log(LOG_WARNING, "Cannot %s unknown format '%s'\n", allowing ? "allow" : "disallow", this);
01313          continue;
01314       }
01315 
01316       if (mask) {
01317          if (allowing)
01318             *mask |= format;
01319          else
01320             *mask &= ~format;
01321       }
01322 
01323       /* Set up a preference list for audio. Do not include video in preferences 
01324          since we can not transcode video and have to use whatever is offered
01325        */
01326       if (pref && (format & AST_FORMAT_AUDIO_MASK)) {
01327          if (strcasecmp(this, "all")) {
01328             if (allowing) {
01329                ast_codec_pref_append(pref, format);
01330                ast_codec_pref_setsize(pref, format, framems);
01331             }
01332             else
01333                ast_codec_pref_remove(pref, format);
01334          } else if (!allowing) {
01335             memset(pref, 0, sizeof(*pref));
01336          }
01337       }
01338    }
01339 }

void ast_smoother_free ( struct ast_smoother s  ) 

Definition at line 296 of file frame.c.

References free.

Referenced by ast_rtp_destroy(), and ast_rtp_write().

00297 {
00298    free(s);
00299 }

int ast_smoother_get_flags ( struct ast_smoother smoother  ) 

Definition at line 196 of file frame.c.

References ast_smoother::flags.

00197 {
00198    return s->flags;
00199 }

struct ast_smoother* ast_smoother_new ( int  bytes  )  [read]

Definition at line 186 of file frame.c.

References ast_malloc, ast_smoother_reset(), and s.

Referenced by ast_rtp_codec_setpref(), and ast_rtp_write().

00187 {
00188    struct ast_smoother *s;
00189    if (size < 1)
00190       return NULL;
00191    if ((s = ast_malloc(sizeof(*s))))
00192       ast_smoother_reset(s, size);
00193    return s;
00194 }

struct ast_frame* ast_smoother_read ( struct ast_smoother s  )  [read]

Definition at line 246 of file frame.c.

References AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), ast_samp2tv(), AST_SMOOTHER_FLAG_G729, ast_tvadd(), ast_tvzero(), ast_smoother::data, ast_frame::data, ast_frame::datalen, ast_smoother::delivery, ast_frame::delivery, ast_smoother::f, ast_smoother::flags, ast_smoother::format, ast_smoother::framedata, ast_frame::frametype, ast_smoother::len, len(), LOG_WARNING, ast_frame::offset, ast_smoother::opt, ast_frame::samples, ast_smoother::samplesperbyte, ast_smoother::size, and ast_frame::subclass.

Referenced by ast_rtp_write().

00247 {
00248    struct ast_frame *opt;
00249    int len;
00250 
00251    /* IF we have an optimization frame, send it */
00252    if (s->opt) {
00253       if (s->opt->offset < AST_FRIENDLY_OFFSET)
00254          ast_log(LOG_WARNING, "Returning a frame of inappropriate offset (%d).\n",
00255                      s->opt->offset);
00256       opt = s->opt;
00257       s->opt = NULL;
00258       return opt;
00259    }
00260 
00261    /* Make sure we have enough data */
00262    if (s->len < s->size) {
00263       /* Or, if this is a G.729 frame with VAD on it, send it immediately anyway */
00264       if (!((s->flags & AST_SMOOTHER_FLAG_G729) && (s->len % 10)))
00265          return NULL;
00266    }
00267    len = s->size;
00268    if (len > s->len)
00269       len = s->len;
00270    /* Make frame */
00271    s->f.frametype = AST_FRAME_VOICE;
00272    s->f.subclass = s->format;
00273    s->f.data = s->framedata + AST_FRIENDLY_OFFSET;
00274    s->f.offset = AST_FRIENDLY_OFFSET;
00275    s->f.datalen = len;
00276    /* Samples will be improper given VAD, but with VAD the concept really doesn't even exist */
00277    s->f.samples = len * s->samplesperbyte;   /* XXX rounding */
00278    s->f.delivery = s->delivery;
00279    /* Fill Data */
00280    memcpy(s->f.data, s->data, len);
00281    s->len -= len;
00282    /* Move remaining data to the front if applicable */
00283    if (s->len) {
00284       /* In principle this should all be fine because if we are sending
00285          G.729 VAD, the next timestamp will take over anyawy */
00286       memmove(s->data, s->data + len, s->len);
00287       if (!ast_tvzero(s->delivery)) {
00288          /* If we have delivery time, increment it, otherwise, leave it at 0 */
00289          s->delivery = ast_tvadd(s->delivery, ast_samp2tv(s->f.samples, 8000));
00290       }
00291    }
00292    /* Return frame */
00293    return &s->f;
00294 }

void ast_smoother_reconfigure ( struct ast_smoother s,
int  bytes 
)

Reconfigure an existing smoother to output a different number of bytes per frame.

Parameters:
s the smoother to reconfigure
bytes the desired number of bytes per output frame
Returns:
nothing

Definition at line 164 of file frame.c.

References ast_smoother::opt, ast_smoother::opt_needs_swap, ast_smoother::size, and smoother_frame_feed().

Referenced by ast_rtp_codec_setpref().

00165 {
00166    /* if there is no change, then nothing to do */
00167    if (s->size == bytes) {
00168       return;
00169    }
00170    /* set the new desired output size */
00171    s->size = bytes;
00172    /* if there is no 'optimized' frame in the smoother,
00173     *   then there is nothing left to do
00174     */
00175    if (!s->opt) {
00176       return;
00177    }
00178    /* there is an 'optimized' frame here at the old size,
00179     * but it must now be put into the buffer so the data
00180     * can be extracted at the new size
00181     */
00182    smoother_frame_feed(s, s->opt, s->opt_needs_swap);
00183    s->opt = NULL;
00184 }

void ast_smoother_reset ( struct ast_smoother s,
int  bytes 
)

Definition at line 158 of file frame.c.

References ast_smoother::size.

Referenced by ast_smoother_new().

00159 {
00160    memset(s, 0, sizeof(*s));
00161    s->size = bytes;
00162 }

void ast_smoother_set_flags ( struct ast_smoother smoother,
int  flags 
)

Definition at line 201 of file frame.c.

References ast_smoother::flags.

Referenced by ast_rtp_codec_setpref(), and ast_rtp_write().

00202 {
00203    s->flags = flags;
00204 }

int ast_smoother_test_flag ( struct ast_smoother s,
int  flag 
)

Definition at line 206 of file frame.c.

References ast_smoother::flags.

Referenced by ast_rtp_write().

00207 {
00208    return (s->flags & flag);
00209 }

void ast_swapcopy_samples ( void *  dst,
const void *  src,
int  samples 
)

Definition at line 545 of file frame.c.

Referenced by __ast_smoother_feed(), iax_frame_wrap(), phone_write_buf(), and smoother_frame_feed().

00546 {
00547    int i;
00548    unsigned short *dst_s = dst;
00549    const unsigned short *src_s = src;
00550 
00551    for (i = 0; i < samples; i++)
00552       dst_s[i] = (src_s[i]<<8) | (src_s[i]>>8);
00553 }


Variable Documentation


Generated on Thu Oct 11 06:43:37 2012 for Asterisk - the Open Source PBX by  doxygen 1.5.6