\param stream_id which logical media channel to use
\return SWITCH_STATUS_SUCCESS a the frame was read
*/
-SWITCH_DECLARE(switch_status_t) switch_core_session_read_frame(_In_ switch_core_session_t *session, switch_frame_t **frame, int timeout, int stream_id);
+SWITCH_DECLARE(switch_status_t) switch_core_session_read_frame(_In_ switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
-SWITCH_DECLARE(switch_status_t) switch_core_session_read_video_frame(_In_ switch_core_session_t *session, switch_frame_t **frame, int timeout, int stream_id);
-SWITCH_DECLARE(switch_status_t) switch_core_session_write_video_frame(_In_ switch_core_session_t *session, switch_frame_t *frame, int timeout, int stream_id);
+SWITCH_DECLARE(switch_status_t) switch_core_session_read_video_frame(_In_ switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+SWITCH_DECLARE(switch_status_t) switch_core_session_write_video_frame(_In_ switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
/*!
\brief Reset the buffers and resampler on a session
\param stream_id which logical media channel to use
\return SWITCH_STATUS_SUCCESS a the frame was written
*/
-SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(_In_ switch_core_session_t *session, switch_frame_t *frame, int timeout, int stream_id);
+SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(_In_ switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
SWITCH_DECLARE(switch_status_t) switch_core_session_perform_kill_channel(_In_ switch_core_session_t *session,
*/
#define switch_core_session_kill_channel(session, sig) switch_core_session_perform_kill_channel(session, __FILE__, __SWITCH_FUNC__, __LINE__, sig)
-/*!
- \brief Wait for a session to be ready for input
- \param session session to wait for
- \param timeout number of milliseconds to wait for data
- \param stream_id which logical media channel to use
- \return SWITCH_STATUS_SUCCESS if data is available for read within timeframe specified
-*/
-SWITCH_DECLARE(switch_status_t) switch_core_session_waitfor_read(_In_ switch_core_session_t *session, int timeout, int stream_id);
-
-/*!
- \brief Wait for a session to be ready for output
- \param session session to wait for
- \param timeout number of milliseconds to wait for data
- \param stream_id which logical media channel to use
- \return SWITCH_STATUS_SUCCESS if the session is available for write within timeframe specified
-*/
-SWITCH_DECLARE(switch_status_t) switch_core_session_waitfor_write(_In_ switch_core_session_t *session, int timeout, int stream_id);
-
/*!
\brief Send DTMF to a session
\param session session to send DTMF to
typedef struct switch_io_event_hook_write_frame switch_io_event_hook_write_frame_t;
typedef struct switch_io_event_hook_video_write_frame switch_io_event_hook_video_write_frame_t;
typedef struct switch_io_event_hook_kill_channel switch_io_event_hook_kill_channel_t;
-typedef struct switch_io_event_hook_waitfor_read switch_io_event_hook_waitfor_read_t;
-typedef struct switch_io_event_hook_waitfor_write switch_io_event_hook_waitfor_write_t;
typedef struct switch_io_event_hook_send_dtmf switch_io_event_hook_send_dtmf_t;
typedef struct switch_io_event_hook_recv_dtmf switch_io_event_hook_recv_dtmf_t;
typedef struct switch_io_event_hook_state_change switch_io_event_hook_state_change_t;
(switch_core_session_t *, switch_caller_profile_t *, switch_core_session_t *, switch_originate_flag_t);
typedef switch_status_t (*switch_receive_message_hook_t) (switch_core_session_t *, switch_core_session_message_t *);
typedef switch_status_t (*switch_receive_event_hook_t) (switch_core_session_t *, switch_event_t *);
-typedef switch_status_t (*switch_read_frame_hook_t) (switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int);
-typedef switch_status_t (*switch_video_read_frame_hook_t) (switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int);
-typedef switch_status_t (*switch_write_frame_hook_t) (switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int);
-typedef switch_status_t (*switch_video_write_frame_hook_t) (switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int);
+typedef switch_status_t (*switch_read_frame_hook_t) (switch_core_session_t *, switch_frame_t **, switch_io_flag_t, int);
+typedef switch_status_t (*switch_video_read_frame_hook_t) (switch_core_session_t *, switch_frame_t **, switch_io_flag_t, int);
+typedef switch_status_t (*switch_write_frame_hook_t) (switch_core_session_t *, switch_frame_t *, switch_io_flag_t, int);
+typedef switch_status_t (*switch_video_write_frame_hook_t) (switch_core_session_t *, switch_frame_t *, switch_io_flag_t, int);
typedef switch_status_t (*switch_kill_channel_hook_t) (switch_core_session_t *, int);
-typedef switch_status_t (*switch_waitfor_read_hook_t) (switch_core_session_t *, int, int);
-typedef switch_status_t (*switch_waitfor_write_hook_t) (switch_core_session_t *, int, int);
typedef switch_status_t (*switch_send_dtmf_hook_t) (switch_core_session_t *, const switch_dtmf_t *);
typedef switch_status_t (*switch_recv_dtmf_hook_t) (switch_core_session_t *, const switch_dtmf_t *);
typedef switch_status_t (*switch_state_change_hook_t) (switch_core_session_t *);
struct switch_io_event_hook_kill_channel *next;
};
-/*! \brief Node in which to store custom waitfor read channel callback hooks */
-struct switch_io_event_hook_waitfor_read {
- /*! the waitfor read channel callback hook */
- switch_waitfor_read_hook_t waitfor_read;
- struct switch_io_event_hook_waitfor_read *next;
-};
-
-/*! \brief Node in which to store custom waitfor write channel callback hooks */
-struct switch_io_event_hook_waitfor_write {
- /*! the waitfor write channel callback hook */
- switch_waitfor_write_hook_t waitfor_write;
- struct switch_io_event_hook_waitfor_write *next;
-};
-
/*! \brief Node in which to store custom send dtmf channel callback hooks */
struct switch_io_event_hook_send_dtmf {
/*! the send dtmf channel callback hook */
switch_io_event_hook_video_write_frame_t *video_write_frame;
/*! a list of kill channel hooks */
switch_io_event_hook_kill_channel_t *kill_channel;
- /*! a list of wait for read hooks */
- switch_io_event_hook_waitfor_read_t *waitfor_read;
- /*! a list of wait for write hooks */
- switch_io_event_hook_waitfor_write_t *waitfor_write;
/*! a list of send dtmf hooks */
switch_io_event_hook_send_dtmf_t *send_dtmf;
/*! a list of recv dtmf hooks */
NEW_HOOK_DECL_ADD_P(video_read_frame);
NEW_HOOK_DECL_ADD_P(video_write_frame);
NEW_HOOK_DECL_ADD_P(kill_channel);
-NEW_HOOK_DECL_ADD_P(waitfor_read);
-NEW_HOOK_DECL_ADD_P(waitfor_write);
NEW_HOOK_DECL_ADD_P(send_dtmf);
NEW_HOOK_DECL_ADD_P(recv_dtmf);
NEW_HOOK_DECL_ADD_P(resurrect_session);
NEW_HOOK_DECL_REM_P(video_read_frame);
NEW_HOOK_DECL_REM_P(video_write_frame);
NEW_HOOK_DECL_REM_P(kill_channel);
-NEW_HOOK_DECL_REM_P(waitfor_read);
-NEW_HOOK_DECL_REM_P(waitfor_write);
NEW_HOOK_DECL_REM_P(send_dtmf);
NEW_HOOK_DECL_REM_P(recv_dtmf);
NEW_HOOK_DECL_REM_P(resurrect_session);
typedef switch_call_cause_t (*switch_io_outgoing_channel_t)
(switch_core_session_t *, switch_caller_profile_t *, switch_core_session_t **, switch_memory_pool_t **, switch_originate_flag_t);
-typedef switch_status_t (*switch_io_read_frame_t) (switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int);
-typedef switch_status_t (*switch_io_write_frame_t) (switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int);
+typedef switch_status_t (*switch_io_read_frame_t) (switch_core_session_t *, switch_frame_t **, switch_io_flag_t, int);
+typedef switch_status_t (*switch_io_write_frame_t) (switch_core_session_t *, switch_frame_t *, switch_io_flag_t, int);
typedef switch_status_t (*switch_io_kill_channel_t) (switch_core_session_t *, int);
-typedef switch_status_t (*switch_io_waitfor_read_t) (switch_core_session_t *, int, int);
-typedef switch_status_t (*switch_io_waitfor_write_t) (switch_core_session_t *, int, int);
typedef switch_status_t (*switch_io_send_dtmf_t) (switch_core_session_t *, const switch_dtmf_t *);
typedef switch_status_t (*switch_io_receive_message_t) (switch_core_session_t *, switch_core_session_message_t *);
typedef switch_status_t (*switch_io_receive_event_t) (switch_core_session_t *, switch_event_t *);
typedef switch_status_t (*switch_io_state_change_t) (switch_core_session_t *);
-typedef switch_status_t (*switch_io_read_video_frame_t) (switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int);
-typedef switch_status_t (*switch_io_write_video_frame_t) (switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int);
+typedef switch_status_t (*switch_io_read_video_frame_t) (switch_core_session_t *, switch_frame_t **, switch_io_flag_t, int);
+typedef switch_status_t (*switch_io_write_video_frame_t) (switch_core_session_t *, switch_frame_t *, switch_io_flag_t, int);
typedef switch_call_cause_t (*switch_io_resurrect_session_t)(switch_core_session_t **, switch_memory_pool_t **, void *);
typedef enum {
SWITCH_IO_READ_FRAME,
SWITCH_IO_WRITE_FRAME,
SWITCH_IO_KILL_CHANNEL,
- SWITCH_IO_WAITFOR_READ,
- SWITCH_IO_WAITFOR_WRITE,
SWITCH_IO_SEND_DTMF,
SWITCH_IO_RECEIVE_MESSAGE,
SWITCH_IO_RECEIVE_EVENT,
switch_io_write_frame_t write_frame;
/*! send a kill signal to the session's channel */
switch_io_kill_channel_t kill_channel;
- /*! wait for the session's channel to be ready to read audio */
- switch_io_waitfor_read_t waitfor_read;
- /*! wait for the session's channel to be ready to write audio */
- switch_io_waitfor_write_t waitfor_write;
/*! send a string of DTMF digits to a session's channel */
switch_io_send_dtmf_t send_dtmf;
/*! receive a message from another session */
\return the number of bytes read
*/
SWITCH_DECLARE(switch_status_t) switch_rtp_read(switch_rtp_t *rtp_session, void *data, uint32_t * datalen,
- switch_payload_t *payload_type, switch_frame_flag_t *flags);
+ switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags);
/*!
\brief Queue RFC2833 DTMF data into an RTP Session
\return the number of bytes read
*/
SWITCH_DECLARE(switch_status_t) switch_rtp_zerocopy_read(switch_rtp_t *rtp_session,
- void **data, uint32_t * datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags);
+ void **data, uint32_t * datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags);
/*!
\brief Read data from a given RTP session without copying
\param frame a frame to populate with information
\return the number of bytes read
*/
-SWITCH_DECLARE(switch_status_t) switch_rtp_zerocopy_read_frame(switch_rtp_t *rtp_session, switch_frame_t *frame);
+SWITCH_DECLARE(switch_status_t) switch_rtp_zerocopy_read_frame(switch_rtp_t *rtp_session, switch_frame_t *frame, switch_io_flag_t io_flagsm);
/*!
\brief Enable VAD on an RTP Session
} switch_file_flag_t;
typedef enum {
- SWITCH_IO_FLAG_NOOP = 0
+ SWITCH_IO_FLAG_NONE = 0,
+ SWITCH_IO_FLAG_NOBLOCK = (1 << 0)
} switch_io_flag_t;
/* make sure this is synced with the EVENT_NAMES array in switch_event.c
}
if (switch_channel_test_flag(switch_core_session_get_channel(conference->floor_holder->session), CF_VIDEO)) {
- status = switch_core_session_read_video_frame(conference->floor_holder->session, &vid_frame, -1, 0);
+ status = switch_core_session_read_video_frame(conference->floor_holder->session, &vid_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
conference->floor_holder = NULL;
for (imember = conference->members; imember; imember = imember->next) {
if (switch_channel_test_flag(switch_core_session_get_channel(imember->session), CF_VIDEO)) {
has_vid++;
- switch_core_session_write_video_frame(imember->session, vid_frame, -1, 0);
+ switch_core_session_write_video_frame(imember->session, vid_frame, SWITCH_IO_FLAG_NONE, 0);
}
}
switch_mutex_unlock(conference->member_mutex);
while (switch_test_flag(member, MFLAG_RUNNING) && switch_channel_ready(channel)) {
/* Read a frame. */
- status = switch_core_session_read_frame(member->session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(member->session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
/* end the loop, if appropriate */
if (!SWITCH_READ_ACCEPTABLE(status) || !switch_test_flag(member, MFLAG_RUNNING)) {
switch_change_sln_volume(write_frame.data, write_frame.samples, member->volume_out_level);
}
write_frame.timestamp = timer.samplecount;
- switch_core_session_write_frame(member->session, &write_frame, -1, 0);
+ switch_core_session_write_frame(member->session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
switch_core_timer_next(&timer);
switch_change_sln_volume(write_frame.data, write_frame.samples, member->volume_out_level);
}
write_frame.timestamp = timer.samplecount;
- switch_core_session_write_frame(member->session, &write_frame, -1, 0);
+ switch_core_session_write_frame(member->session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
}
}
write_frame.datalen = bytes;
write_frame.samples = samples;
write_frame.timestamp = timer.samplecount;
- switch_core_session_write_frame(member->session, &write_frame, -1, 0);
+ switch_core_session_write_frame(member->session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
}
}
}
/* generate some space infront of the file to be played */
for (x = 0; x < leadin; x++) {
switch_frame_t *read_frame;
- status = switch_core_session_read_frame(session, &read_frame, 1000, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
/* SIP won't let us redir media until the call has been answered #$^#%& so we will proxy any early media until they do */
while (switch_channel_ready(caller_channel) && switch_channel_ready(peer_channel)
&& !switch_channel_test_flag(peer_channel, CF_ANSWERED)) {
- switch_status_t status = switch_core_session_read_frame(peer_session, &read_frame, -1, 0);
+ switch_status_t status = switch_core_session_read_frame(peer_session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
uint8_t bad = 1;
if (SWITCH_READ_ACCEPTABLE(status)
- && switch_core_session_write_frame(session, read_frame, -1, 0) == SWITCH_STATUS_SUCCESS) {
+ && switch_core_session_write_frame(session, read_frame, SWITCH_IO_FLAG_NONE, 0) == SWITCH_STATUS_SUCCESS) {
bad = 0;
}
if (bad) {
while(!ready) {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (read_frame && switch_test_flag(read_frame, SFF_CNG)) {
continue;
}
for(;;) {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
break;
}
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
switch_channel_set_flag(other_channel, CF_BREAK);
while (switch_channel_ready(channel) && switch_channel_ready(other_channel) && switch_channel_test_flag(other_channel, CF_TAGGED)) {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
eh->up = 1;
while(switch_channel_ready(channel)) {
- status = switch_core_session_read_video_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_video_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
switch_mutex_unlock(eh->mutex);
- switch_core_session_write_video_frame(session, read_frame, -1, 0);
+ switch_core_session_write_video_frame(session, read_frame, SWITCH_IO_FLAG_NONE, 0);
}
eh->up = 0;
return NULL;
while(switch_channel_ready(channel)) {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
hdr->pt = pt;
}
if (switch_channel_test_flag(channel, CF_VIDEO)) {
- switch_core_session_write_video_frame(session, &vid_frame, -1, 0);
+ switch_core_session_write_video_frame(session, &vid_frame, SWITCH_IO_FLAG_NONE, 0);
}
if (ts && last && last != ts) {
switch_yield(1000);
if ((write_frame.datalen = read(fd, write_frame.data, bytes)) <= 0) {
break;
}
- switch_core_session_write_frame(session, &write_frame, -1, 0);
+ switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
switch_core_timer_next(&timer);
}
switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
switch_core_thread_session_t thread_session;
uint32_t rate, interval = 20;
- int stream_id = 0;
switch_timer_t timer = { 0 }, *timerp = NULL;
uint32_t last;
char *mydata = NULL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "setup timer success %u bytes per %d ms!\n", (rate / 50) * 2, interval);
/* start a thread to absorb incoming audio */
- for (stream_id = 0; stream_id < switch_core_session_get_stream_count(session); stream_id++) {
- switch_core_service_session(session, &thread_session, stream_id);
- }
+ switch_core_service_session(session, &thread_session, 0);
timerp = &timer;
}
static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session,
switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags);
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig);
static switch_status_t engage_device(unsigned int samplerate, int codec_ms);
static switch_status_t load_config(void);
}
-static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
-{
- private_t *tech_pvt = NULL;
-
- tech_pvt = switch_core_session_get_private(session);
- assert(tech_pvt != NULL);
-
- return SWITCH_STATUS_SUCCESS;
-}
-
-static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
-{
- private_t *tech_pvt = NULL;
-
- tech_pvt = switch_core_session_get_private(session);
- assert(tech_pvt != NULL);
-
- return SWITCH_STATUS_SUCCESS;
-
-}
-
static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
private_t *tech_pvt = NULL;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
switch_channel_t *channel = NULL;
private_t *tech_pvt = NULL;
return status;
}
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
switch_channel_t *channel = NULL;
private_t *tech_pvt = NULL;
static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session,
switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags);
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig);
static ldl_status handle_signalling(ldl_handle_t * handle, ldl_session_t * dlsession, ldl_signal_t dl_signal,
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
-{
- struct private_object *tech_pvt = NULL;
-
- tech_pvt = switch_core_session_get_private(session);
- switch_assert(tech_pvt != NULL);
-
- return SWITCH_STATUS_SUCCESS;
-}
-
-static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
-{
- struct private_object *tech_pvt = NULL;
-
- tech_pvt = switch_core_session_get_private(session);
- switch_assert(tech_pvt != NULL);
-
- return SWITCH_STATUS_SUCCESS;
-
-}
static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
}
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
struct private_object *tech_pvt = NULL;
switch_channel_t *channel = switch_core_session_get_channel(session);
while (switch_test_flag(tech_pvt, TFLAG_IO) && tech_pvt->read_frame.datalen == 0) {
tech_pvt->read_frame.flags = SFF_NONE;
- status = switch_rtp_zerocopy_read_frame(tech_pvt->rtp_session, &tech_pvt->read_frame);
+ status = switch_rtp_zerocopy_read_frame(tech_pvt->rtp_session, &tech_pvt->read_frame, flags);
if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
return SWITCH_STATUS_FALSE;
}
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
struct private_object *tech_pvt;
switch_channel_t *channel = switch_core_session_get_channel(session);
static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session,
switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags);
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
-{
- assert(switch_core_session_get_private(session));
-
- return SWITCH_STATUS_SUCCESS;
-}
-
-static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
-{
- assert(switch_core_session_get_private(session));
-
- return SWITCH_STATUS_SUCCESS;
-}
-
static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
private_t *tech_pvt = switch_core_session_get_private(session);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
private_t *tech_pvt = switch_core_session_get_private(session);
- switch_time_t started = switch_timestamp_now();
- unsigned int elapsed;
switch_byte_t *data;
switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_SUCCESS;
}
- if (timeout > -1) {
- elapsed = (unsigned int) ((switch_timestamp_now() - started) / 1000);
- if (elapsed >= (unsigned int) timeout) {
- return SWITCH_STATUS_SUCCESS;
- }
- }
switch_yield(1000);
}
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
private_t *tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
/*.read_frame */ channel_read_frame,
/*.write_frame */ channel_write_frame,
/*.kill_channel */ channel_kill_channel,
- /*.waitfor_read */ channel_waitfor_read,
- /*.waitfor_write */ channel_waitfor_write,
/*.send_dtmf */ channel_send_dtmf,
/*.receive_message*/ channel_receive_message,
/*.receive_event */ channel_receive_event
static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session,
switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags);
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig);
static switch_status_t engage_device(int samplerate, int codec_ms);
static switch_status_t engage_ring_device(int sample_rate, int channels);
}
-static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
-{
- return SWITCH_STATUS_SUCCESS;
-}
-
-static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
-{
- return SWITCH_STATUS_SUCCESS;
-}
-
static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
private_t *tech_pvt = switch_core_session_get_private(session);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
private_t *tech_pvt = switch_core_session_get_private(session);
int samples = 0;
return status;
}
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
switch_status_t status = SWITCH_STATUS_FALSE;
private_t *tech_pvt = switch_core_session_get_private(session);
static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session,
switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags);
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
-{
- private_t *tech_pvt = NULL;
-
- tech_pvt = switch_core_session_get_private(session);
- assert(tech_pvt != NULL);
-
- return SWITCH_STATUS_SUCCESS;
-}
-
-static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
-{
- private_t *tech_pvt = NULL;
-
- tech_pvt = switch_core_session_get_private(session);
- assert(tech_pvt != NULL);
-
- return SWITCH_STATUS_SUCCESS;
-
-}
-
static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
private_t *tech_pvt = switch_core_session_get_private(session);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
switch_channel_t *channel = NULL;
private_t *tech_pvt = NULL;
}
-static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
switch_channel_t *channel = NULL;
private_t *tech_pvt = NULL;
/*.read_frame */ channel_read_frame,
/*.write_frame */ channel_write_frame,
/*.kill_channel */ channel_kill_channel,
- /*.waitfor_read */ channel_waitfor_read,
- /*.waitfor_write */ channel_waitfor_write,
/*.send_dtmf */ channel_send_dtmf,
/*.receive_message*/ channel_receive_message,
/*.receive_event */ channel_receive_event
static switch_call_cause_t sofia_outgoing_channel(switch_core_session_t *session,
switch_caller_profile_t *outbound_profile, switch_core_session_t **new_session,
switch_memory_pool_t **pool, switch_originate_flag_t flags);
-static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t sofia_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t sofia_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t sofia_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
+static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t sofia_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t sofia_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t sofia_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
static switch_status_t sofia_kill_channel(switch_core_session_t *session, int sig);
/* BODY OF THE MODULE */
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sofia_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t sofia_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_channel_t *channel = switch_core_session_get_channel(session);
while (switch_test_flag(tech_pvt, TFLAG_IO) && tech_pvt->video_read_frame.datalen == 0) {
tech_pvt->video_read_frame.flags = SFF_NONE;
- status = switch_rtp_zerocopy_read_frame(tech_pvt->video_rtp_session, &tech_pvt->video_read_frame);
+ status = switch_rtp_zerocopy_read_frame(tech_pvt->video_rtp_session, &tech_pvt->video_read_frame, flags);
if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
if (status == SWITCH_STATUS_TIMEOUT) {
switch_channel_hangup(tech_pvt->channel, SWITCH_CAUSE_MEDIA_TIMEOUT);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sofia_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t sofia_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_channel_t *channel = switch_core_session_get_channel(session);
return status;
}
-static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = switch_core_session_get_channel(session);
while (switch_test_flag(tech_pvt, TFLAG_IO) && tech_pvt->read_frame.datalen == 0) {
tech_pvt->read_frame.flags = SFF_NONE;
- status = switch_rtp_zerocopy_read_frame(tech_pvt->rtp_session, &tech_pvt->read_frame);
+ status = switch_rtp_zerocopy_read_frame(tech_pvt->rtp_session, &tech_pvt->read_frame, flags);
if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
if (status == SWITCH_STATUS_TIMEOUT) {
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sofia_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t sofia_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = switch_core_session_get_channel(session);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sofia_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
-{
- return SWITCH_STATUS_SUCCESS;
-}
-
-static switch_status_t sofia_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
-{
- return SWITCH_STATUS_SUCCESS;
-}
-
static switch_status_t sofia_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
private_object_t *tech_pvt;
/*.read_frame */ sofia_read_frame,
/*.write_frame */ sofia_write_frame,
/*.kill_channel */ sofia_kill_channel,
- /*.waitfor_read */ sofia_waitfor_read,
- /*.waitfor_read */ sofia_waitfor_write,
/*.send_dtmf */ sofia_send_dtmf,
/*.receive_message */ sofia_receive_message,
/*.receive_event */ sofia_receive_event,
static switch_status_t wanpipe_on_soft_execute(switch_core_session_t *session);
static switch_call_cause_t wanpipe_outgoing_channel(switch_core_session_t *session, switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags);
-static switch_status_t wanpipe_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout,
+static switch_status_t wanpipe_read_frame(switch_core_session_t *session, switch_frame_t **frame,
switch_io_flag_t flags, int stream_id);
-static switch_status_t wanpipe_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout,
+static switch_status_t wanpipe_write_frame(switch_core_session_t *session, switch_frame_t *frame,
switch_io_flag_t flags, int stream_id);
static int on_info(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent);
static int on_hangup(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent);
-static switch_status_t wanpipe_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout,
+static switch_status_t wanpipe_read_frame(switch_core_session_t *session, switch_frame_t **frame,
switch_io_flag_t flags, int stream_id)
{
private_object_t *tech_pvt;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t wanpipe_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout,
+static switch_status_t wanpipe_write_frame(switch_core_session_t *session, switch_frame_t *frame,
switch_io_flag_t flags, int stream_id)
{
private_object_t *tech_pvt;
/*.read_frame */ wanpipe_read_frame,
/*.write_frame */ wanpipe_write_frame,
/*.kill_channel */ wanpipe_kill_channel,
- /*.waitfor_read */ NULL,
- /*.waitfor_read */ NULL,
/*.send_dtmf*/ wanpipe_send_dtmf,
/*.receive_message*/ wanpipe_receive_message
};
static switch_call_cause_t woomera_outgoing_channel(switch_core_session_t *session,
switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags);
-static switch_status_t woomera_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t woomera_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
+static switch_status_t woomera_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
+static switch_status_t woomera_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
static switch_status_t woomera_kill_channel(switch_core_session_t *session, int sig);
static void tech_destroy(private_object * tech_pvt);
static void woomera_printf(woomera_profile * profile, switch_socket_t * socket, char *fmt, ...);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t woomera_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
-{
- struct private_object *tech_pvt = NULL;
-
- tech_pvt = switch_core_session_get_private(session);
- switch_assert(tech_pvt != NULL);
-
- return switch_socket_waitfor(tech_pvt->read_poll, ms) ? SWITCH_STATUS_FALSE : SWITCH_STATUS_SUCCESS;
-}
-
-static switch_status_t woomera_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
-{
- struct private_object *tech_pvt = NULL;
-
- tech_pvt = switch_core_session_get_private(session);
- switch_assert(tech_pvt != NULL);
-
- return SWITCH_STATUS_SUCCESS;
-// return switch_socket_waitfor(tech_pvt->write_poll, ms);
-}
-
-static switch_status_t woomera_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t woomera_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
struct private_object *tech_pvt = switch_core_session_get_private(session);
switch_frame_t *pframe;
return SWITCH_STATUS_FALSE;
}
-static switch_status_t woomera_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t woomera_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
struct private_object *tech_pvt = switch_core_session_get_private(session);
switch_size_t len;
/*.read_frame */ woomera_read_frame,
/*.write_frame */ woomera_write_frame,
/*.kill_channel */ woomera_kill_channel,
- /*.waitfor_read */ woomera_waitfor_read,
- /*.waitfor_write */ woomera_waitfor_write
};
/* Make sure when you have 2 sessions in the same scope that you pass the appropriate one to the routines
switch_frame_t write_frame = { 0 };
unsigned char *fdata[1024];
switch_frame_t *read_frame;
- int stream_id;
switch_core_thread_session_t thread_session = { 0 };
switch_channel_t *channel;
channel = switch_core_session_get_channel(session);
if (tto->timer) {
- for (stream_id = 0; stream_id < switch_core_session_get_stream_count(session); stream_id++) {
- switch_core_service_session(session, &thread_session, stream_id);
- }
+ switch_core_service_session(session, &thread_session, 0);
}
if (loops) {
} else {
switch_status_t status;
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
write_frame.samples = write_frame.datalen / 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_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Bad Write\n");
- break;
- }
+ if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Bad Write\n");
+ break;
}
}
switch_channel_set_flag(channel, CF_SERVICE);
while (data->running > 0) {
- switch (switch_core_session_read_frame(session, &read_frame, -1, stream_id)) {
+ switch (switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, stream_id)) {
case SWITCH_STATUS_SUCCESS:
case SWITCH_STATUS_TIMEOUT:
case SWITCH_STATUS_BREAK:
NEW_HOOK_DECL(video_read_frame)
NEW_HOOK_DECL(video_write_frame)
NEW_HOOK_DECL(kill_channel)
-NEW_HOOK_DECL(waitfor_read)
-NEW_HOOK_DECL(waitfor_write)
NEW_HOOK_DECL(send_dtmf)
NEW_HOOK_DECL(recv_dtmf)
NEW_HOOK_DECL(resurrect_session)
#include <switch.h>
#include "private/switch_core_pvt.h"
-SWITCH_DECLARE(switch_status_t) switch_core_session_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, int stream_id)
+SWITCH_DECLARE(switch_status_t) switch_core_session_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
switch_io_event_hook_video_write_frame_t *ptr;
switch_status_t status = SWITCH_STATUS_FALSE;
- switch_io_flag_t flags = 0;
if (switch_channel_get_state(session->channel) >= CS_HANGUP) {
return SWITCH_STATUS_FALSE;
}
if (session->endpoint_interface->io_routines->write_video_frame) {
- if ((status = session->endpoint_interface->io_routines->write_video_frame(session, frame, timeout, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
+ if ((status = session->endpoint_interface->io_routines->write_video_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
for (ptr = session->event_hooks.video_write_frame; ptr; ptr = ptr->next) {
- if ((status = ptr->video_write_frame(session, frame, timeout, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
+ if ((status = ptr->video_write_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
break;
}
}
return status;
}
-SWITCH_DECLARE(switch_status_t) switch_core_session_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, int stream_id)
+SWITCH_DECLARE(switch_status_t) switch_core_session_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
switch_status_t status = SWITCH_STATUS_FALSE;
switch_io_event_hook_video_read_frame_t *ptr;
if (session->endpoint_interface->io_routines->read_video_frame) {
if ((status =
- session->endpoint_interface->io_routines->read_video_frame(session, frame, timeout, SWITCH_IO_FLAG_NOOP, stream_id)) == SWITCH_STATUS_SUCCESS) {
+ session->endpoint_interface->io_routines->read_video_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
for (ptr = session->event_hooks.video_read_frame; ptr; ptr = ptr->next) {
- if ((status = ptr->video_read_frame(session, frame, timeout, SWITCH_IO_FLAG_NOOP, stream_id)) != SWITCH_STATUS_SUCCESS) {
+ if ((status = ptr->video_read_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
break;
}
}
return status;
}
-SWITCH_DECLARE(switch_status_t) switch_core_session_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, int stream_id)
+SWITCH_DECLARE(switch_status_t) switch_core_session_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
switch_io_event_hook_read_frame_t *ptr;
switch_status_t status;
if (session->endpoint_interface->io_routines->read_frame) {
if ((status =
- session->endpoint_interface->io_routines->read_frame(session, frame, timeout, SWITCH_IO_FLAG_NOOP, stream_id)) == SWITCH_STATUS_SUCCESS) {
+ session->endpoint_interface->io_routines->read_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
for (ptr = session->event_hooks.read_frame; ptr; ptr = ptr->next) {
- if ((status = ptr->read_frame(session, frame, timeout, SWITCH_IO_FLAG_NOOP, stream_id)) != SWITCH_STATUS_SUCCESS) {
+ if ((status = ptr->read_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
break;
}
}
return status;
}
-static switch_status_t perform_write(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t perform_write(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
switch_io_event_hook_write_frame_t *ptr;
switch_status_t status = SWITCH_STATUS_FALSE;
if (session->endpoint_interface->io_routines->write_frame) {
- if ((status = session->endpoint_interface->io_routines->write_frame(session, frame, timeout, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
+ if ((status = session->endpoint_interface->io_routines->write_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
for (ptr = session->event_hooks.write_frame; ptr; ptr = ptr->next) {
- if ((status = ptr->write_frame(session, frame, timeout, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
+ if ((status = ptr->write_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
break;
}
}
return status;
}
-SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, int stream_id)
+SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
switch_status_t status = SWITCH_STATUS_FALSE;
switch_frame_t *enc_frame = NULL, *write_frame = frame;
unsigned int flag = 0, need_codec = 0, perfect = 0, do_bugs = 0, do_write = 0, do_resample = 0, ptime_mismatch = 0;
- switch_io_flag_t io_flag = SWITCH_IO_FLAG_NOOP;
switch_assert(session != NULL);
switch_assert(frame != NULL);
if (switch_test_flag(frame, SFF_PROXY_PACKET)) {
/* Fast PASS! */
- return perform_write(session, frame, timeout, flag, stream_id);
+ return perform_write(session, frame, flag, stream_id);
}
if (switch_test_flag(frame, SFF_CNG)) {
if (switch_channel_test_flag(session->channel, CF_ACCEPT_CNG)) {
- return perform_write(session, frame, timeout, flag, stream_id);
+ return perform_write(session, frame, flag, stream_id);
}
return SWITCH_STATUS_SUCCESS;
}
if (flag & SFF_CNG) {
switch_set_flag(write_frame, SFF_CNG);
}
- status = perform_write(session, write_frame, timeout, io_flag, stream_id);
+ status = perform_write(session, write_frame, flags, stream_id);
return status;
} else {
switch_size_t used = switch_buffer_inuse(session->raw_write_buffer);
switch_set_flag(write_frame, SFF_CNG);
}
- if ((status = perform_write(session, write_frame, timeout, io_flag, stream_id)) != SWITCH_STATUS_SUCCESS) {
+ if ((status = perform_write(session, write_frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
break;
}
}
done:
if (do_write) {
- return perform_write(session, frame, timeout, io_flag, stream_id);
+ return perform_write(session, frame, flags, stream_id);
}
return status;
}
return status;
}
-SWITCH_DECLARE(switch_status_t) switch_core_session_waitfor_read(switch_core_session_t *session, int timeout, int stream_id)
-{
- switch_io_event_hook_waitfor_read_t *ptr;
- switch_status_t status = SWITCH_STATUS_FALSE;
-
- if (session->endpoint_interface->io_routines->waitfor_read) {
- if ((status = session->endpoint_interface->io_routines->waitfor_read(session, timeout, stream_id)) == SWITCH_STATUS_SUCCESS) {
- for (ptr = session->event_hooks.waitfor_read; ptr; ptr = ptr->next) {
- if ((status = ptr->waitfor_read(session, timeout, stream_id)) != SWITCH_STATUS_SUCCESS) {
- break;
- }
- }
- }
- }
- return status;
-}
-
-SWITCH_DECLARE(switch_status_t) switch_core_session_waitfor_write(switch_core_session_t *session, int timeout, int stream_id)
-{
- switch_io_event_hook_waitfor_write_t *ptr;
- switch_status_t status = SWITCH_STATUS_FALSE;
-
- if (session->endpoint_interface->io_routines->waitfor_write) {
- if ((status = session->endpoint_interface->io_routines->waitfor_write(session, timeout, stream_id)) == SWITCH_STATUS_SUCCESS) {
- for (ptr = session->event_hooks.waitfor_write; ptr; ptr = ptr->next) {
- if ((status = ptr->waitfor_write(session, timeout, stream_id)) != SWITCH_STATUS_SUCCESS) {
- break;
- }
- }
- }
- }
- return status;
-}
-
SWITCH_DECLARE(switch_status_t) switch_core_session_recv_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
switch_io_event_hook_recv_dtmf_t *ptr;
(!switch_channel_test_flag(channel, CF_ANSWERED) && !switch_channel_test_flag(channel, CF_EARLY_MEDIA))) {
switch_yield(1000);
} else {
- status = switch_core_session_read_frame(session, &read_frame, left, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
}
conninfo->write_frame.datalen = (uint32_t)len;
conninfo->write_frame.samples = conninfo->write_frame.datalen / 2;
- switch_core_session_write_frame(conninfo->session, &conninfo->write_frame, -1, conninfo->stream_id);
+ switch_core_session_write_frame(conninfo->session, &conninfo->write_frame, SWITCH_IO_FLAG_NONE, conninfo->stream_id);
}
switch_clear_flag_locked(conninfo, SUF_READY);
int frame_count = atoi(lead_frames);
while(frame_count > 0) {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
goto done;
}
while (switch_channel_ready(channel) && switch_channel_test_flag(channel, CF_CONTROLLED)) {
- if ((status = switch_core_session_read_frame(session, &read_frame, -1, stream_id)) == SWITCH_STATUS_SUCCESS) {
+ if ((status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, stream_id)) == SWITCH_STATUS_SUCCESS) {
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
if (switch_channel_test_flag(channel, CF_SERVICE)) {
switch_yield(1000);
} else {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
}
if (!SWITCH_READ_ACCEPTABLE(status)) {
if (switch_channel_test_flag(channel, CF_SERVICE)) {
switch_yield(1000);
} else {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
switch_core_session_receive_message(session, &msg);
switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000);
- switch_core_session_read_frame(session, &read_frame, -1, 0);
+ switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if ((flags & SMF_REBRIDGE)
&& (other_uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE))
switch_assert(other_channel != NULL);
switch_core_session_receive_message(other_session, &msg);
switch_channel_wait_for_flag(other_channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000);
- switch_core_session_read_frame(other_session, &read_frame, -1, 0);
+ switch_core_session_read_frame(other_session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
switch_channel_clear_state_handler(other_channel, NULL);
switch_core_session_rwunlock(other_session);
}
write_frame.codec = read_codec;
while(switch_channel_ready(channel)) {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
if ((jb_frame = stfu_n_read_a_frame(jb))) {
write_frame.data = jb_frame->data;
write_frame.datalen = (uint32_t)jb_frame->dlen;
- status = switch_core_session_write_frame(session, &write_frame, -1, 0);
+ status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
eh->up = 1;
while(switch_channel_ready(channel)) {
- status = switch_core_session_read_video_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_video_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
continue;
}
- switch_core_session_write_video_frame(session, read_frame, -1, 0);
+ switch_core_session_write_video_frame(session, read_frame, SWITCH_IO_FLAG_NONE, 0);
}
eh->up = 0;
#endif
while(switch_channel_ready(channel)) {
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
- switch_core_session_write_frame(session, read_frame, -1, 0);
+ switch_core_session_write_frame(session, read_frame, SWITCH_IO_FLAG_NONE, 0);
#ifndef SWITCH_VIDEO_IN_THREADS
- status = switch_core_session_read_video_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_video_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
continue;
}
- switch_core_session_write_video_frame(session, read_frame, -1, 0);
+ switch_core_session_write_video_frame(session, read_frame, SWITCH_IO_FLAG_NONE, 0);
#endif
}
char *fcommand = NULL;
char db[2] = "";
- status = switch_core_session_read_frame(session, &read_frame, 1000, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
goto end;
while (switch_buffer_inuse(ep->buffer) >= len) {
write_frame.datalen = (uint32_t)switch_buffer_read(ep->buffer, buf, len);
write_frame.samples = write_frame.datalen / 2;
- if ((status = switch_core_session_write_frame(session, &write_frame, 1000, 0)) != SWITCH_STATUS_SUCCESS) {
+ if ((status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0)) != SWITCH_STATUS_SUCCESS) {
break;
}
}
vh->up = 1;
while(switch_channel_ready(channel) && vh->up == 1) {
- status = switch_core_session_read_video_frame(vh->session_a, &read_frame, -1, 0);
+ status = switch_core_session_read_video_frame(vh->session_a, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
- switch_core_session_write_video_frame(vh->session_b, read_frame, -1, 0);
+ switch_core_session_write_video_frame(vh->session_b, read_frame, SWITCH_IO_FLAG_NONE, 0);
}
vh->up = 0;
if (switch_channel_test_flag(chan_a, CF_SUSPEND)) {
status = SWITCH_STATUS_SUCCESS;
} else {
- status = switch_core_session_read_frame(session_a, &read_frame, -1, stream_id);
+ status = switch_core_session_read_frame(session_a, &read_frame, SWITCH_IO_FLAG_NONE, stream_id);
}
if (!SWITCH_READ_ACCEPTABLE(status)) {
#ifndef SWITCH_VIDEO_IN_THREADS
if (switch_channel_test_flag(chan_a, CF_VIDEO) && switch_channel_test_flag(chan_b, CF_VIDEO)) {
/* read video from 1 channel and write it to the other */
- status = switch_core_session_read_video_frame(session_a, &read_frame, -1, 0);
+ status = switch_core_session_read_video_frame(session_a, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
goto end_of_bridge_loop;
}
- switch_core_session_write_video_frame(session_b, read_frame, -1, 0);
+ switch_core_session_write_video_frame(session_b, read_frame, SWITCH_IO_FLAG_NONE, 0);
}
#endif
/* read audio from 1 channel and write it to the other */
- status = switch_core_session_read_frame(session_a, &read_frame, -1, stream_id);
+ status = switch_core_session_read_frame(session_a, &read_frame, SWITCH_IO_FLAG_NONE, stream_id);
if (SWITCH_READ_ACCEPTABLE(status)) {
if (switch_test_flag(read_frame, SFF_CNG)) {
}
if (status != SWITCH_STATUS_BREAK && !switch_channel_test_flag(chan_a, CF_HOLD)) {
- if (switch_core_session_write_frame(session_b, read_frame, -1, stream_id) != SWITCH_STATUS_SUCCESS) {
+ if (switch_core_session_write_frame(session_b, read_frame, SWITCH_IO_FLAG_NONE, stream_id) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "write: %s Bad Frame....[%u] Bubye!\n",
switch_channel_get_name(chan_b), read_frame->datalen);
goto end_of_bridge_loop;
message = NULL;
}
}
- status = switch_core_session_read_frame(session, &read_frame, 1000, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
}
}
- if (switch_core_session_write_frame(session, &write_frame, 1000, 0) != SWITCH_STATUS_SUCCESS) {
+ if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
break;
}
} else {
if (session && (ringback_data ||
!(switch_channel_test_flag(caller_channel, CF_PROXY_MODE) && switch_channel_test_flag(caller_channel, CF_PROXY_MODE))) &&
(switch_channel_test_flag(caller_channel, CF_ANSWERED) || switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA))) {
- switch_status_t tstatus = switch_core_session_read_frame(session, &read_frame, 1000, 0);
+ switch_status_t tstatus = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(tstatus)) {
break;
}
}
- if (switch_core_session_write_frame(session, &write_frame, 1000, 0) != SWITCH_STATUS_SUCCESS) {
+ if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
break;
}
}
}
}
- status = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
}
break;
}
- status = switch_core_session_read_frame(session, &read_frame, 1000, 0);
+ status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(status)) {
break;
write_frame.samples = write_frame.datalen / 2;
- if (switch_core_session_write_frame(session, &write_frame, 1000, 0) != SWITCH_STATUS_SUCCESS) {
+ if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
break;
}
}
switch_codec_t codec;
switch_memory_pool_t *pool = switch_core_session_get_pool(session);
char *codec_name;
- int stream_id = 0;
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_file_handle_t lfh;
switch_codec_t *read_codec = NULL;
if (timer_name) {
/* start a thread to absorb incoming audio */
- for (stream_id = 0; stream_id < switch_core_session_get_stream_count(session); stream_id++) {
- switch_core_service_session(session, &thread_session, stream_id);
- }
+ switch_core_service_session(session, &thread_session, 0);
}
ilen = samples;
}
#endif
#endif
- stream_id = 0;
-
if (fh->vol) {
switch_change_sln_volume(write_frame.data, write_frame.datalen / 2, fh->vol);
}
fh->offset_pos += write_frame.samples / 2;
- status = switch_core_session_write_frame(session, &write_frame, -1, stream_id);
+ status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
if (status == SWITCH_STATUS_MORE_DATA) {
status = SWITCH_STATUS_SUCCESS;
switch_yield(10000);
}
- tstatus = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ tstatus = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
if (!SWITCH_READ_ACCEPTABLE(tstatus)) {
break;
switch_size_t ilen = 0;
switch_frame_t write_frame = { 0 };
int x;
- int stream_id = 0;
int done = 0;
int lead_in_out = 10;
switch_status_t status = SWITCH_STATUS_SUCCESS;
if (timer) {
write_frame.timestamp = timer->samplecount;
}
- if (switch_core_session_write_frame(session, &write_frame, -1, stream_id) != SWITCH_STATUS_SUCCESS) {
+ if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
done = 1;
break;
}
}
} else {
switch_frame_t *read_frame;
- switch_status_t tstatus = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ switch_status_t tstatus = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
while (switch_channel_ready(channel) && switch_channel_test_flag(channel, CF_HOLD)) {
switch_yield(10000);
if (timer) {
write_frame.timestamp = timer->samplecount;
}
- if (switch_core_session_write_frame(session, &write_frame, -1, stream_id) != SWITCH_STATUS_SUCCESS) {
+ if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
done = 1;
break;
}
if (timer) {
write_frame.timestamp = timer->samplecount;
}
- if (switch_core_session_write_frame(session, &write_frame, -1, stream_id) != SWITCH_STATUS_SUCCESS) {
+ if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
done = 1;
break;
}
}
} else { /* time off the channel (if you must) */
switch_frame_t *read_frame;
- switch_status_t tstatus = switch_core_session_read_frame(session, &read_frame, -1, 0);
+ switch_status_t tstatus = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
while (switch_channel_ready(channel) && switch_channel_test_flag(channel, CF_HOLD)) {
switch_yield(10000);
switch_codec_t lcodec, *codec;
switch_memory_pool_t *pool = switch_core_session_get_pool(session);
char *codec_name;
- int stream_id = 0;
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_speech_handle_t lsh, *sh;
switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "setup timer success %u bytes per %d ms!\n", sh->samples * 2, interval);
}
/* start a thread to absorb incoming audio */
- for (stream_id = 0; stream_id < switch_core_session_get_stream_count(session); stream_id++) {
- switch_core_service_session(session, &thread_session, stream_id);
- }
+ switch_core_service_session(session, &thread_session, 0);
+
}
status = switch_ivr_speak_text_handle(session, sh, write_frame.codec, timer_name ? timer : NULL, text, args);
}
}
-static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_type, switch_frame_flag_t *flags)
+static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
{
switch_size_t bytes = 0;
switch_status_t status;
goto end;
}
+ if (!bytes && (io_flags & SWITCH_IO_FLAG_NOBLOCK)) {
+ do_cng = 1;
+ goto cng;
+ }
+
+
if (rtp_session->timer.interval) {
check = (uint8_t) (switch_core_timer_check(&rtp_session->timer, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS);
if (bytes) {
}
SWITCH_DECLARE(switch_status_t) switch_rtp_read(switch_rtp_t *rtp_session, void *data, uint32_t * datalen,
- switch_payload_t *payload_type, switch_frame_flag_t *flags)
+ switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
{
int bytes = 0;
return SWITCH_STATUS_FALSE;
}
- bytes = rtp_common_read(rtp_session, payload_type, flags);
+ bytes = rtp_common_read(rtp_session, payload_type, flags, io_flags);
if (bytes < 0) {
*datalen = 0;
return SWITCH_STATUS_SUCCESS;
}
-SWITCH_DECLARE(switch_status_t) switch_rtp_zerocopy_read_frame(switch_rtp_t *rtp_session, switch_frame_t *frame)
+SWITCH_DECLARE(switch_status_t) switch_rtp_zerocopy_read_frame(switch_rtp_t *rtp_session, switch_frame_t *frame, switch_io_flag_t io_flags)
{
int bytes = 0;
return SWITCH_STATUS_FALSE;
}
- bytes = rtp_common_read(rtp_session, &frame->payload, &frame->flags);
+ bytes = rtp_common_read(rtp_session, &frame->payload, &frame->flags, io_flags);
frame->data = rtp_session->recv_msg.body;
frame->packet = &rtp_session->recv_msg;
}
SWITCH_DECLARE(switch_status_t) switch_rtp_zerocopy_read(switch_rtp_t *rtp_session,
- void **data, uint32_t * datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags)
+ void **data, uint32_t * datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
{
int bytes = 0;
return SWITCH_STATUS_FALSE;
}
- bytes = rtp_common_read(rtp_session, payload_type, flags);
+ bytes = rtp_common_read(rtp_session, payload_type, flags, io_flags);
*data = rtp_session->recv_msg.body;
if (bytes < 0) {
projects / thirdparty / freeswitch.git / commitdiff
