freeswitch系列7 IO

freeswitch的大部分媒体逻辑在switch_ivr_*.c中实现，但是这些是功能逻辑，最后会调用switch_core_io.c中的读写帧函数进行io操作。本章不分析功能，只对读写帧这些底层IO的API进行分析。

 

 

 

1. switch_core_session_read_frame

读写帧代码比较长，这里对关键流程进行注解。

对一些参数进行判断

1. if (!switch_core_codec_ready(session->read_codec)) {  

 

从端点读帧

 

1. if (session->endpoint_interface->io_routines->read_frame) {  
2.     switch_mutex_unlock(session->read_codec->mutex);  
3.     switch_mutex_unlock(session->codec_read_mutex);  
4.     if ((status = session->endpoint_interface->io_routines->read_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {  
5.         for (ptr = session->event_hooks.read_frame; ptr; ptr = ptr->next) {  
6.             if ((status = ptr->read_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {  
7.                 break;  
8.             }  
9.         }  
10.     }  

 

调用端点的io接口去读，io层不具体去读，而是调用端点的接口，说明它支持很多种读法，如果是mod_sofia，从网络读RTP，在mod_portaudio则从本地声卡读。另外，除了端点可以读，还可以从事件回调接口读，session->event_hooks.read_frame。

传给监控媒体流

 

1. if (bp->ready) {  
2.     if (switch_test_flag(bp, SMBF_TAP_NATIVE_READ)) {  
3.         if ((*frame)->codec && (*frame)->codec->implementation &&   
4.             (*frame)->codec->implementation->encoded_bytes_per_packet &&   
5.             (*frame)->datalen != (*frame)->codec->implementation->encoded_bytes_per_packet) {  
6.             switch_set_flag((*frame), SFF_CNG);  
7.             break;  
8.         }  
9.         if (bp->callback) {  
10.             bp->native_read_frame = *frame;  
11.             ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_TAP_NATIVE_READ);  
12.             bp->native_read_frame = NULL;  
13.         }  
14.     }  
15. }  

 

freeswitch支持通过bug这种机制进行监控媒体流，这里会把读到的帧传给监控bug。

 

解码帧

1. status = switch_core_codec_decode(codec,  
2.                                   session->read_codec,  
3.                                   read_frame->data,  
4.                                   read_frame->datalen,  
5.                                   session->read_impl.actual_samples_per_second,  
6.                                   session->raw_read_frame.data, &session->raw_read_frame.datalen, &session->raw_read_frame.rate,   
7.                                   &read_frame->flags);  
8.           

 

从网络读到的RTP包是编码的，这里如果code不一样，或者直接播放，要进行解码。

重采样

 

1. case SWITCH_STATUS_RESAMPLE:  
2.     if (!session->read_resampler) {  
3.         switch_mutex_lock(session->resample_mutex);  
4.   
5.         status = switch_resample_create(&session->read_resampler,  
6.                                         read_frame->codec->implementation->actual_samples_per_second,  
7.                                         session->read_impl.actual_samples_per_second,  
8.                                         session->read_impl.decoded_bytes_per_packet, SWITCH_RESAMPLE_QUALITY,   
9.                                         session->read_impl.number_of_channels); 

 

除了支持转码，还支持重采样。

 

再编码

1. status = switch_core_codec_encode(session->read_codec,  
2.                                   enc_frame->codec,  
3.                                   enc_frame->data,  
4.                                   enc_frame->datalen,  
5.                                   session->read_impl.actual_samples_per_second,  
6.                                   session->enc_read_frame.data, &session->enc_read_frame.datalen, &session->enc_read_frame.rate, &flag);  

所谓转码，就是两端协商使用的codec不一样，A的媒体数据，freeswitch先解码成中间格式L16，再编码成B支持的codec。

1. switch_core_session_write_frame

 

快速发

1. if (switch_test_flag(frame, SFF_PROXY_PACKET) || pass_cng) {  
2.     /* Fast PASS! */  
3.     switch_mutex_lock(session->codec_write_mutex);  
4.     status = perform_write(session, frame, flag, stream_id);  
5.     switch_mutex_unlock(session->codec_write_mutex);  
6.     return status;  
7. }  

有些情况，比如这个是代理包标志还是啥，就要调用perform_write直接发。

 

转码

1. if (frame->codec) {  
2.     session->raw_write_frame.datalen = session->raw_write_frame.buflen;  
3.     frame->codec->cur_frame = frame;  
4.     session->write_codec->cur_frame = frame;  
5.     status = switch_core_codec_decode(frame->codec,  
6.                                       session->write_codec,  
7.                                       frame->data,  
8.                                       frame->datalen,  
9.                                       session->write_impl.actual_samples_per_second,  
10.                                       session->raw_write_frame.data, &session->raw_write_frame.datalen, &session->raw_write_frame.rate, &frame->flags); 

 

重采样

1. switch (status) {  
2. case SWITCH_STATUS_RESAMPLE:  
3.     resample++;  
4.     write_frame = &session->raw_write_frame;  
5.     write_frame->rate = frame->codec->implementation->actual_samples_per_second;  
6.     if (!session->write_resampler) {  
7.         switch_mutex_lock(session->resample_mutex);  
8.         status = switch_resample_create(&session->write_resampler,  
9.                                         frame->codec->implementation->actual_samples_per_second,  
10.                                         session->write_impl.actual_samples_per_second,  
11.                                         session->write_impl.decoded_bytes_per_packet, SWITCH_RESAMPLE_QUALITY, session->write_impl.number_of_channels);  
12.  
13. switch_resample_process(session->write_resampler, data, write_frame->datalen / 2 / session->write_resampler->channels);

 

再编码

1. status = switch_core_codec_encode(session->write_codec,  
2.                                   frame->codec,  
3.                                   enc_frame->data,  
4.                                   enc_frame->datalen,  
5.                                   session->write_impl.actual_samples_per_second,  
6.                                   session->enc_write_frame.data, &session->enc_write_frame.datalen, &session->enc_write_frame.rate, &flag);  

 

都处理完后，最后调用perform_write把数据发出去。

 

1.  done:  
2.   
3. if (ptime_mismatch || resample) {  
4.     write_frame->timestamp = 0;  
5. }  
6.   
7. if (do_write) {  
8.     status = perform_write(session, write_frame, flags, stream_id);  
9. }  

 

perform_write实际调用端点的IO函数。

 

1.     if (session->endpoint_interface->io_routines->write_frame) {  
2.         if ((status = session->endpoint_interface->io_routines->write_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {  
3.             for (ptr = session->event_hooks.write_frame; ptr; ptr = ptr->next) {  
4.                 if ((status = ptr->write_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {  
5.                     break;  
6.                 }  
7.             }  
8.         }  
9.     }