FreeSWITCH API Documentation: switch_core

switch_codec_t* switch_core_session_get_effective_read_codec ( switch_core_session_t * session )

Definition at line 301 of file switch_core_codec.c.

00302 {
00303         switch_codec_t *codec;
00304         codec = session->read_codec;
00305         return codec;
00306 }

switch_codec_t* switch_core_session_get_effective_write_codec ( switch_core_session_t * session )

Definition at line 456 of file switch_core_codec.c.

00457 {
00458         switch_codec_t *codec;
00459         codec = session->write_codec;
00460 
00461         return codec;
00462 }

switch_codec_t* switch_core_session_get_read_codec ( switch_core_session_t * session )

Definition at line 308 of file switch_core_codec.c.

00309 {
00310         switch_codec_t *codec;
00311         codec = session->real_read_codec ? session->real_read_codec : session->read_codec;
00312         return codec;
00313 }

switch_codec_t* switch_core_session_get_video_read_codec ( switch_core_session_t * session )

Definition at line 514 of file switch_core_codec.c.

00515 {
00516         switch_codec_t *codec;
00517         codec = session->video_read_codec;
00518 
00519         return codec;
00520 
00521 }

switch_codec_t* switch_core_session_get_video_write_codec ( switch_core_session_t * session )

Definition at line 559 of file switch_core_codec.c.

00560 {
00561         switch_codec_t *codec;
00562         codec = session->video_write_codec;
00563 
00564         return codec;
00565 
00566 }

switch_codec_t* switch_core_session_get_write_codec ( switch_core_session_t * session )

Definition at line 464 of file switch_core_codec.c.

00465 {
00466         switch_codec_t *codec;
00467         codec = session->real_write_codec ? session->real_write_codec : session->write_codec;
00468 
00469         return codec;
00470 }

void switch_core_session_lock_codec_read ( switch_core_session_t * session )

Definition at line 72 of file switch_core_codec.c.

References switch_mutex_lock().

00073 {
00074         switch_mutex_lock(session->codec_read_mutex);
00075 }

void switch_core_session_lock_codec_write ( switch_core_session_t * session )

Definition at line 62 of file switch_core_codec.c.

References switch_mutex_lock().

00063 {
00064         switch_mutex_lock(session->codec_write_mutex);
00065 }

switch_status_t switch_core_session_set_read_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 193 of file switch_core_codec.c.

References CF_MEDIA_SET, switch_codec::next, 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.

00194 {
00195         switch_event_t *event;
00196         switch_channel_t *channel = switch_core_session_get_channel(session);
00197         char tmp[30];
00198         switch_status_t status = SWITCH_STATUS_SUCCESS;
00199 
00200         switch_mutex_lock(session->codec_read_mutex);
00201 
00202         if (codec && (!codec->implementation || !switch_core_codec_ready(codec))) {
00203                 codec = NULL;
00204         }
00205 
00206         if (codec) {
00207                 if (!session->real_read_codec) {
00208                         session->read_codec = session->real_read_codec = codec;
00209                         if (codec->implementation) {
00210                                 session->read_impl = *codec->implementation;
00211                                 session->real_read_impl = *codec->implementation;
00212                         } else {
00213                                 memset(&session->read_impl, 0, sizeof(session->read_impl));
00214                         }
00215                 } else {
00216                         if (codec == session->read_codec) {
00217                                 goto end;
00218                         }
00219                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Push codec %s:%d\n",
00220                                                           switch_channel_get_name(session->channel), codec->implementation->iananame, codec->implementation->ianacode);
00221                         codec->next = session->read_codec;
00222                         session->read_codec = codec;
00223                         if (codec->implementation) {
00224                                 session->read_impl = *codec->implementation;
00225                         } else {
00226                                 memset(&session->read_impl, 0, sizeof(session->read_impl));
00227                         }
00228                 }
00229         } else {
00230                 if (session->read_codec == session->real_read_codec) {
00231                         goto end;
00232                 }
00233 
00234                 if (session->read_codec->next) {
00235                         switch_codec_t *old = session->read_codec;
00236                         session->read_codec = session->read_codec->next;
00237                         if (session->read_codec->implementation) {
00238                                 session->read_impl = *session->read_codec->implementation;
00239                         } else {
00240                                 memset(&session->read_impl, 0, sizeof(session->read_impl));
00241                         }
00242                         old->next = NULL;
00243 
00244                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Restore previous codec %s:%d.\n",
00245                                                           switch_channel_get_name(session->channel),
00246                                                           session->read_impl.iananame ? session->read_impl.iananame : "N/A", session->read_impl.ianacode);
00247                         
00248 
00249                 } else if (session->real_read_codec) {
00250                         session->read_codec = session->real_read_codec;
00251                         if (session->real_read_codec->implementation) {
00252                                 session->read_impl = *session->real_read_codec->implementation;
00253                         } else {
00254                                 memset(&session->read_impl, 0, sizeof(session->read_impl));
00255                         }
00256                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Restore original codec.\n");
00257                 } else {
00258                         status = SWITCH_STATUS_FALSE;
00259                         goto end;
00260                 }
00261         }
00262 
00263         if (!session->read_codec) {
00264                 status = SWITCH_STATUS_FALSE;
00265                 goto end;
00266         }
00267 
00268         if (session->read_codec && session->read_impl.decoded_bytes_per_packet) {
00269                 if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
00270                         switch_channel_event_set_data(session->channel, event);
00271                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-read-codec-name", session->read_impl.iananame);
00272                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-rate", "%d", session->read_impl.actual_samples_per_second);
00273                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-bit-rate", "%d", session->read_impl.bits_per_second);
00274                         if (session->read_impl.actual_samples_per_second != session->read_impl.samples_per_second) {
00275                                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-reported-read-codec-rate", "%d", session->read_impl.samples_per_second);
00276                         }
00277                         switch_event_fire(&event);
00278                 }
00279 
00280                 switch_channel_set_variable(channel, "read_codec", session->read_impl.iananame);
00281                 switch_snprintf(tmp, sizeof(tmp), "%d", session->read_impl.actual_samples_per_second);
00282                 switch_channel_set_variable(channel, "read_rate", tmp);
00283 
00284                 session->raw_read_frame.codec = session->read_codec;
00285                 session->raw_write_frame.codec = session->read_codec;
00286                 session->enc_read_frame.codec = session->read_codec;
00287                 session->enc_write_frame.codec = session->read_codec;
00288         }
00289 
00290   end:
00291 
00292         if (session->read_codec) {
00293                 switch_channel_set_flag(channel, CF_MEDIA_SET);
00294         }
00295 
00296         switch_mutex_unlock(session->codec_read_mutex);
00297         return status;
00298 
00299 }

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 CF_MEDIA_SET, switch_codec::implementation, switch_codec::next, 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().

00095 {
00096         switch_event_t *event;
00097         switch_channel_t *channel = switch_core_session_get_channel(session);
00098         char tmp[30];
00099         switch_status_t status = SWITCH_STATUS_SUCCESS;
00100         int changed_read_codec = 0;
00101 
00102         switch_mutex_lock(session->codec_read_mutex);
00103 
00104         if (codec && (!codec->implementation || !switch_core_codec_ready(codec))) {
00105                 codec = NULL;
00106         }
00107 
00108         if (codec) {
00109                 /* set real_read_codec and read_codec */
00110                 if (!session->real_read_codec) {
00111                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Original read codec set to %s:%d\n",
00112                                                           switch_channel_get_name(session->channel), codec->implementation->iananame, codec->implementation->ianacode);
00113                         session->read_codec = session->real_read_codec = codec;
00114                         changed_read_codec = 1;
00115                         if (codec->implementation) {
00116                                 session->read_impl = *codec->implementation;
00117                                 session->real_read_impl = *codec->implementation;
00118                         } else {
00119                                 memset(&session->read_impl, 0, sizeof(session->read_impl));
00120                         }
00121                 } else { /* replace real_read_codec */
00122                         switch_codec_t *cur_codec;
00123                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Original read codec replaced with %s:%d\n",
00124                                                           switch_channel_get_name(session->channel), codec->implementation->iananame, codec->implementation->ianacode);
00125                         /* Set real_read_codec to front of the list of read_codecs */
00126                         cur_codec = session->read_codec;
00127                         while (cur_codec != NULL) {
00128                                 if (cur_codec->next == session->real_read_codec) {
00129                                         cur_codec->next = codec;
00130                                         break;
00131                                 }
00132                                 cur_codec = cur_codec->next;
00133                         }
00134                         session->real_read_codec = codec;
00135                         /* set read_codec with real_read_codec if it no longer is ready */
00136                         if (!switch_core_codec_ready(session->read_codec)) {
00137                                 session->read_codec = codec;
00138                                 changed_read_codec = 1;
00139                                 if (codec->implementation) {
00140                                         session->read_impl = *codec->implementation;
00141                                         session->real_read_impl = *codec->implementation;
00142                                 } else {
00143                                         memset(&session->read_impl, 0, sizeof(session->read_impl));
00144                                 }
00145                         }
00146                 }
00147 
00148                 /* force media bugs to copy the read codec from the next frame */
00149                 switch_thread_rwlock_wrlock(session->bug_rwlock);
00150                 if (switch_core_codec_ready(&session->bug_codec)) {
00151                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Destroying BUG Codec %s:%d\n",
00152                                 session->bug_codec.implementation->iananame, session->bug_codec.implementation->ianacode);
00153                         switch_core_codec_destroy(&session->bug_codec);
00154                 }
00155                 switch_thread_rwlock_unlock(session->bug_rwlock);
00156         } else {
00157                 status = SWITCH_STATUS_FALSE;
00158                 goto end;
00159         }
00160 
00161         if (changed_read_codec && session->read_codec && session->read_impl.decoded_bytes_per_packet) {
00162                 if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
00163                         switch_channel_event_set_data(session->channel, event);
00164                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-read-codec-name", session->read_impl.iananame);
00165                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-rate", "%d", session->read_impl.actual_samples_per_second);
00166                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-bit-rate", "%d", session->read_impl.bits_per_second);
00167                         if (session->read_impl.actual_samples_per_second != session->read_impl.samples_per_second) {
00168                                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-reported-read-codec-rate", "%d", session->read_impl.samples_per_second);
00169                         }
00170                         switch_event_fire(&event);
00171                 }
00172 
00173                 switch_channel_set_variable(channel, "read_codec", session->read_impl.iananame);
00174                 switch_snprintf(tmp, sizeof(tmp), "%d", session->read_impl.actual_samples_per_second);
00175                 switch_channel_set_variable(channel, "read_rate", tmp);
00176 
00177                 session->raw_read_frame.codec = session->read_codec;
00178                 session->raw_write_frame.codec = session->read_codec;
00179                 session->enc_read_frame.codec = session->read_codec;
00180                 session->enc_write_frame.codec = session->read_codec;
00181         }
00182 
00183   end:
00184 
00185         if (session->read_codec) {
00186                 switch_channel_set_flag(channel, CF_MEDIA_SET);
00187         }
00188 
00189         switch_mutex_unlock(session->codec_read_mutex);
00190         return status;
00191 }

switch_status_t switch_core_session_set_video_read_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 474 of file switch_core_codec.c.

References 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, and SWITCH_STATUS_SUCCESS.

00475 {
00476         switch_event_t *event;
00477         switch_channel_t *channel = switch_core_session_get_channel(session);
00478         char tmp[30];
00479         switch_status_t status = SWITCH_STATUS_SUCCESS;
00480 
00481         if (!codec || !codec->implementation || !switch_core_codec_ready(codec)) {
00482                 if (session->video_read_codec) {
00483                         session->video_read_codec = NULL;
00484                         status = SWITCH_STATUS_SUCCESS;
00485                         goto end;
00486                 }
00487                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot set NULL codec!\n");
00488                 status = SWITCH_STATUS_FALSE;
00489                 goto end;
00490         }
00491 
00492         if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
00493                 switch_channel_event_set_data(session->channel, event);
00494                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-video-read-codec-name", codec->implementation->iananame);
00495                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-video-read-codec-rate", "%d", codec->implementation->actual_samples_per_second);
00496                 switch_event_fire(&event);
00497         }
00498 
00499         switch_channel_set_variable(channel, "video_read_codec", codec->implementation->iananame);
00500         switch_snprintf(tmp, sizeof(tmp), "%d", codec->implementation->actual_samples_per_second);
00501         switch_channel_set_variable(channel, "video_read_rate", tmp);
00502 
00503         session->video_read_codec = codec;
00504         if (codec->implementation) {
00505                 session->video_read_impl = *codec->implementation;
00506         } else {
00507                 memset(&session->video_read_impl, 0, sizeof(session->video_read_impl));
00508         }
00509   end:
00510 
00511         return status;
00512 }

switch_status_t switch_core_session_set_video_write_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 523 of file switch_core_codec.c.

References 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, and SWITCH_STATUS_SUCCESS.

00524 {
00525         switch_event_t *event;
00526         switch_channel_t *channel = switch_core_session_get_channel(session);
00527         char tmp[30];
00528         switch_status_t status = SWITCH_STATUS_SUCCESS;
00529         if (!codec || !codec->implementation || !switch_core_codec_ready(codec)) {
00530                 if (session->video_write_codec) {
00531                         session->video_write_codec = NULL;
00532                         status = SWITCH_STATUS_SUCCESS;
00533                         goto end;
00534                 }
00535                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot set NULL codec!\n");
00536                 status = SWITCH_STATUS_FALSE;
00537                 goto end;
00538         }
00539 
00540         if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
00541                 switch_channel_event_set_data(session->channel, event);
00542                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-video-write-codec-name", codec->implementation->iananame);
00543                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-video-write-codec-rate", "%d", codec->implementation->actual_samples_per_second);
00544                 switch_event_fire(&event);
00545         }
00546 
00547         switch_channel_set_variable(channel, "video_write_codec", codec->implementation->iananame);
00548         switch_snprintf(tmp, sizeof(tmp), "%d", codec->implementation->actual_samples_per_second);
00549         switch_channel_set_variable(channel, "video_write_rate", tmp);
00550 
00551         session->video_write_codec = codec;
00552         session->video_write_impl = *codec->implementation;
00553 
00554   end:
00555 
00556         return status;
00557 }

switch_status_t switch_core_session_set_write_codec	(	switch_core_session_t *	session,
		switch_codec_t *	codec
	)

Definition at line 391 of file switch_core_codec.c.

References 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, and SWITCH_STATUS_SUCCESS.

00392 {
00393         switch_event_t *event;
00394         switch_channel_t *channel = switch_core_session_get_channel(session);
00395         char tmp[30];
00396         switch_status_t status = SWITCH_STATUS_SUCCESS;
00397 
00398         switch_mutex_lock(session->codec_write_mutex);
00399 
00400         if (!codec || !codec->implementation || !switch_core_codec_ready(codec)) {
00401                 if (session->real_write_codec) {
00402                         session->write_codec = session->real_write_codec;
00403                         session->write_impl = *session->real_write_codec->implementation;
00404                         session->real_write_codec = NULL;
00405                 } else {
00406                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot set NULL codec!\n");
00407                         status = SWITCH_STATUS_FALSE;
00408                         goto end;
00409                 }
00410         } else if (session->write_codec) {
00411                 if (session->real_write_codec) {
00412                         if (codec == session->real_write_codec) {
00413                                 session->write_codec = codec;
00414                                 session->write_impl = *codec->implementation;
00415                                 session->real_write_codec = NULL;
00416                         } else {
00417                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot double-set codec!\n");
00418                                 status = SWITCH_STATUS_FALSE;
00419                                 goto end;
00420                         }
00421                 } else {
00422                         session->real_write_codec = session->write_codec;
00423                         session->write_codec = codec;
00424                         session->write_impl = *codec->implementation;
00425                 }
00426         } else {
00427                 session->write_codec = codec;
00428                 session->write_impl = *codec->implementation;
00429         }
00430 
00431         if (session->write_codec && codec && session->write_impl.codec_id) {
00432                 if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
00433                         switch_channel_event_set_data(session->channel, event);
00434                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Name", session->write_impl.iananame);
00435                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Rate", "%d", session->write_impl.actual_samples_per_second);
00436                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Write-codec-bit-rate", "%d", session->write_impl.bits_per_second);
00437                         if (session->write_impl.actual_samples_per_second != session->write_impl.samples_per_second) {
00438                                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Reported-Write-Codec-Rate", "%d",
00439                                                                                 session->write_impl.actual_samples_per_second);
00440                         }
00441                         switch_event_fire(&event);
00442                 }
00443 
00444                 switch_channel_set_variable(channel, "write_codec", session->write_impl.iananame);
00445                 switch_snprintf(tmp, sizeof(tmp), "%d", session->write_impl.actual_samples_per_second);
00446                 switch_channel_set_variable(channel, "write_rate", tmp);
00447         }
00448 
00449   end:
00450         switch_mutex_unlock(session->codec_write_mutex);
00451 
00452         return status;
00453 }

void switch_core_session_unlock_codec_read ( switch_core_session_t * session )

Definition at line 77 of file switch_core_codec.c.

References switch_mutex_unlock().

00078 {
00079         switch_mutex_unlock(session->codec_read_mutex);
00080 }

void switch_core_session_unlock_codec_write ( switch_core_session_t * session )

Definition at line 67 of file switch_core_codec.c.

References switch_mutex_unlock().

00068 {
00069         switch_mutex_unlock(session->codec_write_mutex);
00070 }

void switch_core_session_unset_read_codec ( switch_core_session_t * session )

Definition at line 46 of file switch_core_codec.c.

References mutex, switch_mutex_lock(), and switch_mutex_unlock().

00047 {
00048         switch_mutex_t *mutex = NULL;
00049 
00050         switch_mutex_lock(session->codec_read_mutex);
00051         if (session->read_codec) mutex = session->read_codec->mutex;
00052         if (mutex) switch_mutex_lock(mutex);
00053         session->real_read_codec = session->read_codec = NULL;
00054         session->raw_read_frame.codec = session->read_codec;
00055         session->raw_write_frame.codec = session->read_codec;
00056         session->enc_read_frame.codec = session->read_codec;
00057         session->enc_write_frame.codec = session->read_codec;
00058         if (mutex) switch_mutex_unlock(mutex);
00059         switch_mutex_unlock(session->codec_read_mutex);
00060 }

void switch_core_session_unset_write_codec ( switch_core_session_t * session )

Definition at line 82 of file switch_core_codec.c.

References mutex, switch_mutex_lock(), and switch_mutex_unlock().

00083 {
00084         switch_mutex_t *mutex = NULL;
00085 
00086         switch_mutex_lock(session->codec_write_mutex);
00087         if (session->write_codec) mutex = session->write_codec->mutex;
00088         if (mutex) switch_mutex_lock(mutex);
00089         session->real_write_codec = session->write_codec = NULL;
00090         if (mutex) switch_mutex_unlock(mutex);
00091         switch_mutex_unlock(session->codec_write_mutex);
00092 }

uint32_t CODEC_ID = 1 [static]

Definition at line 39 of file switch_core_codec.c.

Referenced by switch_core_codec_next_id().


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, switch_memory_pool_t *pool)
switch_status_t	switch_core_codec_init_with_bitrate (switch_codec_t codec, const char codec_name, 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.
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.
switch_status_t	switch_core_codec_destroy (switch_codec_t *codec)
	Destroy an initalized codec handle.
Variables
static uint32_t	CODEC_ID = 1

switch_core_codec.c File Reference

Functions

Variables

Function Documentation

Variable Documentation