Codec Functions

Collaboration diagram for Codec Functions:

Macros
#define	switch_core_codec_init(_codec, _codec_name, _modname, _fmtp, _rate, _ms, _channels, _flags, _codec_settings, _pool)   switch_core_codec_init_with_bitrate(_codec, _codec_name, _modname, _fmtp, _rate, _ms, _channels, 0, _flags, _codec_settings, _pool)
	Initialize a codec handle. More...

Functions
switch_status_t	switch_core_codec_init_with_bitrate (switch_codec_t *codec, const char *codec_name, const char *fmtp, const char *modname, 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_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_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_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_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_decode_video (switch_codec_t *codec, switch_frame_t *frame)
	Decode video data using a codec handle. More...
switch_status_t	switch_core_codec_destroy (switch_codec_t *codec)
	Destroy an initalized codec handle. More...
switch_status_t	switch_core_session_set_read_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the read codec to a given session. More...
switch_status_t	switch_core_session_set_real_read_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the original read codec to a given session. This is the read codec used by an endpoint. More...
void	switch_core_session_unset_read_codec (_In_ switch_core_session_t *session)
void	switch_core_session_unset_write_codec (_In_ switch_core_session_t *session)
void	switch_core_session_lock_codec_write (_In_ switch_core_session_t *session)
void	switch_core_session_unlock_codec_write (_In_ switch_core_session_t *session)
void	switch_core_session_lock_codec_read (_In_ switch_core_session_t *session)
void	switch_core_session_unlock_codec_read (_In_ switch_core_session_t *session)
void	switch_core_codec_lock_full (switch_core_session_t *session)
	Lock codec read mutex and codec write mutex using trylock in an infinite loop. More...
void	switch_core_codec_unlock_full (switch_core_session_t *session)
	Unlock codec read mutex and codec write mutex. More...
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_codec_t *	switch_core_session_get_read_codec (_In_ switch_core_session_t *session)
	Retrieve the read codec from a given session. More...
switch_codec_t *	switch_core_session_get_effective_read_codec (_In_ switch_core_session_t *session)
	Retrieve the effevtive read codec from a given session. More...
switch_status_t	switch_core_session_set_write_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the write codec to a given session. More...
switch_codec_t *	switch_core_session_get_write_codec (_In_ switch_core_session_t *session)
	Retrieve the write codec from a given session. More...
switch_codec_t *	switch_core_session_get_effective_write_codec (_In_ switch_core_session_t *session)
	Retrieve the effevtive write codec from a given session. More...
switch_status_t	switch_core_session_set_video_read_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the video_read codec to a given session. More...
switch_codec_t *	switch_core_session_get_video_read_codec (_In_ switch_core_session_t *session)
	Retrieve the video_read codec from a given session. More...
switch_status_t	switch_core_session_set_video_write_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the video_write codec to a given session. More...
switch_codec_t *	switch_core_session_get_video_write_codec (_In_ switch_core_session_t *session)
	Retrieve the video_write codec from a given session. More...

Detailed Description

Macro Definition Documentation

switch_core_codec_init

#define switch_core_codec_init	(		_codec,
			_codec_name,
			_modname,
			_fmtp,
			_rate,
			_ms,
			_channels,
			_flags,
			_codec_settings,
			_pool
	)		switch_core_codec_init_with_bitrate(_codec, _codec_name, _modname, _fmtp, _rate, _ms, _channels, 0, _flags, _codec_settings, _pool)

Initialize a codec handle.

Parameters

codec	the handle to initilize
codec_name	the name of the codec module to use
fmtp	codec parameters to send
rate	the desired rate (0 for any)
ms	the desired number of milliseconds (0 for any)
channels	the desired number of channels (0 for any)
flags	flags to alter behaviour
codec_settings	desired codec settings
pool	the memory pool to use

Returns

SWITCH_STATUS_SUCCESS if the handle is allocated

Definition at line 1693 of file switch_core.h.

Referenced by audio_bridge_thread(), early_thread_run(), setup_ringback(), switch_core_codec_copy(), switch_core_media_set_video_codec(), switch_core_session_set_codec_slin(), switch_ivr_activate_unicast(), switch_ivr_collect_digits_count(), switch_ivr_detect_audio(), switch_ivr_detect_silence(), switch_ivr_eavesdrop_session(), switch_ivr_gentones(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_sleep(), switch_ivr_sound_test(), switch_ivr_speak_text(), switch_ivr_wait_for_answer(), switch_ivr_wait_for_silence(), and switch_rtp_enable_vad().

Function Documentation

switch_core_codec_control()

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

Parameters

codec	the codec handle to use
cmd	the command to send
ctype	the type of the arguement
cmd_data	a void pointer to the data matching the passed type
atype	the type of the extra arguement
cmd_arg	a void pointer to the data matching the passed type
rtype	the type of the response if any
ret_data	a void pointer to a pointer of return data

Returns

SWITCH_STATUS_SUCCESS if the command was received

Definition at line 903 of file switch_core_codec.c.

References switch_codec_implementation::codec_control, switch_codec::implementation, switch_codec::mutex, switch_assert, SWITCH_CHANNEL_LOG, switch_core_codec_ready(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_FALSE.

Referenced by switch_core_media_codec_control(), switch_core_media_receive_message(), switch_core_media_set_outgoing_bitrate(), and switch_core_session_stop_media().

{

        switch_status_t status = SWITCH_STATUS_FALSE;


        switch_assert(codec != NULL);


        if (!codec->implementation || !switch_core_codec_ready(codec)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec is not initialized!\n");
                abort();
                //return SWITCH_STATUS_NOT_INITALIZED;
        }


        if (codec->mutex) switch_mutex_lock(codec->mutex);

        if (codec->implementation->codec_control) {
                status = codec->implementation->codec_control(codec, cmd, ctype, cmd_data, atype, cmd_arg, rtype, ret_data);
        }

        if (codec->mutex) switch_mutex_unlock(codec->mutex);


        return status;
}

switch_core_codec_copy()

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
	)

Definition at line 641 of file switch_core_codec.c.

References switch_codec_implementation::actual_samples_per_second, switch_codec::flags, switch_codec::fmtp_in, switch_codec_implementation::iananame, switch_codec::implementation, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::modname, switch_codec_implementation::number_of_channels, switch_codec_implementation::samples_per_second, switch_assert, and switch_core_codec_init.

Referenced by switch_core_session_read_frame().

{
        uint32_t codec_rate;
        switch_assert(codec != NULL);
        switch_assert(new_codec != NULL);

        codec_rate = !strcasecmp(codec->implementation->iananame, "g722")
                                ? codec->implementation->samples_per_second : codec->implementation->actual_samples_per_second;

        return switch_core_codec_init(new_codec,
                                                                  codec->implementation->iananame,
                                                                  codec->implementation->modname,
                                                                  codec->fmtp_in,
                                                                  codec_rate,
                                                                  codec->implementation->microseconds_per_packet / 1000,
                                                                  codec->implementation->number_of_channels,
                                                                  codec->flags,
                                                                  codec_settings,
                                                                  pool);

}

switch_core_codec_decode()

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.

Parameters

codec	the codec handle to use
other_codec	the codec handle of the last codec used
encoded_data	the buffer to read the encoded data from
encoded_data_len	the size of the encoded_data buffer
encoded_rate	the rate of the encoded data
decoded_data	the raw data buffer
decoded_data_len	then length of the raw buffer
decoded_rate	the new rate of the decoded data
flag	flags to exchange

Returns

SWITCH_STATUS_SUCCESS if the data was decoded

Note

decoded_data_len will be rewritten to the in-use size of decoded_data

Definition at line 796 of file switch_core_codec.c.

References switch_codec_implementation::decode, switch_codec_implementation::decoded_bytes_per_packet, switch_codec_implementation::encoded_bytes_per_packet, switch_codec::implementation, memset(), switch_codec::mutex, switch_codec_implementation::number_of_channels, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_CODEC_FLAG_DECODE, switch_core_codec_ready(), SWITCH_LOG_CRIT, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_NOT_INITALIZED, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by main(), rtp_common_write(), switch_core_session_read_frame(), switch_core_session_write_frame(), and switch_ivr_park().

{
        switch_status_t status;

        switch_assert(codec != NULL);
        switch_assert(encoded_data != NULL);
        switch_assert(decoded_data != NULL);

        if (!codec->implementation || !switch_core_codec_ready(codec)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Decode Codec is not initialized!\n");
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (!switch_test_flag(codec, SWITCH_CODEC_FLAG_DECODE)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec decoder is not initialized!\n");
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (codec->implementation->encoded_bytes_per_packet) {
                uint32_t frames = encoded_data_len / codec->implementation->encoded_bytes_per_packet / codec->implementation->number_of_channels;

                if (frames && codec->implementation->decoded_bytes_per_packet * frames > *decoded_data_len) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Buffer size sanity check failed! edl:%u ebpp:%u fr:%u ddl:%u\n",
                                                          encoded_data_len, codec->implementation->encoded_bytes_per_packet, frames, *decoded_data_len);
                        *decoded_data_len = codec->implementation->decoded_bytes_per_packet;
                        memset(decoded_data, 255, *decoded_data_len);
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        if (codec->mutex) switch_mutex_lock(codec->mutex);
        status = codec->implementation->decode(codec, other_codec, encoded_data, encoded_data_len, encoded_rate,
                                                                                   decoded_data, decoded_data_len, decoded_rate, flag);
        if (codec->mutex) switch_mutex_unlock(codec->mutex);

        return status;
}

switch_core_codec_decode_video()

switch_status_t switch_core_codec_decode_video	(	switch_codec_t *	codec,
		switch_frame_t *	frame
	)

Decode video data using a codec handle.

Parameters

codec	the codec handle to use
frame	the frame to be decoded
img	the new image in I420 format, allocated by the codec
flag	flags to exchange

Returns

SWITCH_STATUS_SUCCESS if the data was decoded, and a non-NULL img

Definition at line 875 of file switch_core_codec.c.

References switch_codec_implementation::decode_video, switch_codec::implementation, switch_codec::mutex, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_CODEC_FLAG_DECODE, switch_core_codec_ready(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_NOT_INITALIZED, and switch_test_flag.

Referenced by switch_core_session_read_video_frame().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_assert(codec != NULL);
        switch_assert(frame != NULL);

        if (!codec->implementation || !switch_core_codec_ready(codec)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Decode Codec is not initialized!\n");
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (!switch_test_flag(codec, SWITCH_CODEC_FLAG_DECODE)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec decoder is not initialized!\n");
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (codec->mutex) switch_mutex_lock(codec->mutex);

        if (codec->implementation->decode_video) {
                status = codec->implementation->decode_video(codec, frame);
        }
        if (codec->mutex) switch_mutex_unlock(codec->mutex);

        return status;
}

switch_core_codec_destroy()

switch_status_t switch_core_codec_destroy

(

switch_codec_t *

codec

)

Destroy an initalized codec handle.

Parameters

codec

the codec handle to destroy

Returns

SWITCH_STATUS_SUCCESS if the codec was destroyed

Definition at line 938 of file switch_core_codec.c.

References switch_codec::codec_interface, switch_codec_implementation::destroy, switch_codec::implementation, switch_codec::memory_pool, memset(), switch_codec::mutex, mutex, pool, switch_assert, SWITCH_CHANNEL_LOG, switch_clear_flag, SWITCH_CODEC_FLAG_FREE_POOL, SWITCH_CODEC_FLAG_READY, switch_core_codec_ready(), switch_core_destroy_memory_pool, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_NOT_INITALIZED, SWITCH_STATUS_SUCCESS, switch_test_flag, and UNPROTECT_INTERFACE.

Referenced by audio_bridge_thread(), early_thread_run(), main(), switch_core_media_bug_prune(), switch_core_media_bug_remove(), switch_core_media_bug_remove_all_function(), switch_core_media_bug_remove_callback(), switch_core_media_bug_transfer_callback(), switch_core_media_set_codec(), switch_core_media_set_video_codec(), switch_core_session_raw_read(), switch_core_session_reset(), switch_core_session_set_real_read_codec(), switch_ivr_clear_speech_cache(), switch_ivr_collect_digits_count(), switch_ivr_deactivate_unicast(), switch_ivr_detect_audio(), switch_ivr_detect_silence(), switch_ivr_eavesdrop_session(), switch_ivr_gentones(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_sleep(), switch_ivr_sound_test(), switch_ivr_speak_text(), switch_ivr_wait_for_answer(), switch_ivr_wait_for_silence(), switch_media_handle_destroy(), and switch_rtp_disable_vad().

{
        switch_mutex_t *mutex = NULL;
        switch_memory_pool_t *pool = NULL;
        int free_pool = 0;

        switch_assert(codec != NULL);
        mutex = codec->mutex;
        pool = codec->memory_pool;

        if (mutex) switch_mutex_lock(mutex);

        if (switch_core_codec_ready(codec)) {
                switch_clear_flag(codec, SWITCH_CODEC_FLAG_READY);
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Codec is not initialized!\n");
                if (mutex) switch_mutex_unlock(mutex);
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (switch_test_flag(codec, SWITCH_CODEC_FLAG_FREE_POOL)) {
                free_pool = 1;
        }

        codec->implementation->destroy(codec);

        UNPROTECT_INTERFACE(codec->codec_interface);

        if (mutex) switch_mutex_unlock(mutex);

        if (free_pool) {
                switch_core_destroy_memory_pool(&pool);
        }

        memset(codec, 0, sizeof(*codec));

        return SWITCH_STATUS_SUCCESS;
}

switch_core_codec_encode()

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.

Parameters

codec	the codec handle to use
other_codec	the codec handle of the last codec used
decoded_data	the raw data
decoded_data_len	then length of the raw buffer
decoded_rate	the rate of the decoded data
encoded_data	the buffer to write the encoded data to
encoded_data_len	the size of the encoded_data buffer
encoded_rate	the new rate of the encoded data
flag	flags to exchange

Returns

SWITCH_STATUS_SUCCESS if the data was encoded

Note

encoded_data_len will be rewritten to the in-use size of encoded_data

Definition at line 764 of file switch_core_codec.c.

References switch_codec_implementation::encode, switch_codec::implementation, switch_codec::mutex, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_ready(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_NOT_INITALIZED, and switch_test_flag.

Referenced by main(), switch_core_session_read_frame(), and switch_core_session_write_frame().

{
        switch_status_t status;

        switch_assert(codec != NULL);
        switch_assert(encoded_data != NULL);
        switch_assert(decoded_data != NULL);

        if (!codec->implementation || !switch_core_codec_ready(codec)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec is not initialized!\n");
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (!switch_test_flag(codec, SWITCH_CODEC_FLAG_ENCODE)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec encoder is not initialized!\n");
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (codec->mutex) switch_mutex_lock(codec->mutex);
        status = codec->implementation->encode(codec, other_codec, decoded_data, decoded_data_len,
                                                                                   decoded_rate, encoded_data, encoded_data_len, encoded_rate, flag);
        if (codec->mutex) switch_mutex_unlock(codec->mutex);

        return status;

}

switch_core_codec_encode_video()

switch_status_t switch_core_codec_encode_video	(	switch_codec_t *	codec,
		switch_frame_t *	frame
	)

Encode video data using a codec handle.

Parameters

codec	the codec handle to use
frame	the frame to encode

Definition at line 839 of file switch_core_codec.c.

References switch_frame::datalen, switch_codec_implementation::encode_video, switch_frame::flags, switch_codec::implementation, switch_codec::mutex, switch_frame::packetlen, SFF_SAME_IMAGE, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_ready(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MORE_DATA, SWITCH_STATUS_NOT_INITALIZED, and switch_test_flag.

Referenced by switch_core_session_write_video_frame().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_assert(codec != NULL);

        if (!codec->implementation || !switch_core_codec_ready(codec)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec is not initialized!\n");
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (!switch_test_flag(codec, SWITCH_CODEC_FLAG_ENCODE)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec encoder is not initialized!\n");
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        if (codec->mutex) switch_mutex_lock(codec->mutex);

        if (codec->implementation->encode_video) {
                status = codec->implementation->encode_video(codec, frame);

                if (status == SWITCH_STATUS_MORE_DATA) {
                        frame->flags |= SFF_SAME_IMAGE;
                } else {
                        frame->flags &= ~SFF_SAME_IMAGE;
                }

                frame->packetlen = frame->datalen + 12;
        }

        if (codec->mutex) switch_mutex_unlock(codec->mutex);

        return status;

}

switch_core_codec_init_with_bitrate()

switch_status_t switch_core_codec_init_with_bitrate	(	switch_codec_t *	codec,
		const char *	codec_name,
		const char *	fmtp,
		const char *	modname,
		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
	)

Definition at line 664 of file switch_core_codec.c.

References switch_codec_implementation::actual_samples_per_second, switch_codec_implementation::bits_per_second, switch_codec::codec_interface, switch_cache_db_handle::flags, switch_codec::flags, switch_codec::fmtp_in, switch_codec::implementation, switch_codec_interface::implementations, switch_codec_implementation::init, switch_codec::memory_pool, memset(), switch_codec_implementation::microseconds_per_packet, switch_codec::mutex, switch_codec_implementation::next, switch_codec_implementation::number_of_channels, pool, switch_codec_implementation::samples_per_second, switch_codec::session, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_CODEC_FLAG_FREE_POOL, SWITCH_CODEC_FLAG_READY, switch_core_memory_pool_get_data(), switch_core_new_memory_pool, switch_core_strdup, switch_loadable_module_get_codec_interface(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_set_flag, SWITCH_STATUS_GENERR, SWITCH_STATUS_NOTIMPL, SWITCH_STATUS_SUCCESS, and UNPROTECT_INTERFACE.

Referenced by main(), and switch_core_media_set_codec().

{
        switch_codec_interface_t *codec_interface;
        const switch_codec_implementation_t *iptr, *implementation = NULL;

        switch_assert(codec != NULL);
        switch_assert(codec_name != NULL);

        memset(codec, 0, sizeof(*codec));

        if (pool) {
                codec->session = switch_core_memory_pool_get_data(pool, "__session");
        }

        if (strchr(codec_name, '.')) {
                char *p = NULL;
                codec_name = switch_core_strdup(pool, codec_name);
                if ((p = strchr(codec_name, '.'))) {
                        *p++ = '\0';
                        modname = codec_name;
                        codec_name = p;
                }
        }

        if ((codec_interface = switch_loadable_module_get_codec_interface(codec_name, modname)) == 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid codec %s!\n", codec_name);
                return SWITCH_STATUS_GENERR;
        }

        if (!strncasecmp(codec_name, "PROXY", 5)) {
                for (iptr = codec_interface->implementations; iptr; iptr = iptr->next) {
                        if (!channels || channels == iptr->number_of_channels) {
                                implementation = iptr;
                                break;
                        }
                }

                goto found;
        }

        /* If no specific codec interval is requested opt for 20ms above all else because lots of stuff assumes it */
        if (!ms) {
                for (iptr = codec_interface->implementations; iptr; iptr = iptr->next) {
                        uint32_t crate = !strcasecmp(codec_name, "g722") ? iptr->samples_per_second : iptr->actual_samples_per_second;
                        if ((!rate || rate == crate) && (!bitrate || bitrate == (uint32_t)iptr->bits_per_second) &&
                                (20 == (iptr->microseconds_per_packet / 1000)) && (!channels || channels == iptr->number_of_channels)) {
                                implementation = iptr;
                                goto found;
                        }
                }
        }

        /* Either looking for a specific interval or there was no interval specified and there wasn't one @20ms available */
        for (iptr = codec_interface->implementations; iptr; iptr = iptr->next) {
                uint32_t crate = !strcasecmp(codec_name, "g722") ? iptr->samples_per_second : iptr->actual_samples_per_second;
                if ((!rate || rate == crate) && (!bitrate || bitrate == (uint32_t)iptr->bits_per_second) &&
                        (!ms || ms == (iptr->microseconds_per_packet / 1000)) && (!channels || channels == iptr->number_of_channels)) {
                        implementation = iptr;
                        break;
                }
        }

  found:

        if (implementation) {
                switch_status_t status;
                codec->codec_interface = codec_interface;
                codec->implementation = implementation;
                codec->flags = flags;

                if (pool) {
                        codec->memory_pool = pool;
                } else {
                        if ((status = switch_core_new_memory_pool(&codec->memory_pool)) != SWITCH_STATUS_SUCCESS) {
                                return status;
                        }
                        switch_set_flag(codec, SWITCH_CODEC_FLAG_FREE_POOL);
                }

                if (fmtp) {
                        codec->fmtp_in = switch_core_strdup(codec->memory_pool, fmtp);
                }

                implementation->init(codec, flags, codec_settings);
                switch_mutex_init(&codec->mutex, SWITCH_MUTEX_NESTED, codec->memory_pool);
                switch_set_flag(codec, SWITCH_CODEC_FLAG_READY);
                return SWITCH_STATUS_SUCCESS;
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Codec %s Exists but not at the desired implementation. %dhz %dms %dch\n",
                                                  codec_name, rate, ms, channels);

        }

        UNPROTECT_INTERFACE(codec_interface);

        return SWITCH_STATUS_NOTIMPL;
}

switch_core_codec_lock_full()

void switch_core_codec_lock_full

(

switch_core_session_t *

session

)

Lock codec read mutex and codec write mutex using trylock in an infinite loop.

Parameters

session

session to lock the codec in

Definition at line 62 of file switch_core_codec.c.

References switch_core_session::codec_read_mutex, switch_core_session::codec_write_mutex, switch_cond_next(), switch_mutex_trylock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_set_codec(), and switch_core_session_reset().

{
        do {
                if (switch_mutex_trylock(session->codec_write_mutex) == SWITCH_STATUS_SUCCESS) {
                        if (switch_mutex_trylock(session->codec_read_mutex) == SWITCH_STATUS_SUCCESS) {
                                return;
                        }

                        switch_mutex_unlock(session->codec_write_mutex);
                }

                switch_cond_next();
        } while (1);
}

switch_core_codec_parse_fmtp()

switch_status_t switch_core_codec_parse_fmtp	(	const char *	codec_name,
		const char *	fmtp,
		uint32_t	rate,
		switch_codec_fmtp_t *	codec_fmtp
	)

Definition at line 607 of file switch_core_codec.c.

References switch_codec_fmtp::actual_samples_per_second, memset(), switch_codec_interface::parse_fmtp, switch_loadable_module_get_codec_interface(), SWITCH_STATUS_FALSE, UNPROTECT_INTERFACE, and zstr.

Referenced by add_audio_codec(), and switch_core_media_negotiate_sdp().

{
        switch_codec_interface_t *codec_interface;
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (zstr(codec_name) || zstr(fmtp) || !codec_fmtp) {
                return SWITCH_STATUS_FALSE;
        }

        memset(codec_fmtp, 0, sizeof(*codec_fmtp));

        if ((codec_interface = switch_loadable_module_get_codec_interface(codec_name, NULL))) {
                if (codec_interface->parse_fmtp) {
                        codec_fmtp->actual_samples_per_second = rate;
                        status = codec_interface->parse_fmtp(fmtp, codec_fmtp);
                }

                UNPROTECT_INTERFACE(codec_interface);
        }

        return status;
}

switch_core_codec_reset()

switch_status_t switch_core_codec_reset

(

switch_codec_t *

codec

)

Definition at line 630 of file switch_core_codec.c.

References switch_codec_implementation::destroy, switch_codec::flags, switch_codec::implementation, switch_codec_implementation::init, switch_assert, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_read_frame(), and switch_core_session_write_frame().

{
        switch_assert(codec != NULL);

        codec->implementation->destroy(codec);
        codec->implementation->init(codec, codec->flags, NULL);

        return SWITCH_STATUS_SUCCESS;
}

switch_core_codec_unlock_full()

void switch_core_codec_unlock_full

(

switch_core_session_t *

session

)

Unlock codec read mutex and codec write mutex.

Parameters

session

session to unlock the codec in

Definition at line 77 of file switch_core_codec.c.

References switch_core_session::codec_read_mutex, switch_core_session::codec_write_mutex, and switch_mutex_unlock().

Referenced by switch_core_media_set_codec(), and switch_core_session_reset().

{
        switch_mutex_unlock(session->codec_read_mutex);
        switch_mutex_unlock(session->codec_write_mutex);
}

switch_core_session_get_effective_read_codec()

switch_codec_t* switch_core_session_get_effective_read_codec

(

_In_ switch_core_session_t *

session

)

Retrieve the effevtive read codec from a given session.

Parameters

session

session to retrieve from

Returns

a pointer to the codec

switch_core_session_get_effective_write_codec()

switch_codec_t* switch_core_session_get_effective_write_codec

(

_In_ switch_core_session_t *

session

)

Retrieve the effevtive write codec from a given session.

Parameters

session

session to retrieve from

Returns

a pointer to the codec

switch_core_session_get_read_codec()

switch_codec_t* switch_core_session_get_read_codec

(

_In_ switch_core_session_t *

session

)

Retrieve the read codec from a given session.

Parameters

session

session to retrieve from

Returns

a pointer to the codec

Referenced by setup_ringback(), switch_channel_test_ready(), switch_core_session_outgoing_channel(), switch_ivr_activate_unicast(), switch_ivr_delay_echo(), switch_ivr_displace_session(), switch_ivr_inband_dtmf_generate_session(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_session_event(), switch_ivr_wait_for_answer(), and switch_jb_set_session().

switch_core_session_get_read_impl()

switch_status_t switch_core_session_get_read_impl	(	switch_core_session_t *	session,
		switch_codec_implementation_t *	impp
	)

Definition at line 346 of file switch_core_codec.c.

References switch_codec_implementation::codec_id, memset(), switch_codec_implementation::number_of_channels, switch_core_session::read_impl, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by audio_bridge_thread(), early_thread_run(), inband_dtmf_generate_callback(), inherit_codec(), preprocess_callback(), record_callback(), recording_thread(), session_audio_callback(), setup_ringback(), switch_channel_event_set_basic_data(), switch_core_media_bug_add(), switch_core_media_bug_read(), switch_core_session_get_real_read_impl(), switch_core_session_set_codec_slin(), switch_core_session_transcoding(), switch_core_session_wait_for_video_input_params(), switch_ivr_collect_digits_count(), switch_ivr_delay_echo(), switch_ivr_detect_audio(), switch_ivr_detect_silence(), switch_ivr_detect_speech_init(), switch_ivr_displace_session(), switch_ivr_eavesdrop_session(), switch_ivr_gentones(), switch_ivr_inband_dtmf_session(), switch_ivr_insert_file(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_preprocess_session(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_ivr_session_audio(), switch_ivr_sleep(), switch_ivr_sound_test(), switch_ivr_speak_text(), switch_ivr_tone_detect_session(), and switch_ivr_wait_for_silence().

{
        if (session->read_impl.codec_id) {
                *impp = session->read_impl;
                return SWITCH_STATUS_SUCCESS;
        }

        memset(impp, 0, sizeof(*impp));
        impp->number_of_channels = 1;
        return SWITCH_STATUS_FALSE;
}

switch_core_session_get_real_read_impl()

switch_status_t switch_core_session_get_real_read_impl	(	switch_core_session_t *	session,
		switch_codec_implementation_t *	impp
	)

Definition at line 358 of file switch_core_codec.c.

References switch_codec_implementation::codec_id, switch_core_session::real_read_impl, switch_core_session_get_read_impl(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_eavesdrop_session().

{
        if (session->real_read_impl.codec_id) {
                *impp = session->real_read_impl;
                return SWITCH_STATUS_SUCCESS;
        }

        return switch_core_session_get_read_impl(session, impp);
}

switch_core_session_get_video_read_codec()

switch_codec_t* switch_core_session_get_video_read_codec

(

_In_ switch_core_session_t *

session

)

Retrieve the video_read codec from a given session.

Parameters

session

session to retrieve from

Returns

a pointer to the codec

Referenced by switch_core_session_outgoing_channel().

switch_core_session_get_video_read_impl()

switch_status_t switch_core_session_get_video_read_impl	(	switch_core_session_t *	session,
		switch_codec_implementation_t *	impp
	)

Definition at line 380 of file switch_core_codec.c.

References switch_codec_implementation::codec_id, memset(), switch_codec_implementation::number_of_channels, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_core_session::video_read_impl.

Referenced by inherit_codec(), and text_bridge_thread().

{
        if (session->video_read_impl.codec_id) {
                *impp = session->video_read_impl;
                return SWITCH_STATUS_SUCCESS;
        }

        memset(impp, 0, sizeof(*impp));
        impp->number_of_channels = 1;
        return SWITCH_STATUS_FALSE;
}

switch_core_session_get_video_write_codec()

switch_codec_t* switch_core_session_get_video_write_codec

(

_In_ switch_core_session_t *

session

)

Retrieve the video_write codec from a given session.

Parameters

session

session to retrieve from

Returns

a pointer to the codec

Referenced by switch_core_session_write_video_frame().

switch_core_session_get_video_write_impl()

switch_status_t switch_core_session_get_video_write_impl	(	switch_core_session_t *	session,
		switch_codec_implementation_t *	impp
	)

Definition at line 392 of file switch_core_codec.c.

References switch_codec_implementation::codec_id, memset(), switch_codec_implementation::number_of_channels, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_core_session::video_write_impl.

Referenced by text_bridge_thread().

{
        if (session->video_write_impl.codec_id) {
                *impp = session->video_write_impl;
                return SWITCH_STATUS_SUCCESS;
        }

        memset(impp, 0, sizeof(*impp));
        impp->number_of_channels = 1;
        return SWITCH_STATUS_FALSE;
}

switch_core_session_get_write_codec()

switch_codec_t* switch_core_session_get_write_codec

(

_In_ switch_core_session_t *

session

)

Retrieve the write codec from a given session.

Parameters

session

session to retrieve from

Returns

a pointer to the codec

Referenced by setup_ringback(), and switch_channel_test_ready().

switch_core_session_get_write_impl()

switch_status_t switch_core_session_get_write_impl	(	switch_core_session_t *	session,
		switch_codec_implementation_t *	impp
	)

Definition at line 368 of file switch_core_codec.c.

References switch_codec_implementation::codec_id, memset(), switch_codec_implementation::number_of_channels, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_core_session::write_impl.

Referenced by setup_ringback(), switch_channel_event_set_basic_data(), switch_core_media_bug_add(), and switch_core_session_send_dtmf_string().

{
        if (session->write_impl.codec_id) {
                *impp = session->write_impl;
                return SWITCH_STATUS_SUCCESS;
        }

        memset(impp, 0, sizeof(*impp));
        impp->number_of_channels = 1;
        return SWITCH_STATUS_FALSE;
}

switch_core_session_lock_codec_read()

void switch_core_session_lock_codec_read

(

_In_ switch_core_session_t *

session

)

switch_core_session_lock_codec_write()

void switch_core_session_lock_codec_write

(

_In_ switch_core_session_t *

session

)

switch_core_session_set_read_codec()

switch_status_t switch_core_session_set_read_codec	(	_In_ switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Assign the read codec to a given session.

Parameters

session	session to add the codec to
codec	the codec to add

Returns

SWITCH_STATUS_SUCCESS if successful

Referenced by early_thread_run(), setup_ringback(), switch_core_session_reset(), switch_core_session_set_codec_slin(), switch_ivr_detect_audio(), switch_ivr_detect_silence(), switch_ivr_eavesdrop_session(), switch_ivr_record_file_event(), switch_ivr_wait_for_answer(), and switch_ivr_wait_for_silence().

switch_core_session_set_real_read_codec()

switch_status_t switch_core_session_set_real_read_codec	(	_In_ switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Assign the original read codec to a given session. This is the read codec used by an endpoint.

Parameters

session	session to add the codec to
codec	the codec to add

Returns

SWITCH_STATUS_SUCCESS if successful

Referenced by switch_core_media_set_codec().

switch_core_session_set_video_read_codec()

switch_status_t switch_core_session_set_video_read_codec	(	_In_ switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Assign the video_read codec to a given session.

Parameters

session	session to add the codec to
codec	the codec to add

Returns

SWITCH_STATUS_SUCCESS if successful

Referenced by switch_core_media_set_video_codec().

switch_core_session_set_video_write_codec()

switch_status_t switch_core_session_set_video_write_codec	(	_In_ switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Assign the video_write codec to a given session.

Parameters

session	session to add the codec to
codec	the codec to add

Returns

SWITCH_STATUS_SUCCESS if successful

Referenced by switch_core_media_set_video_codec().

switch_core_session_set_write_codec()

switch_status_t switch_core_session_set_write_codec	(	_In_ switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Assign the write codec to a given session.

Parameters

session	session to add the codec to
codec	the codec to add

Returns

SWITCH_STATUS_SUCCESS if successful

Referenced by switch_core_media_set_codec().

switch_core_session_unlock_codec_read()

void switch_core_session_unlock_codec_read

(

_In_ switch_core_session_t *

session

)

switch_core_session_unlock_codec_write()

void switch_core_session_unlock_codec_write

(

_In_ switch_core_session_t *

session

)

switch_core_session_unset_read_codec()

void switch_core_session_unset_read_codec

(

_In_ switch_core_session_t *

session

)

Referenced by switch_media_handle_destroy().

switch_core_session_unset_write_codec()

void switch_core_session_unset_write_codec

(

_In_ switch_core_session_t *

session

)

Referenced by switch_media_handle_destroy().