*
*/
/*! \file switch_core.h
- \brief Core Library
+ \brief Core Library
- This module is the main core library and is the intended location of all fundamental operations.
+ This module is the main core library and is the intended location of all fundamental operations.
*/
#ifndef SWITCH_CORE_H
#ifdef __cplusplus
extern "C" {
#endif
+#ifdef _FORMATBUG
+}
+#endif
#include <switch.h>
\param session the session to add the stream to
\param private_info an optional pointer to private data for the new stream
\return the stream id of the new stream
- */
+*/
SWITCH_DECLARE(int) switch_core_session_add_stream(switch_core_session *session, void *private_info);
/*!
\param session the session to add the stream to
\param index the index to retrieve
\return the stream
- */
+*/
SWITCH_DECLARE(void *) switch_core_session_get_stream(switch_core_session *session, int index);
/*!
\brief Determine the number of logical streams a session has
\param session the session to query
\return the total number of logical streams
- */
+*/
SWITCH_DECLARE(int) switch_core_session_get_stream_count(switch_core_session *session);
/*!
*/
SWITCH_DECLARE(switch_status) switch_core_codec_init(switch_codec *codec,
char *codec_name,
- int rate,
+ uint32_t rate,
int ms,
int channels,
uint32_t flags,
\note encoded_data_len will be rewritten to the in-use size of encoded_data
*/
SWITCH_DECLARE(switch_status) switch_core_codec_encode(switch_codec *codec,
- switch_codec *other_codec,
- void *decoded_data,
- switch_size_t decoded_data_len,
- int decoded_rate,
- void *encoded_data,
- switch_size_t *encoded_data_len,
- int *encoded_rate,
- unsigned int *flag);
+ switch_codec *other_codec,
+ void *decoded_data,
+ uint32_t decoded_data_len,
+ uint32_t decoded_rate,
+ void *encoded_data,
+ uint32_t *encoded_data_len,
+ uint32_t *encoded_rate,
+ unsigned int *flag);
/*!
\brief Decode data using a codec handle
\note decoded_data_len will be rewritten to the in-use size of decoded_data
*/
SWITCH_DECLARE(switch_status) switch_core_codec_decode(switch_codec *codec,
- switch_codec *other_codec,
- void *encoded_data,
- switch_size_t encoded_data_len,
- int encoded_rate,
- void *decoded_data,
- switch_size_t *decoded_data_len,
- int *decoded_rate,
- unsigned int *flag);
+ switch_codec *other_codec,
+ void *encoded_data,
+ uint32_t encoded_data_len,
+ uint32_t encoded_rate,
+ void *decoded_data,
+ uint32_t *decoded_data_len,
+ uint32_t *decoded_rate,
+ unsigned int *flag);
/*!
\brief Destroy an initalized codec handle
\param flags flags in/out for fine tuning
\return SWITCH_STATUS_SUCCESS with len adjusted to the bytes written if successful
*/
- SWITCH_DECLARE(switch_status) switch_core_speech_read_tts(switch_speech_handle *sh,
+SWITCH_DECLARE(switch_status) switch_core_speech_read_tts(switch_speech_handle *sh,
void *data,
switch_size_t *datalen,
- switch_size_t *rate,
+ uint32_t *rate,
switch_speech_flag *flags);
/*!
\brief Close an open speech handle
/*! the frame data */
void *data;
/*! the size of the buffer that is in use */
- switch_size_t datalen;
+ uint32_t datalen;
/*! the entire size of the buffer */
- switch_size_t buflen;
+ uint32_t buflen;
/*! the number of audio samples present (audio only) */
- switch_size_t samples;
+ uint32_t samples;
/*! the rate of the frame */
- int rate;
+ uint32_t rate;
/*! frame flags */
switch_frame_flag flags;
};
char *tts_name,
char *voice_name,
char *timer_name,
- switch_size_t rate,
+ uint32_t rate,
switch_dtmf_callback_function dtmf_callback,
char *text,
void *buf,
/*! samples position of the handle */
unsigned int samples;
/*! the current samplerate */
- unsigned int samplerate;
+ uint32_t samplerate;
/*! the number of channels */
- unsigned int channels;
+ uint8_t channels;
/*! integer representation of the format */
unsigned int format;
/*! integer representation of the sections */
switch_status (*speech_read_tts)(switch_speech_handle *sh,
void *data,
switch_size_t *datalen,
- switch_size_t *rate,
+ uint32_t *rate,
switch_speech_flag *flags);
const struct switch_speech_interface *next;
/*! \brief A table of settings and callbacks that define a paticular implementation of a codec */
struct switch_codec_implementation {
/*! samples transferred per second */
- int samples_per_second;
+ uint32_t samples_per_second;
/*! bits transferred per second */
int bits_per_second;
/*! number of microseconds that denote one frame */
int microseconds_per_frame;
/*! number of samples that denote one frame */
- int samples_per_frame;
+ uint32_t samples_per_frame;
/*! number of bytes that denote one frame decompressed */
- switch_size_t bytes_per_frame;
+ uint32_t bytes_per_frame;
/*! number of bytes that denote one frame compressed */
- int encoded_bytes_per_frame;
+ uint32_t encoded_bytes_per_frame;
/*! number of channels represented */
- int number_of_channels;
+ uint8_t number_of_channels;
/*! number of frames to send in one netowrk packet */
int pref_frames_per_packet;
/*! max number of frames to send in one network packet */
switch_status (*encode)(switch_codec *codec,
switch_codec *other_codec,
void *decoded_data,
- switch_size_t decoded_data_len,
- int decoded_rate,
+ uint32_t decoded_data_len,
+ uint32_t decoded_rate,
void *encoded_data,
- switch_size_t *encoded_data_len,
- int *encoded_rate,
+ uint32_t *encoded_data_len,
+ uint32_t *encoded_rate,
unsigned int *flag);
/*! function to decode encoded data into raw data */
switch_status (*decode)(switch_codec *codec,
switch_codec *other_codec,
void *encoded_data,
- switch_size_t encoded_data_len,
- int encoded_rate,
+ uint32_t encoded_data_len,
+ uint32_t encoded_rate,
void *decoded_data,
- switch_size_t *decoded_data_len,
- int *decoded_rate,
+ uint32_t *decoded_data_len,
+ uint32_t *decoded_rate,
unsigned int *flag);
/*! deinitalize a codec handle using this implementation */
switch_status (*destroy)(switch_codec *);
/*! enumeration defining the type of the codec */
const switch_codec_type codec_type;
/*! the IANA code number */
- unsigned int ianacode;
+ uint8_t ianacode;
/*! the IANA code name */
char *iananame;
/*! a list of codec implementations related to the codec */
/*! a pointer to store a float buffer for resampled data */
float *to;
/*! the size of the to buffer used */
- int to_len;
+ uint32_t to_len;
/*! the total size of the to buffer */
- switch_size_t to_size;
+ uint32_t to_size;
};
/*!
int from_rate,
switch_size_t from_size,
int to_rate,
- switch_size_t to_size,
+ uint32_t to_size,
switch_memory_pool *pool);
/*!
\param last parameter denoting the last sample is being resampled
\return the used size of dst
*/
-SWITCH_DECLARE(int) switch_resample_process(switch_audio_resampler *resampler, float *src, int srclen, float *dst, int dstlen, int last);
+SWITCH_DECLARE(uint32_t) switch_resample_process(switch_audio_resampler *resampler, float *src, int srclen, float *dst, uint32_t dstlen, int last);
/*!
\brief Convert an array of floats to an array of shorts
\return the new RTP session or NULL on failure
*/
SWITCH_DECLARE(switch_status)switch_rtp_create(switch_rtp **new_rtp_session,
- int payload,
- switch_size_t packet_size,
+ uint8_t payload,
+ uint32_t packet_size,
uint32_t ms_per_packet,
switch_rtp_flag_t flags,
const char **err,
switch_port_t rx_port,
char *tx_host,
switch_port_t tx_port,
- int payload,
- switch_size_t packet_size,
+ uint8_t payload,
+ uint32_t packet_size,
uint32_t ms_per_packet,
switch_rtp_flag_t flags,
const char **err,
\param rtp_session the RTP session to set the packet size on
\param packet_size the new default packet size
*/
-SWITCH_DECLARE(void) switch_rtp_set_default_packet_size(switch_rtp *rtp_session, uint32_t packet_size);
+SWITCH_DECLARE(void) switch_rtp_set_default_packet_size(switch_rtp *rtp_session, uint16_t packet_size);
/*!
\brief Get the default packet size for a given RTP session
\param rtp_session the RTP session to set the payload number on
\param payload the new default payload number
*/
-SWITCH_DECLARE(void) switch_rtp_set_default_payload(switch_rtp *rtp_session, uint32_t payload);
+SWITCH_DECLARE(void) switch_rtp_set_default_payload(switch_rtp *rtp_session, uint8_t payload);
/*!
\brief Get the default payload number for a given RTP session
\param ts then number of bytes to increment the timestamp by
\return the number of bytes written
*/
-SWITCH_DECLARE(int) switch_rtp_write(switch_rtp *rtp_session, void *data, int datalen, uint32_t ts);
+SWITCH_DECLARE(int) switch_rtp_write(switch_rtp *rtp_session, void *data, uint32_t datalen, uint32_t ts);
/*!
\brief Write data with a specified payload and sequence number to a given RTP session
\param mseq the specific sequence number to use
\return the number of bytes written
*/
-SWITCH_DECLARE(int) switch_rtp_write_payload(switch_rtp *rtp_session, void *data, int datalen, uint8_t payload, uint32_t ts, uint16_t mseq);
+SWITCH_DECLARE(int) switch_rtp_write_payload(switch_rtp *rtp_session, void *data, uint16_t datalen, uint8_t payload, uint32_t ts, uint16_t mseq);
/*!
\brief Retrieve the SSRC from a given RTP session
SWITCH_EVENT_ALL
} switch_event_t;
-
typedef struct switch_rtp switch_rtp;
typedef struct switch_core_session_message switch_core_session_message;
typedef struct switch_audio_resampler switch_audio_resampler;
static switch_status switch_g711u_encode(switch_codec *codec,
switch_codec *other_codec,
void *decoded_data,
- size_t decoded_data_len,
- int decoded_rate,
+ uint32_t decoded_data_len,
+ uint32_t decoded_rate,
void *encoded_data,
- size_t *encoded_data_len, int *encoded_rate, unsigned int *flag)
+ uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag)
{
short *dbuf;
unsigned char *ebuf;
- size_t i;
+ uint32_t i;
dbuf = decoded_data;
ebuf = encoded_data;
static switch_status switch_g711u_decode(switch_codec *codec,
switch_codec *other_codec,
void *encoded_data,
- size_t encoded_data_len,
- int encoded_rate,
+ uint32_t encoded_data_len,
+ uint32_t encoded_rate,
void *decoded_data,
- size_t *decoded_data_len, int *decoded_rate, unsigned int *flag)
+ uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag)
{
short *dbuf;
unsigned char *ebuf;
- size_t i;
+ uint32_t i;
dbuf = decoded_data;
ebuf = encoded_data;
static switch_status switch_g711a_encode(switch_codec *codec,
switch_codec *other_codec,
void *decoded_data,
- size_t decoded_data_len,
- int decoded_rate,
+ uint32_t decoded_data_len,
+ uint32_t decoded_rate,
void *encoded_data,
- size_t *encoded_data_len, int *encoded_rate, unsigned int *flag)
+ uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag)
{
short *dbuf;
unsigned char *ebuf;
- size_t i;
+ uint32_t i;
dbuf = decoded_data;
ebuf = encoded_data;
static switch_status switch_g711a_decode(switch_codec *codec,
switch_codec *other_codec,
void *encoded_data,
- size_t encoded_data_len,
- int encoded_rate,
+ uint32_t encoded_data_len,
+ uint32_t encoded_rate,
void *decoded_data,
- size_t *decoded_data_len, int *decoded_rate, unsigned int *flag)
+ uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag)
{
short *dbuf;
unsigned char *ebuf;
- size_t i;
+ uint32_t i;
dbuf = decoded_data;
ebuf = encoded_data;
switch_codec *other_codec,
void *decoded_data,
- size_t decoded_data_len,
- int decoded_rate,
+ uint32_t decoded_data_len,
+ uint32_t decoded_rate,
void *encoded_data,
- size_t *encoded_data_len,
- int *encoded_rate,
+ uint32_t *encoded_data_len,
+ uint32_t *encoded_rate,
unsigned int *flag)
{
}
if (decoded_data_len % 160 == 0) {
- unsigned int new_len = 0;
+ uint32_t new_len = 0;
INT16 * ddp = decoded_data;
char *edp = encoded_data;
int x;
switch_codec *other_codec,
void *encoded_data,
- size_t encoded_data_len,
- int encoded_rate,
+ uint32_t encoded_data_len,
+ uint32_t encoded_rate,
void *decoded_data,
- size_t *decoded_data_len,
- int *decoded_rate,
+ uint32_t *decoded_data_len,
+ uint32_t *decoded_rate,
unsigned int *flag)
{
int x;
- unsigned int new_len = 0;
+ uint32_t new_len = 0;
test = (uint8_t *) encoded_data;
if (*test == 0 && *(test+1) == 0) {
return SWITCH_STATUS_SUCCESS;
}
static switch_status switch_gsm_encode(switch_codec *codec, switch_codec *other_codec, void *decoded_data,
- size_t decoded_data_len, int decoded_rate, void *encoded_data,
- size_t *encoded_data_len, int *encoded_rate, unsigned int *flag)
+ uint32_t decoded_data_len, uint32_t decoded_rate, void *encoded_data,
+ uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag)
{
struct gsm_context *context = codec->private_info;
if (!context) {
return SWITCH_STATUS_FALSE;
}
if (decoded_data_len % 320 == 0) {
- unsigned int new_len = 0;
+ uint32_t new_len = 0;
gsm_signal * ddp = decoded_data;
gsm_byte * edp = encoded_data;
int x;
return SWITCH_STATUS_SUCCESS;
}
static switch_status switch_gsm_decode(switch_codec *codec, switch_codec *other_codec, void *encoded_data,
- size_t encoded_data_len, int encoded_rate, void *decoded_data,
- size_t *decoded_data_len, int *decoded_rate, unsigned int *flag)
+ uint32_t encoded_data_len, uint32_t encoded_rate, void *decoded_data,
+ uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag)
{
struct gsm_context *context = codec->private_info;
if (!context) {
gsm_byte * edp = encoded_data;
gsm_signal * ddp = decoded_data;
int x;
- unsigned int new_len = 0;
+ uint32_t new_len = 0;
for (x = 0; x < loops && new_len < *decoded_data_len; x++) {
gsm_decode(context->decoder, edp, ddp);
static switch_status switch_raw_encode(switch_codec *codec,
switch_codec *other_codec,
void *decoded_data,
- size_t decoded_data_len,
- int decoded_rate,
+ uint32_t decoded_data_len,
+ uint32_t decoded_rate,
void *encoded_data,
- size_t *encoded_data_len, int *encoded_rate, unsigned int *flag)
+ uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag)
{
/* NOOP indicates that the audio in is already the same as the audio out, so no conversion was necessary. */
static switch_status switch_raw_decode(switch_codec *codec,
switch_codec *other_codec,
void *encoded_data,
- size_t encoded_data_len,
- int encoded_rate,
+ uint32_t encoded_data_len,
+ uint32_t encoded_rate,
void *decoded_data,
- size_t *decoded_data_len, int *decoded_rate, unsigned int *flag)
+ uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag)
{
if (codec && other_codec && codec->implementation->samples_per_second != other_codec->implementation->samples_per_second) {
memcpy(decoded_data, encoded_data, encoded_data_len);
static switch_status switch_speex_encode(switch_codec *codec,
switch_codec *other_codec,
void *decoded_data,
- size_t decoded_data_len,
- int decoded_rate,
+ uint32_t decoded_data_len,
+ uint32_t decoded_rate,
void *encoded_data,
- size_t *encoded_data_len, int *encoded_rate, unsigned int *flag)
+ uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag)
{
struct speex_context *context = codec->private_info;
short *buf;
static switch_status switch_speex_decode(switch_codec *codec,
switch_codec *other_codec,
void *encoded_data,
- size_t encoded_data_len,
- int encoded_rate,
+ uint32_t encoded_data_len,
+ uint32_t encoded_rate,
void *decoded_data,
- size_t *decoded_data_len, int *decoded_rate, unsigned int *flag)
+ uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag)
{
struct speex_context *context = codec->private_info;
short *buf;
int32_t timestamp_recv;
int32_t timestamp_dtmf;
char *codec_name;
- int codec_num;
+ uint8_t codec_num;
};
struct rfc2833_digit {
switch_io_flag flags, int stream_id)
{
struct private_object *tech_pvt = NULL;
- size_t bytes = 0, samples = 0, frames = 0, ms = 0;
+ uint32_t bytes = 0;
+ switch_size_t samples = 0, frames = 0, ms = 0;
switch_channel *channel = NULL;
int payload = 0;
//printf("%s send %d bytes %d samples in %d frames ts=%d\n", switch_channel_get_name(channel), frame->datalen, samples, frames, tech_pvt->timestamp_send);
- switch_rtp_write(tech_pvt->rtp_session, frame->data, (int) frame->datalen, samples);
+ switch_rtp_write(tech_pvt->rtp_session, frame->data, frame->datalen, samples);
tech_pvt->timestamp_send += (int) samples;
switch_clear_flag(tech_pvt, TFLAG_WRITING);
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Opening File [%s] %dhz\n", path, context->sfinfo.samplerate);
handle->samples = (unsigned int) context->sfinfo.frames;
handle->samplerate = context->sfinfo.samplerate;
- handle->channels = context->sfinfo.channels;
+ handle->channels = (uint8_t)context->sfinfo.channels;
handle->format = context->sfinfo.format;
handle->sections = context->sfinfo.sections;
handle->seekable = context->sfinfo.seekable;
break;
}
}
- if ((write_frame.datalen = switch_buffer_read(tto->audio_buffer, fdata, write_frame.codec->implementation->bytes_per_frame)) <= 0) {
+ if ((write_frame.datalen = (uint32_t)switch_buffer_read(tto->audio_buffer, fdata, write_frame.codec->implementation->bytes_per_frame)) <= 0) {
if (loops > 0) {
switch_buffer *tmp;
tto->loop_buffer = tmp;
loops--;
/* try again */
- if ((write_frame.datalen = switch_buffer_read(tto->audio_buffer, fdata, write_frame.codec->implementation->bytes_per_frame)) <= 0) {
+ if ((write_frame.datalen = (uint32_t)switch_buffer_read(tto->audio_buffer, fdata, write_frame.codec->implementation->bytes_per_frame)) <= 0) {
break;
}
} else {
return session->write_codec;
}
-SWITCH_DECLARE(switch_status) switch_core_codec_init(switch_codec *codec, char *codec_name, int rate, int ms,
+SWITCH_DECLARE(switch_status) switch_core_codec_init(switch_codec *codec, char *codec_name, uint32_t rate, int ms,
int channels, uint32_t flags,
const switch_codec_settings *codec_settings,
switch_memory_pool *pool)
SWITCH_DECLARE(switch_status) switch_core_codec_encode(switch_codec *codec,
switch_codec *other_codec,
void *decoded_data,
- switch_size_t decoded_data_len,
- int decoded_rate,
+ uint32_t decoded_data_len,
+ uint32_t decoded_rate,
void *encoded_data,
- switch_size_t *encoded_data_len, int *encoded_rate, unsigned int *flag)
+ uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag)
{
assert(codec != NULL);
assert(encoded_data != NULL);
SWITCH_DECLARE(switch_status) switch_core_codec_decode(switch_codec *codec,
switch_codec *other_codec,
void *encoded_data,
- switch_size_t encoded_data_len,
- int encoded_rate,
+ uint32_t encoded_data_len,
+ uint32_t encoded_rate,
void *decoded_data,
- switch_size_t *decoded_data_len, int *decoded_rate, unsigned int *flag)
+ uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag)
{
assert(codec != NULL);
SWITCH_DECLARE(switch_status) switch_core_speech_read_tts(switch_speech_handle *sh,
void *data,
switch_size_t *datalen,
- switch_size_t *rate,
+ uint32_t *rate,
switch_speech_flag *flags)
{
assert(sh != NULL);
read_frame->datalen,
session->read_codec->implementation->samples_per_second,
session->raw_read_frame.data,
- &session->raw_read_frame.datalen, &session->raw_read_frame.rate, &flag);
+ &session->raw_read_frame.datalen,
+ &session->raw_read_frame.rate,
+ &flag);
switch (status) {
case SWITCH_STATUS_RESAMPLE:
session->read_resampler->to_len =
switch_resample_process(session->read_resampler, session->read_resampler->from,
session->read_resampler->from_len, session->read_resampler->to,
- (int) session->read_resampler->to_size, 0);
+ session->read_resampler->to_size, 0);
switch_float_to_short(session->read_resampler->to, data, read_frame->datalen);
read_frame->samples = session->read_resampler->to_len;
read_frame->datalen = session->read_resampler->to_len * 2;
enc_frame = *frame;
session->raw_read_frame.rate = (*frame)->rate;
} else {
- session->raw_read_frame.datalen = switch_buffer_read(session->raw_read_buffer,
+ session->raw_read_frame.datalen = (uint32_t)switch_buffer_read(session->raw_read_buffer,
session->raw_read_frame.data,
session->read_codec->implementation->
bytes_per_frame);
session->write_resampler->from_len =
switch_short_to_float(data, session->write_resampler->from, (int) write_frame->datalen / 2);
- session->write_resampler->to_len =
+ session->write_resampler->to_len = (uint32_t)
switch_resample_process(session->write_resampler, session->write_resampler->from,
session->write_resampler->from_len, session->write_resampler->to,
- (int) session->write_resampler->to_size, 0);
+ session->write_resampler->to_size, 0);
switch_float_to_short(session->write_resampler->to, data, write_frame->datalen * 2);
write_frame->samples = session->write_resampler->to_len;
write_frame->datalen = session->write_resampler->to_len * 2;
return status;
} else {
switch_size_t used = switch_buffer_inuse(session->raw_write_buffer);
- switch_size_t bytes = session->write_codec->implementation->bytes_per_frame;
+ uint32_t bytes = session->write_codec->implementation->bytes_per_frame;
switch_size_t frames = (used / bytes);
-
-
-
-
-
- status = SWITCH_STATUS_SUCCESS;
+ status = SWITCH_STATUS_SUCCESS;
if (frames) {
switch_size_t x;
for (x = 0; x < frames; x++) {
- if ((session->raw_write_frame.datalen =
+ if ((session->raw_write_frame.datalen = (uint32_t)
switch_buffer_read(session->raw_write_buffer, session->raw_write_frame.data, bytes)) != 0) {
enc_frame = &session->raw_write_frame;
session->read_resampler->from,
(int) write_frame->datalen /
2);
- session->read_resampler->to_len =
+ session->read_resampler->to_len = (uint32_t)
switch_resample_process(session->read_resampler, session->read_resampler->from,
session->read_resampler->from_len,
session->read_resampler->to,
- (int) session->read_resampler->to_size, 0);
+ session->read_resampler->to_size, 0);
switch_float_to_short(session->read_resampler->to, data, write_frame->datalen * 2);
write_frame->samples = session->read_resampler->to_len;
write_frame->datalen = session->read_resampler->to_len * 2;
switch_channel *channel;
short abuf[960];
char dtmf[128];
- int interval = 0, samples = 0;
- switch_size_t len = 0, ilen = 0, olen = 0;
+ uint32_t interval = 0, samples = 0;
+ uint32_t len = 0, ilen = 0;
+ switch_size_t olen = 0;
switch_frame write_frame;
switch_timer timer;
switch_core_thread_session thread_session;
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "OPEN FILE %s %uhz %u channels\n", file, fh->samplerate, fh->channels);
interval = 20;
- samples = (fh->samplerate / 50) * fh->channels;
+ samples = ((fh->samplerate / 50) * fh->channels);
len = samples * 2;
codec_name = "L16";
memset(abuf, 0, ilen * 2);
olen = ilen;
do_speed = 0;
- } else if (fh->audio_buffer && (switch_buffer_inuse(fh->audio_buffer) > (ilen * 2))) {
+ } else if (fh->audio_buffer && (switch_buffer_inuse(fh->audio_buffer) > (switch_size_t)(ilen * 2))) {
switch_buffer_read(fh->audio_buffer, abuf, ilen * 2);
olen = ilen;
do_speed = 0;
continue;
}
- write_frame.datalen = olen * 2;
- write_frame.samples = (int) olen;
+ write_frame.datalen = (uint32_t)(olen * 2);
+ write_frame.samples = (uint32_t)olen;
#if __BYTE_ORDER == __BIG_ENDIAN
switch_swap_linear(write_frame.data, (int) write_frame.datalen / 2);
#endif
char *tts_name,
char *voice_name,
char *timer_name,
- switch_size_t rate,
+ uint32_t rate,
switch_dtmf_callback_function dtmf_callback,
char *text,
void *buf,
short abuf[960];
char dtmf[128];
int interval = 0;
- switch_size_t samples = 0;
- switch_size_t len = 0;
+ uint32_t samples = 0;
+ uint32_t len = 0;
switch_size_t ilen = 0;
switch_frame write_frame;
switch_timer timer;
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "OPEN TTS %s\n", tts_name);
interval = 20;
- samples = (rate / 50);
+ samples = (uint32_t)(rate / 50);
len = samples * 2;
codec_name = "L16";
flags = 0;
switch_core_speech_feed_tts(&sh, text, &flags);
- write_frame.rate = (int)rate;
+ write_frame.rate = rate;
memset(write_frame.data, 0, len);
write_frame.datalen = len;
break;
}
- write_frame.datalen = ilen;
- write_frame.samples = (int) ilen / 2;
+ write_frame.datalen = (uint32_t)ilen;
+ write_frame.samples = (uint32_t)(ilen / 2);
for (stream_id = 0; stream_id < switch_core_session_get_stream_count(session); stream_id++) {
if (switch_core_session_write_frame(session, &write_frame, -1, stream_id) != SWITCH_STATUS_SUCCESS) {
SWITCH_DECLARE(switch_status) switch_resample_create(switch_audio_resampler **new_resampler,
int from_rate,
switch_size_t from_size,
- int to_rate, switch_size_t to_size, switch_memory_pool *pool)
+ int to_rate, uint32_t to_size, switch_memory_pool *pool)
{
switch_audio_resampler *resampler;
double lto_rate, lfrom_rate;
}
-SWITCH_DECLARE(int) switch_resample_process(switch_audio_resampler *resampler, float *src, int srclen, float *dst,
- int dstlen, int last)
+SWITCH_DECLARE(uint32_t) switch_resample_process(switch_audio_resampler *resampler, float *src, int srclen, float *dst,
+ uint32_t dstlen, int last)
{
int o = 0, srcused = 0, srcpos = 0, out = 0;
srtp_ctx_t *recv_ctx;
uint16_t seq;
- uint32_t payload;
+ uint8_t payload;
switch_rtp_invalid_handler invalid_handler;
void *private_data;
char *ice_user;
char *user_ice;
switch_time_t last_stun;
- switch_size_t packet_size;
+ uint32_t packet_size;
switch_time_t last_read;
switch_time_t next_read;
uint32_t ms_per_packet;
}
SWITCH_DECLARE(switch_status) switch_rtp_create(switch_rtp **new_rtp_session,
- int payload,
- switch_size_t packet_size,
+ uint8_t payload,
+ uint32_t packet_size,
uint32_t ms_per_packet,
switch_rtp_flag_t flags,
const char **err,
switch_port_t rx_port,
char *tx_host,
switch_port_t tx_port,
- int payload,
- switch_size_t packet_size,
+ uint8_t payload,
+ uint32_t packet_size,
uint32_t ms_per_packet,
switch_rtp_flag_t flags,
const char **err,
return rtp_session->sock;
}
-SWITCH_DECLARE(void) switch_rtp_set_default_packet_size(switch_rtp *rtp_session, uint32_t packet_size)
+SWITCH_DECLARE(void) switch_rtp_set_default_packet_size(switch_rtp *rtp_session, uint16_t packet_size)
{
rtp_session->packet_size = packet_size;
}
return rtp_session->packet_size;
}
-SWITCH_DECLARE(void) switch_rtp_set_default_payload(switch_rtp *rtp_session, uint32_t payload)
+SWITCH_DECLARE(void) switch_rtp_set_default_payload(switch_rtp *rtp_session, uint8_t payload)
{
rtp_session->payload = payload;
}
return bytes;
}
-static int rtp_common_write(switch_rtp *rtp_session, void *data, int datalen, int payload)
+static int rtp_common_write(switch_rtp *rtp_session, void *data, uint32_t datalen, uint8_t payload)
{
switch_size_t bytes;
}
-SWITCH_DECLARE(int) switch_rtp_write(switch_rtp *rtp_session, void *data, int datalen, uint32_t ts)
+SWITCH_DECLARE(int) switch_rtp_write(switch_rtp *rtp_session, void *data, uint32_t datalen, uint32_t ts)
{
if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_IO) || !rtp_session->remote_addr) {
rtp_session->seq = htons(rtp_session->seq);
rtp_session->send_msg.header.seq = rtp_session->seq;
rtp_session->send_msg.header.ts = htonl(rtp_session->ts);
- rtp_session->payload = htonl(rtp_session->payload);
+ rtp_session->payload = (uint8_t)htonl(rtp_session->payload);
return rtp_common_write(rtp_session, data, datalen, rtp_session->payload);
}
-SWITCH_DECLARE(int) switch_rtp_write_payload(switch_rtp *rtp_session, void *data, int datalen, uint8_t payload, uint32_t ts, uint16_t mseq)
+SWITCH_DECLARE(int) switch_rtp_write_payload(switch_rtp *rtp_session, void *data, uint16_t datalen, uint8_t payload, uint32_t ts, uint16_t mseq)
{
if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_IO) || !rtp_session->remote_addr) {
projects / thirdparty / freeswitch.git / commitdiff
