Changeset 6005


Ignore:
Timestamp:
May 26, 2019 1:18:02 PM (4 months ago)
Author:
riza
Message:

Close #2202: Limit the number of ignored error when receiving RTP/RTCP.

Location:
pjproject/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjmedia/include/pjmedia/config.h

    r5915 r6005  
    12231223 
    12241224 
     1225/** 
     1226 * Specify the number of identical consecutive error that will be ignored when  
     1227 * receiving RTP/RTCP data before the library tries to restart the transport. 
     1228 * 
     1229 * When receiving RTP/RTCP data, the library will ignore error besides  
     1230 * PJ_EPENDING or PJ_ECANCELLED and continue the loop to receive the data.  
     1231 * If the OS always return error, then the loop will continue non stop. 
     1232 * This setting will limit the number of the identical consecutive error,  
     1233 * before the library start to restart the transport. If error still happens 
     1234 * after transport restart, then PJMEDIA_EVENT_MEDIA_TP_ERR event will be  
     1235 * publish as a notification. 
     1236 * 
     1237 * If PJ_ESOCKETSTOP is raised, then transport will be restarted regardless 
     1238 * of this setting. 
     1239 *  
     1240 * To always ignore the error when receving RTP/RTCP, set this to 0. 
     1241 * 
     1242 * Default : 20 
     1243 */ 
     1244#ifndef PJMEDIA_IGNORE_RECV_ERR_CNT 
     1245#   define PJMEDIA_IGNORE_RECV_ERR_CNT          20 
     1246#endif 
     1247 
     1248 
    12251249/* 
    12261250 * .... new stuffs ... 
  • pjproject/trunk/pjmedia/include/pjmedia/event.h

    r5923 r6005  
    9494     * Audio device stopped on error. 
    9595     */ 
    96     PJMEDIA_EVENT_AUD_DEV_ERROR = PJMEDIA_FOURCC('A', 'E', 'R', 'R') 
     96    PJMEDIA_EVENT_AUD_DEV_ERROR = PJMEDIA_FOURCC('A', 'E', 'R', 'R'), 
     97 
     98    /** 
     99     * Transport media error. 
     100     */ 
     101    PJMEDIA_EVENT_MEDIA_TP_ERR = PJMEDIA_FOURCC('T', 'E', 'R', 'R') 
    97102 
    98103} pjmedia_event_type; 
     
    155160    pj_status_t              status; 
    156161} pjmedia_event_aud_dev_err_data; 
     162 
     163/** 
     164 * Additional data/parameters for media transmit error event. 
     165 */ 
     166typedef struct pjmedia_event_media_tp_err_data 
     167{ 
     168    /** The media type          */ 
     169    pjmedia_type            type; 
     170 
     171    /** RTP/RTCP?               */ 
     172    pj_bool_t               is_rtp; 
     173 
     174    /** Media direction         */ 
     175    pjmedia_dir             dir; 
     176 
     177    /** The error code          */ 
     178    pj_status_t             status; 
     179 
     180} pjmedia_event_media_tp_err_data; 
     181 
    157182 
    158183/** Additional parameters for window changed event. */ 
     
    243268        /** Storage for user event data */ 
    244269        pjmedia_event_user_data                 user; 
     270 
     271        /** Media transport error event data */ 
     272        pjmedia_event_media_tp_err_data         med_tp_err; 
    245273 
    246274        /** Pointer to storage to user event data, if it's outside 
  • pjproject/trunk/pjmedia/src/pjmedia/stream.c

    r5982 r6005  
    7575/* Number of DTMF E bit transmissions */ 
    7676#define DTMF_EBIT_RETRANSMIT_CNT        3 
     77 
     78/*  Number of send error before repeat the report. */ 
     79#define SEND_ERR_COUNT_TO_REPORT        50 
    7780 
    7881/** 
     
    234237    pj_sockaddr              rem_rtp_addr;     /**< Remote RTP address      */ 
    235238    unsigned                 rem_rtp_flag;     /**< Indicator flag about 
    236                                                     packet from this addr.  
    237                                                     0=no pkt, 1=good ssrc,  
     239                                                    packet from this addr. 
     240                                                    0=no pkt, 1=good ssrc, 
    238241                                                    2=bad ssrc pkts         */ 
    239242    unsigned                 rtp_src_cnt;      /**< How many pkt from 
     
    245248#endif 
    246249 
    247     pj_uint32_t              rtp_rx_last_ts;        /**< Last received RTP timestamp*/ 
    248     pj_status_t              rtp_rx_last_err;       /**< Last RTP recv() error */ 
    249     pj_status_t              rtp_tx_last_err;       /**< Last RTP send() error */ 
    250     pj_status_t              rtcp_tx_last_err;      /**< Last RTCP send() error */ 
     250    pj_uint32_t              rtp_rx_last_ts;        /**< Last received RTP 
     251                                                         timestamp          */ 
     252    pj_uint32_t              rtp_tx_err_cnt;        /**< The number of RTP 
     253                                                         send() error       */ 
     254    pj_uint32_t              rtcp_tx_err_cnt;       /**< The number of RTCP 
     255                                                         send() error       */ 
    251256 
    252257    /* RTCP Feedback */ 
     
    263268                                   '4', '5', '6', '7', 
    264269                                   '8', '9', '*', '#', 
    265                                    'A', 'B', 'C', 'D',  
     270                                   'A', 'B', 'C', 'D', 
    266271                                   'R'}; 
    267272 
     
    462467    /* Send RTCP */ 
    463468    send_rtcp(stream, PJ_TRUE, PJ_FALSE, PJ_FALSE, PJ_FALSE); 
    464      
     469 
    465470    /* Update stats in case the stream is paused */ 
    466471    stream->rtcp.stat.rtp_tx_last_seq = pj_ntohs(stream->enc->rtp.out_hdr.seq); 
     
    538543                                      stream->dec_buf_pos; 
    539544            unsigned nsamples_copy = PJ_MIN(nsamples_req, nsamples_avail); 
    540              
     545 
    541546            pjmedia_copy_samples(p_out_samp + samples_count, 
    542547                                 stream->dec_buf + stream->dec_buf_pos, 
     
    10131018 
    10141019 
     1020/** 
     1021 * Publish transport error event. 
     1022 */ 
     1023static void publish_tp_event(pjmedia_event_type event_type, 
     1024                             pj_status_t status, 
     1025                             pj_bool_t is_rtp, 
     1026                             pjmedia_dir dir, 
     1027                             pjmedia_stream *stream) 
     1028{ 
     1029    pjmedia_event ev; 
     1030    pj_timestamp ts_now; 
     1031 
     1032    pj_get_timestamp(&ts_now); 
     1033    pj_bzero(&ev.data.med_tp_err, sizeof(ev.data.med_tp_err)); 
     1034 
     1035    /* Publish event. */ 
     1036    pjmedia_event_init(&ev, event_type, 
     1037                       &ts_now, stream); 
     1038    ev.data.med_tp_err.type = PJMEDIA_TYPE_AUDIO; 
     1039    ev.data.med_tp_err.is_rtp = is_rtp; 
     1040    ev.data.med_tp_err.dir = dir; 
     1041    ev.data.med_tp_err.status = status; 
     1042 
     1043    pjmedia_event_publish(NULL, stream, &ev, 0); 
     1044} 
     1045 
     1046 
    10151047static pj_status_t send_rtcp(pjmedia_stream *stream, 
    10161048                             pj_bool_t with_sdes, 
     
    11341166    status = pjmedia_transport_send_rtcp(stream->transport, pkt, len); 
    11351167    if (status != PJ_SUCCESS) { 
    1136         if (stream->rtcp_tx_last_err != status) { 
    1137             PJ_PERROR(4,(stream->port.info.name.ptr, status, 
    1138                          "Error sending RTCP")); 
    1139             stream->rtcp_tx_last_err = status; 
    1140         } 
    1141     } else { 
    1142         if (stream->rtcp_tx_last_err != PJ_SUCCESS) { 
    1143             PJ_LOG(4,(stream->port.info.name.ptr, "Sending RTCP resumed")); 
    1144             stream->rtcp_tx_last_err = PJ_SUCCESS; 
     1168        if (stream->rtcp_tx_err_cnt++ == 0) { 
     1169            LOGERR_((stream->port.info.name.ptr, status, 
     1170                     "Error sending RTCP")); 
     1171        } 
     1172        if (stream->rtcp_tx_err_cnt > SEND_ERR_COUNT_TO_REPORT) { 
     1173            stream->rtcp_tx_err_cnt = 0; 
    11451174        } 
    11461175    } 
     
    14841513                                        frame_out.size + 
    14851514                                            sizeof(pjmedia_rtp_hdr)); 
     1515 
    14861516    if (status != PJ_SUCCESS) { 
    1487         if (stream->rtp_tx_last_err != status) { 
    1488             PJ_PERROR(4,(stream->port.info.name.ptr, status, 
    1489                          "Error sending RTP")); 
    1490             stream->rtp_tx_last_err = status; 
     1517        if (stream->rtp_tx_err_cnt++ == 0) { 
     1518            LOGERR_((stream->port.info.name.ptr, status, "Error sending RTP")); 
     1519        } 
     1520        if (stream->rtp_tx_err_cnt > SEND_ERR_COUNT_TO_REPORT) { 
     1521            stream->rtp_tx_err_cnt = 0; 
    14911522        } 
    14921523        return PJ_SUCCESS; 
    1493     } else { 
    1494         if (stream->rtp_tx_last_err != PJ_SUCCESS) { 
    1495             PJ_LOG(4,(stream->port.info.name.ptr, "Sending RTP resumed")); 
    1496             stream->rtp_tx_last_err = PJ_SUCCESS; 
    1497         } 
    14981524    } 
    14991525 
     
    16801706#else 
    16811707    if (event->event > 15) { 
    1682 #endif     
     1708#endif 
    16831709        PJ_LOG(5,(stream->port.info.name.ptr, 
    16841710                  "Ignored RTP pkt with bad DTMF event %d", 
     
    17441770            return; 
    17451771        } 
    1746         if (stream->rtp_rx_last_err != status) { 
    1747             char errmsg[PJ_ERR_MSG_SIZE]; 
    1748             pj_strerror(status, errmsg, sizeof(errmsg)); 
    1749             PJ_LOG(4,(stream->port.info.name.ptr, 
    1750                       "Unable to receive RTP packet, recv() returned %d: %s", 
    1751                       status, errmsg)); 
    1752             stream->rtp_rx_last_err = status; 
     1772 
     1773        LOGERR_((stream->port.info.name.ptr, status, 
     1774                 "Unable to receive RTP packet")); 
     1775 
     1776        if (status == PJ_ESOCKETSTOP) { 
     1777            /* Publish receive error event. */ 
     1778            publish_tp_event(PJMEDIA_EVENT_MEDIA_TP_ERR, status, PJ_TRUE, 
     1779                             PJMEDIA_DIR_DECODING, stream); 
    17531780        } 
    17541781        return; 
    1755     } else { 
    1756         stream->rtp_rx_last_err = PJ_SUCCESS; 
    17571782    } 
    17581783 
     
    17691794        return; 
    17701795    } 
    1771      
     1796 
    17721797    /* Check if multiplexing is allowed and the payload indicates RTCP. */ 
    17731798    if (stream->si.rtcp_mux && hdr->pt >= 64 && hdr->pt <= 95) { 
     
    18381863    } 
    18391864 
    1840     /* See if source address of RTP packet is different than the  
     1865    /* See if source address of RTP packet is different than the 
    18411866     * configured address, and check if we need to tell the 
    18421867     * media transport to switch RTP remote address. 
     
    18521877        } else { 
    18531878            stream->rtp_src_cnt++; 
    1854              
     1879 
    18551880            if (stream->rtp_src_cnt < PJMEDIA_RTP_NAT_PROBATION_CNT) { 
    18561881                if (stream->rem_rtp_flag == 1 || 
     
    18651890                    pkt_discarded = PJ_TRUE; 
    18661891                    goto on_return; 
    1867                 }                
     1892                } 
    18681893                if (stream->si.has_rem_ssrc && !seq_st.status.flag.badssrc && 
    18691894                    stream->rem_rtp_flag != 1) 
     
    19271952        { 
    19281953            unsigned dec_ptime; 
    1929              
     1954 
    19301955            PJ_LOG(4, (stream->port.info.name.ptr, "codec decode " 
    19311956                       "ptime change detected")); 
     
    21062131{ 
    21072132    pjmedia_stream *stream = (pjmedia_stream*) data; 
     2133    pj_status_t status; 
    21082134 
    21092135    /* Check for errors */ 
    21102136    if (bytes_read < 0) { 
    2111         if (bytes_read != -PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK)) { 
    2112             LOGERR_((stream->port.info.name.ptr, (pj_status_t)-bytes_read, 
    2113                      "RTCP recv() error")); 
     2137        status = (pj_status_t)-bytes_read; 
     2138        if (status == PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK)) { 
     2139            return; 
     2140        } 
     2141        LOGERR_((stream->port.info.name.ptr, status, 
     2142                         "Unable to receive RTCP packet")); 
     2143 
     2144        if (status == PJ_ESOCKETSTOP) { 
     2145            /* Publish receive error event. */ 
     2146            publish_tp_event(PJMEDIA_EVENT_MEDIA_TP_ERR, status, PJ_FALSE, 
     2147                             PJMEDIA_DIR_DECODING, stream); 
    21142148        } 
    21152149        return; 
     
    22202254        if (stream->rtcp_fb_nack_cap_idx < 0) 
    22212255            return PJ_SUCCESS; 
    2222          
     2256 
    22232257        data->cap = stream->si.loc_rtcp_fb.caps[stream->rtcp_fb_nack_cap_idx]; 
    22242258    } 
     
    26362670    pj_sockaddr_cp(&stream->rem_rtp_addr, &info->rem_addr); 
    26372671    if (stream->si.rtcp_mux) { 
    2638         pj_sockaddr_cp(&att_param.rem_rtcp, &info->rem_addr);            
     2672        pj_sockaddr_cp(&att_param.rem_rtcp, &info->rem_addr); 
    26392673    } else if (pj_sockaddr_has_addr(&info->rem_rtcp.addr)) { 
    26402674        pj_sockaddr_cp(&att_param.rem_rtcp, &info->rem_rtcp); 
     
    31283162                pt = 11; 
    31293163            } 
    3130 #if defined(PJMEDIA_HAS_DTMF_FLASH) && PJMEDIA_HAS_DTMF_FLASH!= 0            
     3164#if defined(PJMEDIA_HAS_DTMF_FLASH) && PJMEDIA_HAS_DTMF_FLASH!= 0 
    31313165            else if (dig == 'r') 
    31323166            { 
  • pjproject/trunk/pjmedia/src/pjmedia/transport_udp.c

    r5907 r6005  
    1919 */ 
    2020#include <pjmedia/transport_udp.h> 
     21#include <pj/compat/socket.h> 
    2122#include <pj/addr_resolv.h> 
    2223#include <pj/assert.h> 
     
    2728#include <pj/rand.h> 
    2829#include <pj/string.h> 
    29  
    3030 
    3131/* Maximum size of incoming RTP packet */ 
     
    155155                                       unsigned pct_lost); 
    156156static pj_status_t transport_destroy  (pjmedia_transport *tp); 
    157  
    158 #if defined(PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT) && \ 
    159             PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT!=0 
    160157static pj_status_t transport_restart  (pj_bool_t is_rtp,  
    161158                                       struct transport_udp *udp); 
    162 #endif 
    163159 
    164160static pjmedia_transport_op transport_udp_op =  
     
    454450} 
    455451 
     452/* Call RTP cb. */ 
     453static void call_rtp_cb(struct transport_udp *udp, pj_ssize_t bytes_read,  
     454                        pj_bool_t *rem_switch) 
     455{ 
     456    void (*cb)(void*,void*,pj_ssize_t); 
     457    void (*cb2)(pjmedia_tp_cb_param*); 
     458    void *user_data; 
     459 
     460    cb = udp->rtp_cb; 
     461    cb2 = udp->rtp_cb2; 
     462    user_data = udp->user_data; 
     463 
     464    if (cb2) { 
     465        pjmedia_tp_cb_param param; 
     466 
     467        param.user_data = user_data; 
     468        param.pkt = udp->rtp_pkt; 
     469        param.size = bytes_read; 
     470        param.src_addr = &udp->rtp_src_addr; 
     471        param.rem_switch = PJ_FALSE; 
     472        (*cb2)(&param); 
     473        if (rem_switch) 
     474            *rem_switch = param.rem_switch; 
     475    } else if (cb) { 
     476        (*cb)(user_data, udp->rtp_pkt, bytes_read); 
     477    } 
     478} 
     479 
     480/* Call RTCP cb. */ 
     481static void call_rtcp_cb(struct transport_udp *udp, pj_ssize_t bytes_read) 
     482{ 
     483    void(*cb)(void*, void*, pj_ssize_t); 
     484    void *user_data; 
     485 
     486    cb = udp->rtcp_cb; 
     487    user_data = udp->user_data; 
     488 
     489    if (cb) 
     490        (*cb)(user_data, udp->rtcp_pkt, bytes_read); 
     491} 
    456492 
    457493/* Notification from ioqueue about incoming RTP packet */ 
     
    463499    pj_status_t status; 
    464500    pj_bool_t rem_switch = PJ_FALSE; 
     501    pj_bool_t transport_restarted = PJ_FALSE; 
     502    unsigned num_err = 0; 
     503    pj_status_t last_err = PJ_SUCCESS; 
    465504 
    466505    PJ_UNUSED_ARG(op_key); 
     
    470509    udp = (struct transport_udp*) pj_ioqueue_get_user_data(key); 
    471510 
    472 #if defined(PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT) && \ 
    473             PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT!=0 
    474511    if (-bytes_read == PJ_ESOCKETSTOP) { 
    475512        /* Try to recover by restarting the transport. */ 
    476         PJ_LOG(4, (udp->base.name, "Restarting RTP transport")); 
    477513        status = transport_restart(PJ_TRUE, udp); 
    478         if (status == PJ_SUCCESS) { 
    479             PJ_LOG(4, (udp->base.name, "Success restarting RTP transport")); 
    480         } else { 
    481             PJ_PERROR(1, (udp->base.name, status,  
    482                           "Error restarting RTP transport")); 
     514        if (status != PJ_SUCCESS) { 
     515            bytes_read = -PJ_ESOCKETSTOP; 
     516            call_rtp_cb(udp, bytes_read, NULL); 
    483517        } 
    484518        return; 
    485519    } 
    486 #endif 
    487520 
    488521    do { 
    489         void (*cb)(void*,void*,pj_ssize_t); 
    490         void (*cb2)(pjmedia_tp_cb_param*); 
    491         void *user_data; 
    492522        pj_bool_t discard = PJ_FALSE; 
    493  
    494         cb = udp->rtp_cb; 
    495         cb2 = udp->rtp_cb2; 
    496         user_data = udp->user_data; 
    497523 
    498524        /* Simulate packet lost on RX direction */ 
     
    507533 
    508534        //if (!discard && udp->attached && cb) 
    509         if (!discard) { 
    510             if (cb2) { 
    511                 pjmedia_tp_cb_param param; 
    512  
    513                 param.user_data = user_data; 
    514                 param.pkt = udp->rtp_pkt; 
    515                 param.size = bytes_read; 
    516                 param.src_addr = &udp->rtp_src_addr; 
    517                 param.rem_switch = PJ_FALSE; 
    518                 (*cb2)(&param); 
    519                 rem_switch = param.rem_switch; 
    520             } else if (cb) { 
    521                 (*cb)(user_data, udp->rtp_pkt, bytes_read); 
    522             } 
     535        if (!discard &&  
     536            (-bytes_read != PJ_STATUS_FROM_OS(PJ_BLOCKING_ERROR_VAL)))  
     537        { 
     538            call_rtp_cb(udp, bytes_read, &rem_switch); 
    523539        } 
    524540 
     
    566582        udp->rtp_addrlen = sizeof(udp->rtp_src_addr); 
    567583        status = pj_ioqueue_recvfrom(udp->rtp_key, &udp->rtp_read_op, 
    568                                      udp->rtp_pkt, &bytes_read, 0, 
    569                                      &udp->rtp_src_addr,  
    570                                      &udp->rtp_addrlen); 
    571  
    572         if (status != PJ_EPENDING && status != PJ_SUCCESS) 
     584                                        udp->rtp_pkt, &bytes_read, 0, 
     585                                        &udp->rtp_src_addr, 
     586                                        &udp->rtp_addrlen); 
     587 
     588        if (status != PJ_EPENDING && status != PJ_SUCCESS) {         
     589            if (transport_restarted && last_err == status) { 
     590                /* Still the same error after restart */ 
     591                bytes_read = -PJ_ESOCKETSTOP; 
     592                call_rtp_cb(udp, bytes_read, NULL); 
     593                break; 
     594            } else if (PJMEDIA_IGNORE_RECV_ERR_CNT) { 
     595                if (last_err == status) { 
     596                    ++num_err; 
     597                } else { 
     598                    num_err = 1; 
     599                    last_err = status; 
     600                } 
     601 
     602                if (status == PJ_ESOCKETSTOP || 
     603                    num_err > PJMEDIA_IGNORE_RECV_ERR_CNT) 
     604                { 
     605                    status = transport_restart(PJ_TRUE, udp);                
     606                    if (status != PJ_SUCCESS) { 
     607                        bytes_read = -PJ_ESOCKETSTOP; 
     608                        call_rtp_cb(udp, bytes_read, NULL); 
     609                        break; 
     610                    } 
     611                    transport_restarted = PJ_TRUE; 
     612                    num_err = 0; 
     613                } 
     614            } 
    573615            bytes_read = -status; 
    574  
     616        } 
    575617    } while (status != PJ_EPENDING && status != PJ_ECANCELLED && 
    576618             udp->started); 
     
    585627    struct transport_udp *udp; 
    586628    pj_status_t status = PJ_SUCCESS; 
     629    pj_bool_t transport_restarted = PJ_FALSE; 
     630    unsigned num_err = 0; 
     631    pj_status_t last_err = PJ_SUCCESS; 
    587632 
    588633    PJ_UNUSED_ARG(op_key); 
     
    592637    udp = (struct transport_udp*) pj_ioqueue_get_user_data(key); 
    593638 
    594 #if defined(PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT) && \ 
    595             PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT!=0 
    596639    if (-bytes_read == PJ_ESOCKETSTOP) { 
    597640        /* Try to recover by restarting the transport. */ 
    598         PJ_LOG(4, (udp->base.name, "Restarting RTCP transport")); 
    599641        status = transport_restart(PJ_FALSE, udp); 
    600         if (status == PJ_SUCCESS) { 
    601             PJ_LOG(4, (udp->base.name, "Success restarting RTCP transport")); 
    602         } else { 
    603             PJ_PERROR(1, (udp->base.name, status,  
    604                           "Error restarting RTCP transport")); 
     642        if (status != PJ_SUCCESS) { 
     643            bytes_read = -PJ_ESOCKETSTOP; 
     644            call_rtcp_cb(udp, bytes_read); 
    605645        } 
    606646        return; 
    607647    } 
    608 #endif 
    609648 
    610649    do { 
    611         void (*cb)(void*,void*,pj_ssize_t); 
    612         void *user_data; 
    613  
    614         cb = udp->rtcp_cb; 
    615         user_data = udp->user_data; 
    616  
    617         //if (udp->attached && cb) 
    618         if (cb) 
    619             (*cb)(user_data, udp->rtcp_pkt, bytes_read); 
     650        call_rtcp_cb(udp, bytes_read); 
    620651 
    621652#if defined(PJMEDIA_TRANSPORT_SWITCH_REMOTE_ADDR) && \ 
     
    656687                                     &udp->rtcp_src_addr,  
    657688                                     &udp->rtcp_addr_len); 
    658         if (status != PJ_EPENDING && status != PJ_SUCCESS) 
     689 
     690        if (status != PJ_EPENDING && status != PJ_SUCCESS) { 
     691            if (transport_restarted && last_err == status) { 
     692                /* Still the same error after restart */ 
     693                bytes_read = -PJ_ESOCKETSTOP; 
     694                call_rtcp_cb(udp, bytes_read); 
     695                break; 
     696            } else if (PJMEDIA_IGNORE_RECV_ERR_CNT) { 
     697                if (last_err == status) { 
     698                    ++num_err; 
     699                } else { 
     700                    num_err = 1; 
     701                    last_err = status; 
     702                } 
     703 
     704                if (status == PJ_ESOCKETSTOP || 
     705                    num_err > PJMEDIA_IGNORE_RECV_ERR_CNT) 
     706                { 
     707                    status = transport_restart(PJ_FALSE, udp);               
     708                    if (status != PJ_SUCCESS) { 
     709                        bytes_read = -PJ_ESOCKETSTOP; 
     710                        call_rtcp_cb(udp, bytes_read); 
     711                        break; 
     712                    } 
     713                    transport_restarted = PJ_TRUE; 
     714                    num_err = 0; 
     715                } 
     716            } 
    659717            bytes_read = -status; 
    660  
     718        }        
    661719    } while (status != PJ_EPENDING && status != PJ_ECANCELLED && 
    662720             udp->started); 
     
    928986    PJ_ASSERT_RETURN(size <= PJMEDIA_MAX_MTU, PJ_ETOOBIG); 
    929987 
     988    if (!udp->started) { 
     989        return PJ_SUCCESS; 
     990    } 
     991 
    930992    /* Simulate packet lost on TX direction */ 
    931993    if (udp->tx_drop_pct) { 
     
    9851047 
    9861048    //PJ_ASSERT_RETURN(udp->attached, PJ_EINVALIDOP); 
     1049 
     1050    if (!udp->started) { 
     1051        return PJ_SUCCESS; 
     1052    } 
    9871053 
    9881054    if (addr == NULL) { 
     
    11811247} 
    11821248 
    1183 #if defined(PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT) && \ 
    1184             PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT!=0 
    1185 static pj_status_t transport_restart(pj_bool_t is_rtp, 
     1249static pj_status_t transport_restart(pj_bool_t is_rtp,  
    11861250                                     struct transport_udp *udp) 
    11871251{ 
     
    11941258    pj_ssize_t size; 
    11951259 
     1260    PJ_LOG(4, (udp->base.name, "Restarting %s transport",  
     1261              (is_rtp)?"RTP":"RTCP")); 
     1262 
     1263    udp->started = PJ_FALSE; 
    11961264    /* Destroy existing socket, if any. */     
    11971265    if (key) { 
     
    12081276        pj_sock_close(*sock); 
    12091277    } 
    1210     *sock = PJ_INVALID_SOCKET; 
     1278    *sock = PJ_INVALID_SOCKET;    
    12111279 
    12121280    /* Create socket */ 
     
    12241292    /* Set buffer size for RTP socket */ 
    12251293#if PJMEDIA_TRANSPORT_SO_RCVBUF_SIZE 
    1226     { 
     1294    if (is_rtp) { 
    12271295        unsigned sobuf_size = PJMEDIA_TRANSPORT_SO_RCVBUF_SIZE; 
    12281296 
    1229         status = pj_sock_setsockopt_sobuf(udp->rtp_sock, pj_SO_RCVBUF(), 
    1230                                           PJ_TRUE, &sobuf_size); 
    1231         if (status != PJ_SUCCESS) { 
    1232             pj_perror(3, udp->base.name, status, "Failed setting SO_RCVBUF"); 
    1233         } else { 
    1234             if (sobuf_size < PJMEDIA_TRANSPORT_SO_RCVBUF_SIZE) { 
    1235                 PJ_LOG(4, (udp->base.name, 
    1236                            "Warning! Cannot set SO_RCVBUF as configured, " 
    1237                            "now=%d, configured=%d", 
    1238                            sobuf_size, PJMEDIA_TRANSPORT_SO_RCVBUF_SIZE)); 
    1239             } else { 
    1240                 PJ_LOG(5, (udp->base.name, "SO_RCVBUF set to %d", sobuf_size)); 
    1241             } 
    1242         } 
     1297        pj_sock_setsockopt_sobuf(udp->rtp_sock, pj_SO_RCVBUF(),  
     1298                                 PJ_TRUE, &sobuf_size); 
    12431299    } 
    12441300#endif 
    12451301#if PJMEDIA_TRANSPORT_SO_SNDBUF_SIZE 
    1246     { 
     1302    if (is_rtp) { 
    12471303        unsigned sobuf_size = PJMEDIA_TRANSPORT_SO_SNDBUF_SIZE; 
    12481304 
    1249         status = pj_sock_setsockopt_sobuf(udp->rtp_sock, pj_SO_SNDBUF(), 
    1250                                           PJ_TRUE, &sobuf_size); 
    1251         if (status != PJ_SUCCESS) { 
    1252             pj_perror(3, udp->base.name, status, "Failed setting SO_SNDBUF"); 
    1253         } else { 
    1254             if (sobuf_size < PJMEDIA_TRANSPORT_SO_SNDBUF_SIZE) { 
    1255                 PJ_LOG(4, (udp->base.name, 
    1256                            "Warning! Cannot set SO_SNDBUF as configured, " 
    1257                            "now=%d, configured=%d", 
    1258                            sobuf_size, PJMEDIA_TRANSPORT_SO_SNDBUF_SIZE)); 
    1259             } else { 
    1260                 PJ_LOG(5, (udp->base.name, "SO_SNDBUF set to %d", sobuf_size)); 
    1261             } 
    1262         } 
     1305        pj_sock_setsockopt_sobuf(udp->rtp_sock, pj_SO_SNDBUF(),  
     1306                                 PJ_TRUE, &sobuf_size); 
    12631307    } 
    12641308#endif 
     
    12961340        goto on_error; 
    12971341 
    1298  
     1342    udp->started = PJ_TRUE; 
     1343    PJ_LOG(4, (udp->base.name, "Success restarting %s transport",  
     1344              (is_rtp)?"RTP":"RTCP")); 
    12991345    return PJ_SUCCESS; 
    13001346on_error: 
     
    13031349        *sock = PJ_INVALID_SOCKET; 
    13041350    } 
     1351    PJ_PERROR(1, (udp->base.name, status,  
     1352                 "Error restarting %s transport", (is_rtp)?"RTP":"RTCP")); 
    13051353    return status; 
    13061354} 
    1307 #endif 
  • pjproject/trunk/pjmedia/src/pjmedia/vid_stream.c

    r5982 r6005  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2011 Teluu Inc. (http://www.teluu.com) 
    44 * 
     
    1515 * You should have received a copy of the GNU General Public License 
    1616 * along with this program; if not, write to the Free Software 
    17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1818 */ 
    1919#include <pjmedia/vid_stream.h> 
     
    7575#define MIN_CHUNKS_PER_FRM      30 
    7676 
     77/*  Number of send error before repeat the report. */ 
     78#define SEND_ERR_COUNT_TO_REPORT        50 
    7779 
    7880/** 
     
    115117 
    116118    pjmedia_transport       *transport;     /**< Stream transport.          */ 
    117     unsigned                 send_err_cnt;  /**< Send error count.          */ 
    118119 
    119120    pj_mutex_t              *jb_mutex; 
     
    137138    pjmedia_event            fmt_event;     /**< Buffered fmt_changed event 
    138139                                                 to avoid deadlock          */ 
    139     pjmedia_event            miss_keyframe_event;  
     140    pjmedia_event            miss_keyframe_event; 
    140141                                            /**< Buffered missing keyframe 
    141142                                                 event for delayed republish*/ 
     
    148149                                                 frame assembly.            */ 
    149150    pj_bool_t                force_keyframe;/**< Forced to encode keyframe? */ 
    150     unsigned                 num_keyframe;  /**< The number of keyframe needed  
     151    unsigned                 num_keyframe;  /**< The number of keyframe needed 
    151152                                                 to be sent, after the stream 
    152153                                                 is created. */ 
    153     pj_timestamp             last_keyframe_tx;   
    154                                             /**< Timestamp of the last  
     154    pj_timestamp             last_keyframe_tx; 
     155                                            /**< Timestamp of the last 
    155156                                                 keyframe. */ 
    156157 
     
    172173    pj_uint32_t              last_dec_ts;   /**< Last decoded timestamp.    */ 
    173174    int                      last_dec_seq;  /**< Last decoded sequence.     */ 
    174     pj_status_t              rtp_rx_last_err; /**< Last RTP recv() error.   */ 
     175    pj_uint32_t              rtp_tx_err_cnt;/**< The number of RTP 
     176                                                 send() error               */ 
     177    pj_uint32_t              rtcp_tx_err_cnt;/**< The number of RTCP 
     178                                                  send() error              */ 
    175179 
    176180    pj_timestamp             ts_freq;       /**< Timestamp frequency.       */ 
     
    178182    pj_sockaddr              rem_rtp_addr;  /**< Remote RTP address         */ 
    179183    unsigned                 rem_rtp_flag;  /**< Indicator flag about 
    180                                                  packet from this addr.  
    181                                                  0=no pkt, 1=good ssrc pkts,  
     184                                                 packet from this addr. 
     185                                                 0=no pkt, 1=good ssrc pkts, 
    182186                                                 2=bad ssrc pkts            */ 
    183187    pj_sockaddr              rtp_src_addr;  /**< Actual packet src addr.    */ 
     
    203207 
    204208static void on_rx_rtcp( void *data, 
    205                         void *pkt,  
     209                        void *pkt, 
    206210                        pj_ssize_t bytes_read); 
    207211 
     
    233237} 
    234238 
    235 PJ_INLINE(int) trace_jb_print_state(pjmedia_vid_stream *stream,  
     239PJ_INLINE(int) trace_jb_print_state(pjmedia_vid_stream *stream, 
    236240                                    char **buf, pj_ssize_t len) 
    237241{ 
     
    405409} 
    406410 
     411/** 
     412 * Publish transport error event. 
     413 */ 
     414static void publish_tp_event(pjmedia_event_type event_type, 
     415                             pj_status_t status, 
     416                             pj_bool_t is_rtp, 
     417                             pjmedia_dir dir, 
     418                             pjmedia_vid_stream *stream) 
     419{ 
     420    pjmedia_event ev; 
     421    pj_timestamp ts_now; 
     422 
     423    pj_get_timestamp(&ts_now); 
     424    pj_bzero(&ev.data.med_tp_err, sizeof(ev.data.med_tp_err)); 
     425 
     426    /* Publish event. */ 
     427    pjmedia_event_init(&ev, event_type, 
     428                       &ts_now, stream); 
     429    ev.data.med_tp_err.type = PJMEDIA_TYPE_VIDEO; 
     430    ev.data.med_tp_err.is_rtp = is_rtp; 
     431    ev.data.med_tp_err.dir = dir; 
     432    ev.data.med_tp_err.status = status; 
     433 
     434    pjmedia_event_publish(NULL, stream, &ev, 0); 
     435} 
     436 
    407437#if defined(PJMEDIA_STREAM_ENABLE_KA) && PJMEDIA_STREAM_ENABLE_KA != 0 
    408438/* 
     
    462492 
    463493#else 
    464      
     494 
    465495    PJ_UNUSED_ARG(stream); 
    466496 
     
    478508    int len, max_len; 
    479509    pj_status_t status; 
     510    pjmedia_vid_channel *channel = stream->enc; 
    480511 
    481512    /* Build RTCP RR/SR packet */ 
     
    526557    /* Send! */ 
    527558    status = pjmedia_transport_send_rtcp(stream->transport, pkt, len); 
    528  
     559    if (status != PJ_SUCCESS) { 
     560        if (stream->rtcp_tx_err_cnt++ == 0) { 
     561            LOGERR_((channel->port.info.name.ptr, status, 
     562                     "Error sending RTCP")); 
     563        } 
     564        if (stream->rtcp_tx_err_cnt > SEND_ERR_COUNT_TO_REPORT) { 
     565            stream->rtcp_tx_err_cnt = 0; 
     566        } 
     567    } 
    529568    return status; 
    530569} 
     
    539578static void check_tx_rtcp(pjmedia_vid_stream *stream, pj_uint32_t timestamp) 
    540579{ 
    541     /* Note that timestamp may represent local or remote timestamp,  
     580    /* Note that timestamp may represent local or remote timestamp, 
    542581     * depending on whether this function is called from put_frame() 
    543582     * or get_frame(). 
     
    546585 
    547586    if (stream->rtcp_last_tx == 0) { 
    548          
     587 
    549588        stream->rtcp_last_tx = timestamp; 
    550589 
    551590    } else if (timestamp - stream->rtcp_last_tx >= stream->rtcp_interval) { 
    552591        pj_status_t status; 
    553          
     592 
    554593        status = send_rtcp(stream, !stream->rtcp_sdes_bye_disabled, PJ_FALSE); 
    555594        if (status != PJ_SUCCESS) { 
     
    591630/* 
    592631 * This callback is called by stream transport on receipt of packets 
    593  * in the RTP socket.  
     632 * in the RTP socket. 
    594633 */ 
    595634static void on_rx_rtp( pjmedia_tp_cb_param *param) 
     
    612651            return; 
    613652        } 
    614         if (stream->rtp_rx_last_err != status) { 
    615             char errmsg[PJ_ERR_MSG_SIZE]; 
    616             pj_strerror(status, errmsg, sizeof(errmsg)); 
    617             PJ_LOG(4,(channel->port.info.name.ptr, 
    618                       "Unable to receive RTP packet, recv() returned %d: %s", 
    619                       status, errmsg)); 
    620             stream->rtp_rx_last_err = status; 
     653 
     654        LOGERR_((channel->port.info.name.ptr, status, 
     655                 "Unable to receive RTP packet")); 
     656 
     657        if (status == PJ_ESOCKETSTOP) { 
     658            /* Publish receive error event. */ 
     659            publish_tp_event(PJMEDIA_EVENT_MEDIA_TP_ERR, status, PJ_TRUE, 
     660                             PJMEDIA_DIR_DECODING, stream); 
    621661        } 
    622662        return; 
    623     } else { 
    624         stream->rtp_rx_last_err = PJ_SUCCESS; 
    625663    } 
    626664 
     
    653691    pjmedia_rtp_session_update2(&channel->rtp, hdr, &seq_st, PJ_TRUE); 
    654692    if (seq_st.status.value) { 
    655         TRC_  ((channel->port.info.name.ptr,  
     693        TRC_  ((channel->port.info.name.ptr, 
    656694                "RTP status: badpt=%d, badssrc=%d, dup=%d, " 
    657                 "outorder=%d, probation=%d, restart=%d",  
     695                "outorder=%d, probation=%d, restart=%d", 
    658696                seq_st.status.flag.badpt, 
    659697                seq_st.status.flag.badssrc, 
     
    691729    } 
    692730 
    693     /* See if source address of RTP packet is different than the  
     731    /* See if source address of RTP packet is different than the 
    694732     * configured address, and check if we need to tell the 
    695733     * media transport to switch RTP remote address. 
     
    705743        } else { 
    706744            stream->rtp_src_cnt++; 
    707              
     745 
    708746            if (stream->rtp_src_cnt < PJMEDIA_RTP_NAT_PROBATION_CNT) { 
    709747                if (stream->rem_rtp_flag == 1 || 
     
    718756                    pkt_discarded = PJ_TRUE; 
    719757                    goto on_return; 
    720                 }                
     758                } 
    721759                if (stream->info.has_rem_ssrc && !seq_st.status.flag.badssrc 
    722760                    && stream->rem_rtp_flag != 1) 
     
    793831    } else { 
    794832        /* Just put the payload into jitter buffer */ 
    795         pjmedia_jbuf_put_frame3(stream->jb, payload, payloadlen, 0,  
     833        pjmedia_jbuf_put_frame3(stream->jb, payload, payloadlen, 0, 
    796834                                pj_ntohs(hdr->seq), pj_ntohl(hdr->ts), NULL); 
    797835 
     
    844882/* 
    845883 * This callback is called by stream transport on receipt of packets 
    846  * in the RTCP socket.  
     884 * in the RTCP socket. 
    847885 */ 
    848886static void on_rx_rtcp( void *data, 
    849                         void *pkt,  
     887                        void *pkt, 
    850888                        pj_ssize_t bytes_read) 
    851889{ 
    852890    pjmedia_vid_stream *stream = (pjmedia_vid_stream*) data; 
     891    pj_status_t status; 
    853892 
    854893    /* Check for errors */ 
    855894    if (bytes_read < 0) { 
    856         if (bytes_read != -PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK)) { 
    857             LOGERR_((stream->cname.ptr, (pj_status_t)-bytes_read, 
    858                      "RTCP recv() error")); 
     895        status = (pj_status_t)-bytes_read; 
     896        if (status == PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK)) { 
     897            return; 
     898        } 
     899        LOGERR_((stream->cname.ptr, status, "Unable to receive RTCP packet")); 
     900        if (status == PJ_ESOCKETSTOP) { 
     901            /* Publish receive error event. */ 
     902            publish_tp_event(PJMEDIA_EVENT_MEDIA_TP_ERR, status, PJ_FALSE, 
     903                             PJMEDIA_DIR_DECODING, stream); 
    859904        } 
    860905        return; 
     
    889934        pj_uint32_t dtx_duration; 
    890935 
    891         dtx_duration = pj_timestamp_diff32(&stream->last_frm_ts_sent,  
     936        dtx_duration = pj_timestamp_diff32(&stream->last_frm_ts_sent, 
    892937                                           &frame->timestamp); 
    893938 
     
    922967 
    923968    /* Check if need to send keyframe. */ 
    924     if (stream->num_keyframe &&  
    925         (pj_cmp_timestamp(&null_ts, &stream->last_keyframe_tx) != 0))  
    926     {    
     969    if (stream->num_keyframe && 
     970        (pj_cmp_timestamp(&null_ts, &stream->last_keyframe_tx) != 0)) 
     971    { 
    927972        unsigned elapse_time; 
    928973        pj_timestamp now; 
     
    935980        { 
    936981            stream->force_keyframe = PJ_TRUE; 
    937             --stream->num_keyframe;              
     982            --stream->num_keyframe; 
    938983        } 
    939984    } 
     
    9651010        return status; 
    9661011    } 
    967      
     1012 
    9681013    pj_get_timestamp(&initial_time); 
    9691014 
    970     if ((stream->num_keyframe) &&  
    971         ((frame_out.bit_info & PJMEDIA_VID_FRM_KEYFRAME)  
    972                                                   == PJMEDIA_VID_FRM_KEYFRAME))  
     1015    if ((stream->num_keyframe) && 
     1016        ((frame_out.bit_info & PJMEDIA_VID_FRM_KEYFRAME) 
     1017                                                  == PJMEDIA_VID_FRM_KEYFRAME)) 
    9731018    { 
    9741019        stream->last_keyframe_tx = initial_time; 
     
    10031048                                                    sizeof(pjmedia_rtp_hdr)); 
    10041049            if (status != PJ_SUCCESS) { 
    1005                 enum { COUNT_TO_REPORT = 20 }; 
    1006                 if (stream->send_err_cnt++ == 0) { 
     1050                if (stream->rtp_tx_err_cnt++ == 0) { 
    10071051                    LOGERR_((channel->port.info.name.ptr, status, 
    1008                              "Transport send_rtp() error")); 
     1052                             "Error sending RTP")); 
    10091053                } 
    1010                 if (stream->send_err_cnt > COUNT_TO_REPORT) 
    1011                     stream->send_err_cnt = 0; 
    1012                 /* Ignore this error */ 
     1054                if (stream->rtp_tx_err_cnt > SEND_ERR_COUNT_TO_REPORT) { 
     1055                    stream->rtp_tx_err_cnt = 0; 
     1056                } 
    10131057            } 
    1014  
    10151058            pjmedia_rtcp_tx_rtp(&stream->rtcp, (unsigned)frame_out.size); 
    10161059            total_sent += frame_out.size; 
     
    10821125#endif 
    10831126 
    1084     /* Check if now is the time to transmit RTCP SR/RR report.  
     1127    /* Check if now is the time to transmit RTCP SR/RR report. 
    10851128     * We only do this when stream direction is not "decoding only", because 
    10861129     * when it is, check_tx_rtcp() will be handled by get_frame(). 
     
    12441287 
    12451288            ts_diff = frm_ts - stream->last_dec_ts; 
    1246              
     1289 
    12471290            /* Calculate new FPS based on RTP timestamp diff */ 
    12481291            if (stream->info.codec_info.clock_rate % ts_diff == 0) { 
     
    12731316                    pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    12741317 
    1275                     stream->dec_delay_cnt =  
     1318                    stream->dec_delay_cnt = 
    12761319                                    ((PJMEDIA_VID_STREAM_DECODE_MIN_DELAY_MSEC * 
    12771320                                      vfd->fps.num) + 
     
    14251468    char fourcc_name[5]; 
    14261469    pjmedia_port_info *pi; 
    1427      
     1470 
    14281471    pj_assert(info->type == PJMEDIA_TYPE_VIDEO); 
    14291472    pj_assert(dir == PJMEDIA_DIR_DECODING || dir == PJMEDIA_DIR_ENCODING); 
     
    14501493    channel->paused = 1; 
    14511494    channel->pt = pt; 
    1452      
     1495 
    14531496    /* Allocate buffer for outgoing packet. */ 
    14541497    if (dir == PJMEDIA_DIR_ENCODING) { 
     
    15531596    /* Init stream/port name */ 
    15541597    stream->name.ptr = (char*) pj_pool_alloc(pool, M); 
    1555     stream->name.slen = pj_ansi_snprintf(stream->name.ptr, M,  
     1598    stream->name.slen = pj_ansi_snprintf(stream->name.ptr, M, 
    15561599                                         "vstrm%p", stream); 
    15571600 
    15581601    /* Create and initialize codec: */ 
    1559     status = pjmedia_vid_codec_mgr_alloc_codec(stream->codec_mgr,  
     1602    status = pjmedia_vid_codec_mgr_alloc_codec(stream->codec_mgr, 
    15601603                                               &info->codec_info, 
    15611604                                               &stream->codec); 
     
    15671610        pjmedia_vid_codec_param def_param; 
    15681611 
    1569         status = pjmedia_vid_codec_mgr_get_default_param(stream->codec_mgr,  
     1612        status = pjmedia_vid_codec_mgr_get_default_param(stream->codec_mgr, 
    15701613                                                         &info->codec_info, 
    15711614                                                         &def_param); 
     
    16421685    stream->frame_size = vfd_enc->max_bps/8 * vfd_enc->fps.denum / 
    16431686                         vfd_enc->fps.num; 
    1644      
     1687 
    16451688    /* As the maximum frame_size is not represented directly by maximum bps 
    16461689     * (which includes intra and predicted frames), let's increase the 
     
    16511694 
    16521695    /* Validate the frame size */ 
    1653     if (stream->frame_size == 0 ||  
     1696    if (stream->frame_size == 0 || 
    16541697        stream->frame_size > PJMEDIA_MAX_VIDEO_ENC_FRAME_SIZE) 
    16551698    { 
     
    16861729 
    16871730    /* Create decoder channel */ 
    1688     status = create_channel( pool, stream, PJMEDIA_DIR_DECODING,  
     1731    status = create_channel( pool, stream, PJMEDIA_DIR_DECODING, 
    16891732                             info->rx_pt, info, &stream->dec); 
    16901733    if (status != PJ_SUCCESS) 
     
    16921735 
    16931736    /* Create encoder channel */ 
    1694     status = create_channel( pool, stream, PJMEDIA_DIR_ENCODING,  
     1737    status = create_channel( pool, stream, PJMEDIA_DIR_ENCODING, 
    16951738                             info->tx_pt, info, &stream->enc); 
    16961739    if (status != PJ_SUCCESS) 
     
    17931836    pj_sockaddr_cp(&stream->rem_rtp_addr, &info->rem_addr); 
    17941837    if (info->rtcp_mux) { 
    1795         pj_sockaddr_cp(&att_param.rem_rtcp, &info->rem_addr);            
     1838        pj_sockaddr_cp(&att_param.rem_rtcp, &info->rem_addr); 
    17961839    } else if (pj_sockaddr_has_addr(&info->rem_rtcp.addr)) { 
    17971840        pj_sockaddr_cp(&att_param.rem_rtcp, &info->rem_rtcp); 
    1798     }     
     1841    } 
    17991842    att_param.addr_len = pj_sockaddr_get_len(&info->rem_addr); 
    18001843    att_param.rtp_cb2 = &on_rx_rtp; 
     
    18241867        pj_ssize_t len; 
    18251868 
    1826         pj_ansi_snprintf(trace_name, sizeof(trace_name),  
     1869        pj_ansi_snprintf(trace_name, sizeof(trace_name), 
    18271870                         TRACE_JB_PATH_PREFIX "%s.csv", 
    18281871                         channel->port.info.name.ptr); 
     
    18321875            stream->trace_jb_fd = TRACE_JB_INVALID_FD; 
    18331876            PJ_PERROR(3,(THIS_FILE, status, 
    1834                          "Failed creating RTP trace file '%s'",  
     1877                         "Failed creating RTP trace file '%s'", 
    18351878                         trace_name)); 
    18361879        } else { 
     
    18761919 
    18771920        total_time = pj_elapsed_msec(&stream->tx_start, &stream->tx_end); 
    1878         PJ_LOG(5, (stream->name.ptr,  
     1921        PJ_LOG(5, (stream->name.ptr, 
    18791922                   "RC stat: pkt_cnt=%.2f/image, sleep=%.2fms/s, fps=%.2f", 
    18801923                   stream->rc_total_pkt*1.0/stream->rc_total_img, 
     
    18891932    } 
    18901933 
    1891     /* Detach from transport  
     1934    /* Detach from transport 
    18921935     * MUST NOT hold stream mutex while detaching from transport, as 
    18931936     * it may cause deadlock. See ticket #460 for the details. 
     
    19131956 
    19141957    /* Free mutex */ 
    1915      
     1958 
    19161959    if (stream->jb_mutex) { 
    19171960        pj_mutex_destroy(stream->jb_mutex); 
  • pjproject/trunk/pjsip-apps/src/pjsua/pjsua_app.c

    r5999 r6005  
    905905} 
    906906 
     907static char *get_media_dir(pjmedia_dir dir) { 
     908    switch (dir) { 
     909    case PJMEDIA_DIR_ENCODING: 
     910        return "TX"; 
     911    case PJMEDIA_DIR_DECODING: 
     912        return "RX"; 
     913    case PJMEDIA_DIR_ENCODING+PJMEDIA_DIR_DECODING: 
     914        return "TX+RX"; 
     915    default: 
     916        return "unknown dir"; 
     917    }     
     918} 
     919 
    907920/* Callback on media events */ 
    908921static void on_call_media_event(pjsua_call_id call_id, 
     
    915928              pjmedia_fourcc_name(event->type, event_name))); 
    916929 
     930    if (event->type == PJMEDIA_EVENT_MEDIA_TP_ERR) { 
     931        pjmedia_event_media_tp_err_data *err_data; 
     932 
     933        err_data = &event->data.med_tp_err; 
     934        PJ_PERROR(3, (THIS_FILE, err_data->status,  
     935                  "Media transport error event (%s %s %s)", 
     936                  (err_data->type==PJMEDIA_TYPE_AUDIO)?"Audio":"Video", 
     937                  (err_data->is_rtp)?"RTP":"RTCP", 
     938                  get_media_dir(err_data->dir))); 
     939    } 
    917940#if PJSUA_HAS_VIDEO 
    918     if (event->type == PJMEDIA_EVENT_FMT_CHANGED) { 
     941    else if (event->type == PJMEDIA_EVENT_FMT_CHANGED) { 
    919942        /* Adjust renderer window size to original video size */ 
    920943        pjsua_call_info ci; 
     
    931954            wid = ci.media[med_idx].stream.vid.win_in; 
    932955            pjsua_vid_win_get_info(wid, &win_info); 
    933              
     956 
    934957            size = event->data.fmt_changed.new_fmt.det.vid.size; 
    935958            if (size.w != win_info.size.w || size.h != win_info.size.h) { 
     
    943966#else 
    944967    PJ_UNUSED_ARG(call_id); 
    945     PJ_UNUSED_ARG(med_idx); 
    946     PJ_UNUSED_ARG(event); 
     968    PJ_UNUSED_ARG(med_idx);     
    947969#endif 
    948970} 
Note: See TracChangeset for help on using the changeset viewer.