switch_core_codec.c File Reference

#include <switch.h>
#include "private/switch_core_pvt.h"

Include dependency graph for switch_core_codec.c:

Go to the source code of this file.

Functions
uint32_t	switch_core_codec_next_id (void)
void	switch_core_session_unset_read_codec (switch_core_session_t *session)
void	switch_core_session_lock_codec_write (switch_core_session_t *session)
void	switch_core_session_unlock_codec_write (switch_core_session_t *session)
void	switch_core_session_lock_codec_read (switch_core_session_t *session)
void	switch_core_session_unlock_codec_read (switch_core_session_t *session)
void	switch_core_session_unset_write_codec (switch_core_session_t *session)
switch_status_t	switch_core_session_set_real_read_codec (switch_core_session_t *session, switch_codec_t *codec)
switch_status_t	switch_core_session_set_read_codec (switch_core_session_t *session, switch_codec_t *codec)
switch_codec_t *	switch_core_session_get_effective_read_codec (switch_core_session_t *session)
switch_codec_t *	switch_core_session_get_read_codec (switch_core_session_t *session)
switch_status_t	switch_core_session_get_read_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_get_real_read_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_get_write_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_get_video_read_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_get_video_write_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_set_read_impl (switch_core_session_t *session, const switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_set_write_impl (switch_core_session_t *session, const switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_set_video_read_impl (switch_core_session_t *session, const switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_set_video_write_impl (switch_core_session_t *session, const switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_set_write_codec (switch_core_session_t *session, switch_codec_t *codec)
switch_codec_t *	switch_core_session_get_effective_write_codec (switch_core_session_t *session)
switch_codec_t *	switch_core_session_get_write_codec (switch_core_session_t *session)
switch_status_t	switch_core_session_set_video_read_codec (switch_core_session_t *session, switch_codec_t *codec)
switch_codec_t *	switch_core_session_get_video_read_codec (switch_core_session_t *session)
switch_status_t	switch_core_session_set_video_write_codec (switch_core_session_t *session, switch_codec_t *codec)
switch_codec_t *	switch_core_session_get_video_write_codec (switch_core_session_t *session)
switch_status_t	switch_core_codec_parse_fmtp (const char *codec_name, const char *fmtp, uint32_t rate, switch_codec_fmtp_t *codec_fmtp)
switch_status_t	switch_core_codec_reset (switch_codec_t *codec)
switch_status_t	switch_core_codec_copy (switch_codec_t *codec, switch_codec_t *new_codec, const switch_codec_settings_t *codec_settings, switch_memory_pool_t *pool)
switch_status_t	switch_core_codec_init_with_bitrate (switch_codec_t *codec, const char *codec_name, const char *modname, const char *fmtp, uint32_t rate, int ms, int channels, uint32_t bitrate, uint32_t flags, const switch_codec_settings_t *codec_settings, switch_memory_pool_t *pool)
switch_status_t	switch_core_codec_encode (switch_codec_t *codec, switch_codec_t *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)
	Encode data using a codec handle. More...
switch_status_t	switch_core_codec_decode (switch_codec_t *codec, switch_codec_t *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)
	Decode data using a codec handle. More...
switch_status_t	switch_core_codec_encode_video (switch_codec_t *codec, switch_frame_t *frame)
	Encode video data using a codec handle. More...
switch_status_t	switch_core_codec_decode_video (switch_codec_t *codec, switch_frame_t *frame)
	Decode video data using a codec handle. More...
switch_status_t	switch_core_codec_control (switch_codec_t *codec, switch_codec_control_command_t cmd, switch_codec_control_type_t ctype, void *cmd_data, switch_codec_control_type_t atype, void *cmd_arg, switch_codec_control_type_t *rtype, void **ret_data)
	send control data using a codec handle More...
switch_status_t	switch_core_codec_destroy (switch_codec_t *codec)
	Destroy an initalized codec handle. More...

Variables
static uint32_t	CODEC_ID = 1

Function Documentation

switch_core_session_get_effective_read_codec()

switch_codec_t* switch_core_session_get_effective_read_codec

(

switch_core_session_t *

session

)

Definition at line 311 of file switch_core_codec.c.

References switch_core_session::read_codec.

{
        switch_codec_t *codec;
        codec = session->read_codec;
        return codec;
}

switch_core_session_get_effective_write_codec()

switch_codec_t* switch_core_session_get_effective_write_codec

(

switch_core_session_t *

session

)

Definition at line 474 of file switch_core_codec.c.

References switch_core_session::write_codec.

{
        switch_codec_t *codec;
        codec = session->write_codec;

        return codec;
}

switch_core_session_get_read_codec()

switch_codec_t* switch_core_session_get_read_codec

(

switch_core_session_t *

session

)

Definition at line 318 of file switch_core_codec.c.

References switch_core_session::read_codec, and switch_core_session::real_read_codec.

{
        switch_codec_t *codec;
        codec = session->real_read_codec ? session->real_read_codec : session->read_codec;
        return codec;
}

switch_core_session_get_video_read_codec()

switch_codec_t* switch_core_session_get_video_read_codec

(

switch_core_session_t *

session

)

Definition at line 532 of file switch_core_codec.c.

References switch_core_session::video_read_codec.

{
        switch_codec_t *codec;
        codec = session->video_read_codec;

        return codec;

}

switch_core_session_get_video_write_codec()

switch_codec_t* switch_core_session_get_video_write_codec

(

switch_core_session_t *

session

)

Definition at line 577 of file switch_core_codec.c.

References switch_core_session::video_write_codec.

{
        switch_codec_t *codec;
        codec = session->video_write_codec;

        return codec;

}

switch_core_session_get_write_codec()

switch_codec_t* switch_core_session_get_write_codec

(

switch_core_session_t *

session

)

Definition at line 482 of file switch_core_codec.c.

References switch_core_session::real_write_codec, and switch_core_session::write_codec.

{
        switch_codec_t *codec;
        codec = session->real_write_codec ? session->real_write_codec : session->write_codec;

        return codec;
}

switch_core_session_lock_codec_read()

void switch_core_session_lock_codec_read

(

switch_core_session_t *

session

)

Definition at line 72 of file switch_core_codec.c.

References switch_core_session::codec_read_mutex, and switch_mutex_lock().

{
        switch_mutex_lock(session->codec_read_mutex);
}

switch_core_session_lock_codec_write()

void switch_core_session_lock_codec_write

(

switch_core_session_t *

session

)

Definition at line 62 of file switch_core_codec.c.

References switch_core_session::codec_write_mutex, and switch_mutex_lock().

{
        switch_mutex_lock(session->codec_write_mutex);
}

switch_core_session_set_read_codec()

switch_status_t switch_core_session_set_read_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 203 of file switch_core_codec.c.

References switch_codec_implementation::actual_samples_per_second, switch_codec_implementation::bits_per_second, CF_MEDIA_SET, switch_core_session::channel, switch_frame::codec, switch_core_session::codec_read_mutex, switch_codec_implementation::decoded_bytes_per_packet, switch_core_session::enc_read_frame, switch_core_session::enc_write_frame, switch_codec_implementation::ianacode, switch_codec_implementation::iananame, switch_codec::implementation, memset(), switch_codec::next, switch_core_session::raw_read_frame, switch_core_session::raw_write_frame, switch_core_session::read_codec, switch_core_session::read_impl, switch_core_session::real_read_codec, switch_core_session::real_read_impl, switch_codec_implementation::samples_per_second, switch_channel_event_set_data(), switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, switch_core_codec_ready(), switch_core_session_get_channel(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_CODEC, switch_event_create, switch_event_fire, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_event_t *event;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char tmp[30];
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        switch_mutex_lock(session->codec_read_mutex);

        if (codec && (!codec->implementation || !switch_core_codec_ready(codec))) {
                codec = NULL;
        }

        if (codec) {
                if (!session->real_read_codec) {
                        session->read_codec = session->real_read_codec = codec;
                        if (codec->implementation) {
                                session->read_impl = *codec->implementation;
                                session->real_read_impl = *codec->implementation;
                        } else {
                                memset(&session->read_impl, 0, sizeof(session->read_impl));
                        }
                } else {
                        if (codec == session->read_codec) {
                                goto end;
                        }
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Push codec %s:%d\n",
                                                          switch_channel_get_name(session->channel), codec->implementation ? codec->implementation->iananame : "undefined", codec->implementation ? codec->implementation->ianacode : -1);
                        codec->next = session->read_codec;
                        session->read_codec = codec;
                        if (codec->implementation) {
                                session->read_impl = *codec->implementation;
                        } else {
                                memset(&session->read_impl, 0, sizeof(session->read_impl));
                        }
                }
        } else {
                if (session->read_codec == session->real_read_codec) {
                        goto end;
                }

                if (session->read_codec->next && switch_core_codec_ready(session->read_codec->next)) {
                        switch_codec_t *old = session->read_codec;
                        session->read_codec = session->read_codec->next;
                        if (session->read_codec->implementation) {
                                session->read_impl = *session->read_codec->implementation;
                        } else {
                                memset(&session->read_impl, 0, sizeof(session->read_impl));
                        }
                        old->next = NULL;

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Restore previous codec %s:%d.\n",
                                                          switch_channel_get_name(session->channel),
                                                          session->read_impl.iananame ? session->read_impl.iananame : "N/A", session->read_impl.ianacode);


                } else if (session->real_read_codec) {
                        session->read_codec = session->real_read_codec;
                        if (session->real_read_codec->implementation) {
                                session->read_impl = *session->real_read_codec->implementation;
                        } else {
                                memset(&session->read_impl, 0, sizeof(session->read_impl));
                        }
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Restore original codec.\n");
                } else {
                        status = SWITCH_STATUS_FALSE;
                        goto end;
                }
        }

        if (!session->read_codec) {
                status = SWITCH_STATUS_FALSE;
                goto end;
        }

        if (session->read_impl.decoded_bytes_per_packet) {
                if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
                        switch_channel_event_set_data(session->channel, event);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-read-codec-name", session->read_impl.iananame);
                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-rate", "%d", session->read_impl.actual_samples_per_second);
                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-bit-rate", "%d", session->read_impl.bits_per_second);
                        if (session->read_impl.actual_samples_per_second != session->read_impl.samples_per_second) {
                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-reported-read-codec-rate", "%d", session->read_impl.samples_per_second);
                        }
                        switch_event_fire(&event);
                }

                switch_channel_set_variable(channel, "read_codec", session->read_impl.iananame);
                switch_snprintf(tmp, sizeof(tmp), "%d", session->read_impl.actual_samples_per_second);
                switch_channel_set_variable(channel, "read_rate", tmp);

                session->raw_read_frame.codec = session->read_codec;
                session->raw_write_frame.codec = session->read_codec;
                session->enc_read_frame.codec = session->read_codec;
                session->enc_write_frame.codec = session->read_codec;
        }

  end:

        if (session->read_codec) {
                switch_channel_set_flag(channel, CF_MEDIA_SET);
        }

        switch_mutex_unlock(session->codec_read_mutex);
        return status;

}

switch_core_session_set_real_read_codec()

switch_status_t switch_core_session_set_real_read_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 94 of file switch_core_codec.c.

References switch_codec_implementation::actual_samples_per_second, switch_codec_implementation::bits_per_second, switch_core_session::bug_codec, switch_core_session::bug_rwlock, CF_MEDIA_SET, switch_core_session::channel, switch_frame::codec, switch_core_session::codec_read_mutex, switch_codec_implementation::decoded_bytes_per_packet, switch_core_session::enc_read_frame, switch_core_session::enc_write_frame, switch_codec_implementation::ianacode, switch_codec_implementation::iananame, switch_codec::implementation, memset(), switch_codec::next, switch_core_session::raw_read_frame, switch_core_session::raw_write_frame, switch_core_session::read_codec, switch_core_session::read_impl, switch_core_session::real_read_codec, switch_core_session::real_read_impl, switch_codec_implementation::samples_per_second, switch_channel_event_set_data(), switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_session_get_channel(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_CODEC, switch_event_create, switch_event_fire, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

{
        switch_event_t *event;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char tmp[30];
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        int changed_read_codec = 0;

        switch_mutex_lock(session->codec_read_mutex);

        if (codec && (!codec->implementation || !switch_core_codec_ready(codec))) {
                codec = NULL;
        }

        if (codec) {
                /* set real_read_codec and read_codec */
                if (!session->real_read_codec) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Original read codec set to %s:%d\n",
                                                          switch_channel_get_name(session->channel), codec->implementation->iananame, codec->implementation->ianacode);
                        session->read_codec = session->real_read_codec = codec;
                        changed_read_codec = 1;
                        if (codec->implementation) {
                                session->read_impl = *codec->implementation;
                                session->real_read_impl = *codec->implementation;
                        } else {
                                memset(&session->read_impl, 0, sizeof(session->read_impl));
                        }
                } else { /* replace real_read_codec */
                        switch_codec_t *cur_codec;

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Original read codec replaced with %s:%d\n",
                                                          switch_channel_get_name(session->channel), codec->implementation ? codec->implementation->iananame : "undefined", codec->implementation ? codec->implementation->ianacode : -1);
                        /* Set real_read_codec to front of the list of read_codecs */
                        cur_codec = session->read_codec;
                        while (cur_codec != NULL) {
                                if (cur_codec->next == session->real_read_codec) {
                                        cur_codec->next = codec;
                                        break;
                                }

                                cur_codec = cur_codec->next;
                        }

                        session->real_read_codec = codec;
                        session->real_read_impl = *codec->implementation;

                        /* set read_codec with real_read_codec if it no longer is ready */
                        if (!switch_core_codec_ready(session->read_codec)) {
                                session->read_codec = codec;
                                changed_read_codec = 1;
                                if (codec->implementation) {
                                        session->read_impl = *codec->implementation;
                                        session->real_read_impl = *codec->implementation;
                                } else {
                                        memset(&session->read_impl, 0, sizeof(session->read_impl));
                                }
                        }
                }

                /* force media bugs to copy the read codec from the next frame */
                switch_thread_rwlock_wrlock(session->bug_rwlock);
                if (switch_core_codec_ready(&session->bug_codec)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Destroying BUG Codec %s:%d\n",
                                session->bug_codec.implementation->iananame, session->bug_codec.implementation->ianacode);
                        switch_core_codec_destroy(&session->bug_codec);
                }

                switch_thread_rwlock_unlock(session->bug_rwlock);
        } else {
                status = SWITCH_STATUS_FALSE;
                goto end;
        }

        if (changed_read_codec && session->read_codec && session->read_impl.decoded_bytes_per_packet) {
                if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
                        switch_channel_event_set_data(session->channel, event);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-read-codec-name", session->read_impl.iananame);
                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-rate", "%d", session->read_impl.actual_samples_per_second);
                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-bit-rate", "%d", session->read_impl.bits_per_second);
                        if (session->read_impl.actual_samples_per_second != session->read_impl.samples_per_second) {
                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-reported-read-codec-rate", "%d", session->read_impl.samples_per_second);
                        }

                        switch_event_fire(&event);
                }

                switch_channel_set_variable(channel, "read_codec", session->read_impl.iananame);
                switch_channel_set_variable(channel, "original_read_codec", session->read_impl.iananame);
                switch_snprintf(tmp, sizeof(tmp), "%d", session->read_impl.actual_samples_per_second);
                switch_channel_set_variable(channel, "read_rate", tmp);
                switch_channel_set_variable(channel, "original_read_rate", tmp);

                session->raw_read_frame.codec = session->read_codec;
                session->raw_write_frame.codec = session->read_codec;
                session->enc_read_frame.codec = session->read_codec;
                session->enc_write_frame.codec = session->read_codec;
        }

  end:

        if (session->read_codec) {
                switch_channel_set_flag(channel, CF_MEDIA_SET);
        }

        switch_mutex_unlock(session->codec_read_mutex);

        return status;
}

switch_core_session_set_video_read_codec()

switch_status_t switch_core_session_set_video_read_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 492 of file switch_core_codec.c.

References switch_codec_implementation::actual_samples_per_second, switch_core_session::channel, switch_codec_implementation::iananame, switch_codec::implementation, memset(), switch_channel_event_set_data(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_codec_ready(), switch_core_session_get_channel(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_CODEC, switch_event_create, switch_event_fire, SWITCH_LOG_ERROR, switch_log_printf(), switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_core_session::video_read_codec, and switch_core_session::video_read_impl.

{
        switch_event_t *event;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char tmp[30];
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if (!codec || !codec->implementation || !switch_core_codec_ready(codec)) {
                if (session->video_read_codec) {
                        session->video_read_codec = NULL;
                        status = SWITCH_STATUS_SUCCESS;
                        goto end;
                }
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot set NULL codec!\n");
                status = SWITCH_STATUS_FALSE;
                goto end;
        }

        if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(session->channel, event);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-video-read-codec-name", codec->implementation->iananame);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-video-read-codec-rate", "%d", codec->implementation->actual_samples_per_second);
                switch_event_fire(&event);
        }

        switch_channel_set_variable(channel, "video_read_codec", codec->implementation->iananame);
        switch_snprintf(tmp, sizeof(tmp), "%d", codec->implementation->actual_samples_per_second);
        switch_channel_set_variable(channel, "video_read_rate", tmp);

        session->video_read_codec = codec;
        if (codec->implementation) {
                session->video_read_impl = *codec->implementation;
        } else {
                memset(&session->video_read_impl, 0, sizeof(session->video_read_impl));
        }
  end:

        return status;
}

switch_core_session_set_video_write_codec()

switch_status_t switch_core_session_set_video_write_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 541 of file switch_core_codec.c.

References switch_codec_implementation::actual_samples_per_second, switch_core_session::channel, switch_codec_implementation::iananame, switch_codec::implementation, switch_channel_event_set_data(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_codec_ready(), switch_core_session_get_channel(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_CODEC, switch_event_create, switch_event_fire, SWITCH_LOG_ERROR, switch_log_printf(), switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_core_session::video_write_codec, and switch_core_session::video_write_impl.

{
        switch_event_t *event;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char tmp[30];
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        if (!codec || !codec->implementation || !switch_core_codec_ready(codec)) {
                if (session->video_write_codec) {
                        session->video_write_codec = NULL;
                        status = SWITCH_STATUS_SUCCESS;
                        goto end;
                }
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot set NULL codec!\n");
                status = SWITCH_STATUS_FALSE;
                goto end;
        }

        if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(session->channel, event);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-video-write-codec-name", codec->implementation->iananame);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-video-write-codec-rate", "%d", codec->implementation->actual_samples_per_second);
                switch_event_fire(&event);
        }

        switch_channel_set_variable(channel, "video_write_codec", codec->implementation->iananame);
        switch_snprintf(tmp, sizeof(tmp), "%d", codec->implementation->actual_samples_per_second);
        switch_channel_set_variable(channel, "video_write_rate", tmp);

        session->video_write_codec = codec;
        session->video_write_impl = *codec->implementation;

  end:

        return status;
}

switch_core_session_set_write_codec()

switch_status_t switch_core_session_set_write_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 409 of file switch_core_codec.c.

References switch_codec_implementation::actual_samples_per_second, switch_codec_implementation::bits_per_second, switch_core_session::channel, switch_codec_implementation::codec_id, switch_core_session::codec_write_mutex, switch_codec_implementation::iananame, switch_codec::implementation, switch_core_session::real_write_codec, switch_codec_implementation::samples_per_second, switch_channel_event_set_data(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_codec_ready(), switch_core_session_get_channel(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_CODEC, switch_event_create, switch_event_fire, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_core_session::write_codec, and switch_core_session::write_impl.

{
        switch_event_t *event;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char tmp[30];
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        switch_mutex_lock(session->codec_write_mutex);

        if (!codec || !codec->implementation || !switch_core_codec_ready(codec)) {
                if (session->real_write_codec) {
                        session->write_codec = session->real_write_codec;
                        session->write_impl = *session->real_write_codec->implementation;
                        session->real_write_codec = NULL;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot set NULL codec!\n");
                        status = SWITCH_STATUS_FALSE;
                        goto end;
                }
        } else if (session->write_codec) {
                if (session->real_write_codec) {
                        if (codec == session->real_write_codec) {
                                session->write_codec = codec;
                                session->write_impl = *codec->implementation;
                                session->real_write_codec = NULL;
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot double-set codec!\n");
                                status = SWITCH_STATUS_FALSE;
                                goto end;
                        }
                } else {
                        session->real_write_codec = session->write_codec;
                        session->write_codec = codec;
                        session->write_impl = *codec->implementation;
                }
        } else {
                session->write_codec = codec;
                session->write_impl = *codec->implementation;
        }

        if (codec && session->write_impl.codec_id) {
                if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
                        switch_channel_event_set_data(session->channel, event);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Name", session->write_impl.iananame);
                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Rate", "%d", session->write_impl.actual_samples_per_second);
                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Write-codec-bit-rate", "%d", session->write_impl.bits_per_second);
                        if (session->write_impl.actual_samples_per_second != session->write_impl.samples_per_second) {
                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Reported-Write-Codec-Rate", "%d",
                                                                                session->write_impl.actual_samples_per_second);
                        }
                        switch_event_fire(&event);
                }

                switch_channel_set_variable(channel, "write_codec", session->write_impl.iananame);
                switch_snprintf(tmp, sizeof(tmp), "%d", session->write_impl.actual_samples_per_second);
                switch_channel_set_variable(channel, "write_rate", tmp);
        }

  end:
        switch_mutex_unlock(session->codec_write_mutex);

        return status;
}

switch_core_session_unlock_codec_read()

void switch_core_session_unlock_codec_read

(

switch_core_session_t *

session

)

Definition at line 77 of file switch_core_codec.c.

References switch_core_session::codec_read_mutex, and switch_mutex_unlock().

{
        switch_mutex_unlock(session->codec_read_mutex);
}

switch_core_session_unlock_codec_write()

void switch_core_session_unlock_codec_write

(

switch_core_session_t *

session

)

Definition at line 67 of file switch_core_codec.c.

References switch_core_session::codec_write_mutex, and switch_mutex_unlock().

{
        switch_mutex_unlock(session->codec_write_mutex);
}

switch_core_session_unset_read_codec()

void switch_core_session_unset_read_codec

(

switch_core_session_t *

session

)

Definition at line 46 of file switch_core_codec.c.

References switch_frame::codec, switch_core_session::codec_read_mutex, switch_core_session::enc_read_frame, switch_core_session::enc_write_frame, switch_codec::mutex, mutex, switch_core_session::raw_read_frame, switch_core_session::raw_write_frame, switch_core_session::read_codec, switch_core_session::real_read_codec, switch_mutex_lock(), and switch_mutex_unlock().

{
        switch_mutex_t *mutex = NULL;

        switch_mutex_lock(session->codec_read_mutex);
        if (session->read_codec) mutex = session->read_codec->mutex;
        if (mutex) switch_mutex_lock(mutex);
        session->real_read_codec = session->read_codec = NULL;
        session->raw_read_frame.codec = session->read_codec;
        session->raw_write_frame.codec = session->read_codec;
        session->enc_read_frame.codec = session->read_codec;
        session->enc_write_frame.codec = session->read_codec;
        if (mutex) switch_mutex_unlock(mutex);
        switch_mutex_unlock(session->codec_read_mutex);
}

switch_core_session_unset_write_codec()

void switch_core_session_unset_write_codec

(

switch_core_session_t *

session

)

Definition at line 82 of file switch_core_codec.c.

References switch_core_session::codec_write_mutex, switch_codec::mutex, mutex, switch_core_session::real_write_codec, switch_mutex_lock(), switch_mutex_unlock(), and switch_core_session::write_codec.

{
        switch_mutex_t *mutex = NULL;

        switch_mutex_lock(session->codec_write_mutex);
        if (session->write_codec) mutex = session->write_codec->mutex;
        if (mutex) switch_mutex_lock(mutex);
        session->real_write_codec = session->write_codec = NULL;
        if (mutex) switch_mutex_unlock(mutex);
        switch_mutex_unlock(session->codec_write_mutex);
}

Variable Documentation

CODEC_ID

uint32_t CODEC_ID = 1

static

Definition at line 39 of file switch_core_codec.c.

Referenced by switch_core_codec_next_id().