LLVMFuzzerTestOneInput: 26| 602|{ 27| 602| static thread_local struct rtpp_log *log; 28| 602| static thread_local struct rtpp_analyzer *rap; 29| 602| struct rtp_packet *pktp; 30| | 31| 602| if (size > MAX_RPKT_LEN) ------------------ | | 37| 602|#define MAX_RPKT_LEN 8192 ------------------ | Branch (31:9): [True: 0, False: 602] ------------------ 32| 0| return (0); 33| | 34| 602| if (log == NULL) { ------------------ | Branch (34:9): [True: 1, False: 601] ------------------ 35| 1| log = rtpp_log_ctor("rtpproxy", NULL, LF_REOPEN); ------------------ | | 42| 1|#define LF_REOPEN 0 ------------------ 36| 1| assert(log != NULL); ------------------ | Branch (36:9): [True: 0, False: 1] | Branch (36:9): [True: 1, False: 0] ------------------ 37| 1| rap = rtpp_analyzer_ctor(log); 38| 1| assert(rap != NULL); ------------------ | Branch (38:9): [True: 0, False: 1] | Branch (38:9): [True: 1, False: 0] ------------------ 39| 1| } 40| | 41| 602| pktp = rtp_packet_alloc(); 42| 602| assert(pktp != NULL); ------------------ | Branch (42:5): [True: 0, False: 602] | Branch (42:5): [True: 602, False: 0] ------------------ 43| 602| pktp->size = size; 44| 602| memcpy(pktp->data.buf, data, size); 45| | 46| 602| CALL_SMETHOD(rap, update, pktp); ------------------ | | 156| 602|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | ------------------ | | | | 154| 602|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | ------------------ | | | | | | 118| 602|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | 119| 602| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | 120| 602| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | 121| 602| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | 122| 602| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | 123| 602| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | 124| 602| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | 125| 602| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | 126| 602| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | 127| 602| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | 128| 602| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | 129| 602| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | 130| 602| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | 131| 602| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | 132| 602| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | 133| 602| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | 134| 602| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | 135| 602| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | 136| 602| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | 137| 602| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | 138| 602| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | 139| 602| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | 140| 602| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | 141| 602| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | 142| 602| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | 143| 602| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | 144| 602| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | 145| 602| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | 146| 602| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | 147| 602| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | 148| 602| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | 149| 602|) | | | | ------------------ | | ------------------ ------------------ 47| 602| RTPP_OBJ_DECREF(pktp); ------------------ | | 174| 602|#define RTPP_OBJ_DECREF(obj) RC_DECREF((obj)->rcnt) | | ------------------ | | | | 83| 602|#define RC_DECREF(rp, ...) _RC_CHOOSE(_RC_REF, __VA_ARGS__)(rp, decref, ##__VA_ARGS__) | | | | ------------------ | | | | | | 79| 602|#define _RC_CHOOSE(NAME, ...) _GET_ARG_3(__VA_ARGS__, NAME##_2, NAME##_1,) | | | | | | ------------------ | | | | | | | | 78| |#define _GET_ARG_3(_1, _2, _3, ...) _3 | | | | | | | | ------------------ | | | | | | | | | | 80| 602|#define _RC_REF_1(rp, method) CALL_SMETHOD(rp, method, HEREVAL) | | | | | | | | | | ------------------ | | | | | | | | | | | | 156| 602|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 154| 602|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 118| 602|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | | | | | | | | | | | 119| 602| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | | | | | | | | | | | 120| 602| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | | | | | | | | | | | 121| 602| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | | | | | | | | | | | 122| 602| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | | | | | | | | | | | 123| 602| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | | | | | | | | | | | 124| 602| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | | | | | | | | | | | 125| 602| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | | | | | | | | | | | 126| 602| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | | | | | | | | | | | 127| 602| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | | | | | | | | | | | 128| 602| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | | | | | | | | | | | 129| 602| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | | | | | | | | | | | 130| 602| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | | | | | | | | | | | 131| 602| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | | | | | | | | | | | 132| 602| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | | | | | | | | | | | 133| 602| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | | | | | | | | | | | 134| 602| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | | | | | | | | | | | 135| 602| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | | | | | | | | | | | 136| 602| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | | | | | | | | | | | 137| 602| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | | | | | | | | | | | 138| 602| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | | | | | | | | | | | 139| 602| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | | | | | | | | | | | 140| 602| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | | | | | | | | | | | 141| 602| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | | | | | | | | | | | 142| 602| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | | | | | | | | | | | 143| 602| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | | | | | | | | | | | 144| 602| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | | | | | | | | | | | 145| 602| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | | | | | | | | | | | 146| 602| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | | | | | | | | | | | 147| 602| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | | | | | | | | | | | 148| 602| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | | | | | | | | | | | 149| 602|) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 80| 602|#define _RC_REF_1(rp, method) CALL_SMETHOD(rp, method, HEREVAL) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 40| 602|#define HEREVAL ({static const struct rtpp_codeptr _here = {.fname = __FILE__, .linen = __LINE__, .funcn = __func__}; &_here;}) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 48| 602| return (0); 49| 602|} rtp_packet_parse_raw: 282| 596|{ 283| 596| int padding_size; 284| 596| rtp_hdr_ext_t *hdr_ext_ptr; 285| 596| rtp_hdr_t *header; 286| | 287| 596| header = (rtp_hdr_t *)buf; 288| | 289| 596| padding_size = 0; 290| | 291| 596| rinfo->data_size = 0; 292| 596| rinfo->data_offset = 0; 293| 596| rinfo->appendable = 1; 294| 596| rinfo->nsamples = RTP_NSAMPLES_UNKNOWN; ------------------ | | 71| 596|#define RTP_NSAMPLES_UNKNOWN (-1) ------------------ 295| | 296| 596| if (size < sizeof(*header)) ------------------ | Branch (296:9): [True: 29, False: 567] ------------------ 297| 29| return RTP_PARSER_PTOOSHRT; 298| | 299| 567| if (header->version != 2) ------------------ | Branch (299:9): [True: 4, False: 563] ------------------ 300| 4| return RTP_PARSER_IHDRVER; 301| | 302| 563| rinfo->data_offset = RTP_HDR_LEN(header); ------------------ | | 137| 563|#define RTP_HDR_LEN(rhp) (sizeof(*(rhp)) + ((rhp)->cc * sizeof((rhp)->csrc[0]))) ------------------ 303| | 304| 563| if (header->x != 0) { ------------------ | Branch (304:9): [True: 85, False: 478] ------------------ 305| 85| if (size < rinfo->data_offset + sizeof(*hdr_ext_ptr)) ------------------ | Branch (305:13): [True: 7, False: 78] ------------------ 306| 7| return RTP_PARSER_PTOOSHRTXS; 307| 78| hdr_ext_ptr = (rtp_hdr_ext_t *)&buf[rinfo->data_offset]; 308| 78| rinfo->data_offset += sizeof(rtp_hdr_ext_t) + 309| 78| (ntohs(hdr_ext_ptr->length) * sizeof(hdr_ext_ptr->extension[0])); 310| 78| } 311| | 312| 556| if (size < rinfo->data_offset) ------------------ | Branch (312:9): [True: 21, False: 535] ------------------ 313| 21| return RTP_PARSER_PTOOSHRTXH; 314| | 315| 535| if (header->p != 0) { ------------------ | Branch (315:9): [True: 93, False: 442] ------------------ 316| 93| if (rinfo->data_offset == size) ------------------ | Branch (316:13): [True: 1, False: 92] ------------------ 317| 1| return RTP_PARSER_PTOOSHRTPS; 318| 92| padding_size = buf[size - 1]; 319| 92| if (padding_size == 0) ------------------ | Branch (319:13): [True: 3, False: 89] ------------------ 320| 3| return RTP_PARSER_IPS; 321| 92| } 322| | 323| 531| if (size < rinfo->data_offset + padding_size) ------------------ | Branch (323:9): [True: 19, False: 512] ------------------ 324| 19| return RTP_PARSER_PTOOSHRTP; 325| | 326| 512| rinfo->data_size = size - rinfo->data_offset - padding_size; 327| 512| rinfo->ts = ntohl(header->ts); 328| 512| rinfo->seq = ntohs(header->seq); 329| 512| rinfo->ssrc = ntohl(header->ssrc); 330| 512| rinfo->rtp_profile = &rtp_profiles[header->pt]; 331| | 332| 512| if (rinfo->data_size == 0) ------------------ | Branch (332:9): [True: 321, False: 191] ------------------ 333| 321| return RTP_PARSER_OK; 334| | 335| 191| rinfo->nsamples = rtp_calc_samples(header->pt, rinfo->data_size, 336| 191| &buf[rinfo->data_offset]); 337| | /* 338| | * G.729 comfort noise frame as the last frame causes 339| | * packet to be non-appendable 340| | */ 341| 191| if (header->pt == RTP_G729 && (rinfo->data_size % 10) != 0) ------------------ | Branch (341:9): [True: 7, False: 184] | Branch (341:35): [True: 6, False: 1] ------------------ 342| 6| rinfo->appendable = 0; 343| 191| return RTP_PARSER_OK; 344| 512|} rtp.c:g723_len: 68| 1.53k|{ 69| | 70| 1.53k| switch (ch & 3) { 71| 671| case 2: ------------------ | Branch (71:5): [True: 671, False: 863] ------------------ 72| | /* Silence Insertion Descriptor (SID) frame */ 73| 671| return 4; 74| | 75| 460| case 0: ------------------ | Branch (75:5): [True: 460, False: 1.07k] ------------------ 76| | /* 6.3 kbit/s frame */ 77| 460| return 24; 78| | 79| 364| case 1: ------------------ | Branch (79:5): [True: 364, False: 1.17k] ------------------ 80| | /* 5.3 kbit/s frame */ 81| 364| return 20; 82| | 83| 39| default: ------------------ | Branch (83:5): [True: 39, False: 1.49k] ------------------ 84| 39| return RTP_NSAMPLES_UNKNOWN; ------------------ | | 71| 39|#define RTP_NSAMPLES_UNKNOWN (-1) ------------------ 85| 1.53k| } 86| 1.53k|} rtp.c:rtp_calc_samples: 104| 191|{ 105| | 106| 191| switch (codec_id) { 107| 32| case RTP_PCMU: ------------------ | Branch (107:2): [True: 32, False: 159] ------------------ 108| 34| case RTP_PCMA: ------------------ | Branch (108:2): [True: 2, False: 189] ------------------ 109| 34| return nbytes; 110| | 111| 7| case RTP_G729: ------------------ | Branch (111:2): [True: 7, False: 184] ------------------ 112| 7| return (nbytes / 10) * 80 + (nbytes % 10 == 0 ? 0 : 80); ------------------ | Branch (112:35): [True: 1, False: 6] ------------------ 113| | 114| 5| case RTP_GSM: ------------------ | Branch (114:2): [True: 5, False: 186] ------------------ 115| 5| return 160 * (nbytes / 33); 116| | 117| 112| case RTP_G723: ------------------ | Branch (117:2): [True: 112, False: 79] ------------------ 118| 112| return g723_samples(data, nbytes); 119| | 120| 2| case RTP_G722: ------------------ | Branch (120:2): [True: 2, False: 189] ------------------ 121| 2| return nbytes; 122| | 123| 31| default: ------------------ | Branch (123:2): [True: 31, False: 160] ------------------ 124| 31| return RTP_NSAMPLES_UNKNOWN; ------------------ | | 71| 31|#define RTP_NSAMPLES_UNKNOWN (-1) ------------------ 125| 191| } 126| 191|} rtp.c:g723_samples: 90| 112|{ 91| 112| int pos, samples, n; 92| | 93| 1.60k| for (pos = 0, samples = 0; pos < maxlen; pos += n) { ------------------ | Branch (93:32): [True: 1.53k, False: 73] ------------------ 94| 1.53k| samples += 240; 95| 1.53k| n = g723_len(buf[pos]); 96| 1.53k| if (n == RTP_NSAMPLES_UNKNOWN) ------------------ | | 71| 1.53k|#define RTP_NSAMPLES_UNKNOWN (-1) ------------------ | Branch (96:6): [True: 39, False: 1.49k] ------------------ 97| 39| return RTP_NSAMPLES_UNKNOWN; ------------------ | | 71| 39|#define RTP_NSAMPLES_UNKNOWN (-1) ------------------ 98| 1.53k| } 99| 73| return samples; 100| 112|} rtpp_stats_init: 212| 1|{ 213| | 214| 1| memset(stat, '\0', sizeof(struct rtpp_session_stat)); 215| 1| stat->jdata = rtp_analyze_jt_ctor(); 216| 1| if (stat->jdata == NULL) { ------------------ | Branch (216:9): [True: 0, False: 1] ------------------ 217| 0| return (-1); 218| 0| } 219| 1| stat->last.pt = PT_UNKN; ------------------ | | 41| 1|#define PT_UNKN 128 ------------------ 220| 1| return (0); 221| 1|} update_rtpp_stats: 349| 512|{ 350| 512| uint32_t seq; 351| 512| uint16_t idx; 352| 512| uint32_t mask; 353| 512| const struct rtp_profile *rpp; 354| 512| struct rtp_analyze_jdata *jdp; 355| | 356| 512| rpp = rinfo->rtp_profile; 357| 512| jdp = jdata_by_ssrc(stat->jdata, rinfo->ssrc); 358| 512| if (jdp == NULL) ------------------ | Branch (358:9): [True: 0, False: 512] ------------------ 359| 0| return (UPDATE_ERR); 360| 512| if (stat->ssrc_changes == 0) { ------------------ | Branch (360:9): [True: 1, False: 511] ------------------ 361| 1| RTPP_DBG_ASSERT(stat->last.pcount == 0); 362| 1| RTPP_DBG_ASSERT(stat->psent == 0); 363| 1| RTPP_DBG_ASSERT(stat->precvd == 0); 364| 1| stat->last.ssrc.val = rinfo->ssrc; 365| 1| stat->last.ssrc.inited = 1; 366| 1| stat->last.max_seq = stat->last.min_seq = rinfo->seq; 367| 1| stat->last.base_ts = rinfo->ts; 368| 1| stat->last.base_rtime = rtime; 369| 1| stat->last.pcount = 1; 370| 1| stat->ssrc_changes = 1; 371| 1| idx = (rinfo->seq % 131072) >> 5; 372| 1| stat->last.seen[idx] |= (uint32_t)1 << (rinfo->seq & 31); 373| 1| stat->last.seq = rinfo->seq; 374| 1| if (rpp->ts_rate > 0) { ------------------ | Branch (374:13): [True: 1, False: 0] ------------------ 375| 1| update_jitter_stats(jdp, rinfo, rtime, RTP_NORMAL, rlog); ------------------ | | 111| 1|#define RTP_NORMAL 0 ------------------ 376| 1| } 377| 1| return (UPDATE_OK); 378| 1| } 379| 511| RTPP_DBG_ASSERT(stat->last.ssrc.inited == 1); 380| 511| if (stat->last.ssrc.val != rinfo->ssrc) { ------------------ | Branch (380:9): [True: 216, False: 295] ------------------ 381| 216| update_rtpp_totals(stat, stat); 382| 216| stat->last.duplicates = 0; 383| 216| memset(stat->last.seen, '\0', sizeof(stat->last.seen)); 384| |#if !defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) 385| | LOGI_IF_NOT_NULL(rlog, "SSRC changed from " SSRC_FMT "/%d to " 386| | SSRC_FMT "/%d", stat->last.ssrc.val, stat->last.seq, rinfo->ssrc, 387| | rinfo->seq); 388| |#endif 389| 216| stat->last.ssrc.val = rinfo->ssrc; 390| 216| stat->last.max_seq = stat->last.min_seq = rinfo->seq; 391| 216| stat->last.base_ts = rinfo->ts; 392| 216| stat->last.base_rtime = rtime; 393| 216| stat->last.pcount = 1; 394| 216| stat->ssrc_changes += 1; 395| 216| if ((stat->psent > 0 || stat->precvd > 0) && rlog != NULL) { ------------------ | Branch (395:14): [True: 216, False: 0] | Branch (395:33): [True: 0, False: 0] | Branch (395:54): [True: 216, False: 0] ------------------ 396| 216| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: ssrc_changes=%u, psent=%u, precvd=%u", ------------------ | | 103| 216| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 216, False: 0] | | ------------------ | | 104| 216| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 216|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 648|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 216|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 216| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 216|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 396| 216| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: ssrc_changes=%u, psent=%u, precvd=%u", | | | | | | | | ------------------ | | | | | | | | | | 31| 216|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 397| 216| rinfo->ssrc, rinfo->seq, stat->ssrc_changes, stat->psent, stat->precvd); | | | | | | ------------------ | | | | ------------------ | | | | 57| 216| __LINE__, ## args) | | ------------------ | | 105| 216| } ------------------ 397| 216| rinfo->ssrc, rinfo->seq, stat->ssrc_changes, stat->psent, stat->precvd); 398| 216| } 399| 216| idx = (rinfo->seq % 131072) >> 5; 400| 216| stat->last.seen[idx] |= (uint32_t)1 << (rinfo->seq & 31); 401| 216| stat->last.seq = rinfo->seq; 402| 216| if (rpp->ts_rate > 0) { ------------------ | Branch (402:13): [True: 167, False: 49] ------------------ 403| 167| update_jitter_stats(jdp, rinfo, rtime, RTP_SSRC_RESET, rlog); ------------------ | | 113| 167|#define RTP_SSRC_RESET 2 ------------------ 404| 167| } 405| 216| return (UPDATE_SSRC_CHG); 406| 216| } 407| 295| seq = rinfo->seq + stat->last.seq_offset; 408| 295| if (header->mbt && (seq < stat->last.max_seq && (stat->last.max_seq & 0xffff) != 65535)) { ------------------ | Branch (408:9): [True: 157, False: 138] | Branch (408:25): [True: 44, False: 113] | Branch (408:53): [True: 39, False: 5] ------------------ 409| 39| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: seq reset last->max_seq=%u, seq=%u, m=%u", ------------------ | | 103| 39| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 39, False: 0] | | ------------------ | | 104| 39| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 39|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 117|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 39|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 39| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 39|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 409| 39| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: seq reset last->max_seq=%u, seq=%u, m=%u", | | | | | | | | ------------------ | | | | | | | | | | 31| 39|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 410| 39| rinfo->ssrc, rinfo->seq, stat->last.max_seq, seq, header->mbt); | | | | | | ------------------ | | | | ------------------ | | | | 57| 39| __LINE__, ## args) | | ------------------ | | 105| 39| } ------------------ 410| 39| rinfo->ssrc, rinfo->seq, stat->last.max_seq, seq, header->mbt); 411| | /* Seq reset has happened. Treat it as a ssrc change */ 412| 39| update_rtpp_totals(stat, stat); 413| 39| stat->last.duplicates = 0; 414| 39| memset(stat->last.seen, '\0', sizeof(stat->last.seen)); 415| 39| stat->last.max_seq = stat->last.min_seq = seq; 416| 39| stat->last.base_ts = rinfo->ts; 417| 39| stat->last.base_rtime = rtime; 418| 39| stat->last.pcount = 1; 419| 39| stat->seq_res_count += 1; 420| 39| idx = (seq % 131072) >> 5; 421| 39| stat->last.seen[idx] |= (uint32_t)1 << (rinfo->seq & 31); 422| 39| stat->last.seq = rinfo->seq; 423| 39| if (rpp->ts_rate > 0) { ------------------ | Branch (423:13): [True: 29, False: 10] ------------------ 424| 29| update_jitter_stats(jdp, rinfo, rtime, RTP_SEQ_RESET, rlog); ------------------ | | 112| 29|#define RTP_SEQ_RESET 1 ------------------ 425| 29| } 426| 39| return (UPDATE_OK); 427| 256| } else { 428| 256| if (rpp->ts_rate > 0) { ------------------ | Branch (428:13): [True: 209, False: 47] ------------------ 429| 209| if (seq == 0 && (stat->last.max_seq & 0xffff) < 65500) { ------------------ | Branch (429:17): [True: 2, False: 207] | Branch (429:29): [True: 2, False: 0] ------------------ 430| 2| update_jitter_stats(jdp, rinfo, rtime, RTP_SEQ_RESET, rlog); ------------------ | | 112| 2|#define RTP_SEQ_RESET 1 ------------------ 431| 207| } else { 432| 207| update_jitter_stats(jdp, rinfo, rtime, RTP_NORMAL, rlog); ------------------ | | 111| 207|#define RTP_NORMAL 0 ------------------ 433| 207| } 434| 209| } 435| 256| } 436| 256| if (rpp->ts_rate != 0 && ABS(rtime - stat->last.base_rtime - ------------------ | | 42| 209|#define ABS(x) ((x) > 0 ? (x) : (-x)) | | ------------------ | | | Branch (42:26): [True: 0, False: 209] | | ------------------ ------------------ | Branch (436:9): [True: 209, False: 47] | Branch (436:30): [True: 0, False: 209] ------------------ 437| 209| rtp_ts2dtime(rpp->ts_rate, rinfo->ts - stat->last.base_ts)) > 0.1) { 438| 0| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: delta rtime=%f, delta ts=%f", ------------------ | | 103| 0| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 0, False: 0] | | ------------------ | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 0|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 0|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 438| 0| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: delta rtime=%f, delta ts=%f", | | | | | | | | ------------------ | | | | | | | | | | 31| 0|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 439| 0| rinfo->ssrc, rinfo->seq, rtime - stat->last.base_rtime, | | | | | | | | 440| 0| rtp_ts2dtime(rpp->ts_rate, rinfo->ts - stat->last.base_ts)); | | | | | | ------------------ | | | | ------------------ | | | | 57| 0| __LINE__, ## args) | | ------------------ | | 105| 0| } ------------------ 439| 0| rinfo->ssrc, rinfo->seq, rtime - stat->last.base_rtime, 440| 0| rtp_ts2dtime(rpp->ts_rate, rinfo->ts - stat->last.base_ts)); 441| 0| stat->last.base_rtime = rtime; 442| 0| } 443| 256| if (stat->last.max_seq % 65536 < 536 && rinfo->seq > 65000) { ------------------ | Branch (443:9): [True: 96, False: 160] | Branch (443:45): [True: 49, False: 47] ------------------ 444| | /* Pre-wrap packet received after a wrap */ 445| 49| seq -= 65536; 446| 207| } else if (stat->last.max_seq > 65000 && seq < stat->last.max_seq - 65000) { ------------------ | Branch (446:16): [True: 164, False: 43] | Branch (446:46): [True: 13, False: 151] ------------------ 447| 13| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: wrap last->max_seq=%u, seq=%u", ------------------ | | 103| 13| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 13, False: 0] | | ------------------ | | 104| 13| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 13|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 39|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 13|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 13| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 13|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 447| 13| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: wrap last->max_seq=%u, seq=%u", | | | | | | | | ------------------ | | | | | | | | | | 31| 13|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 448| 13| rinfo->ssrc, rinfo->seq, stat->last.max_seq, seq); | | | | | | ------------------ | | | | ------------------ | | | | 57| 13| __LINE__, ## args) | | ------------------ | | 105| 13| } ------------------ 448| 13| rinfo->ssrc, rinfo->seq, stat->last.max_seq, seq); 449| | /* Wrap up has happened */ 450| 13| stat->last.seq_offset += 65536; 451| 13| seq += 65536; 452| 13| if (stat->last.seq_offset % 131072 == 65536) { ------------------ | Branch (452:13): [True: 7, False: 6] ------------------ 453| 7| memset(stat->last.seen + 2048, '\0', sizeof(stat->last.seen) / 2); 454| 7| } else { 455| 6| memset(stat->last.seen, '\0', sizeof(stat->last.seen) / 2); 456| 6| } 457| 194| } else if (seq + 536 < stat->last.max_seq || seq > stat->last.max_seq + 536) { ------------------ | Branch (457:16): [True: 27, False: 167] | Branch (457:50): [True: 96, False: 71] ------------------ 458| 123| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: desync last->max_seq=%u, seq=%u, m=%u", ------------------ | | 103| 123| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 123, False: 0] | | ------------------ | | 104| 123| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 123|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 369|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 123|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 123| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 123|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 458| 123| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: desync last->max_seq=%u, seq=%u, m=%u", | | | | | | | | ------------------ | | | | | | | | | | 31| 123|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 459| 123| rinfo->ssrc, rinfo->seq, stat->last.max_seq, seq, header->mbt); | | | | | | ------------------ | | | | ------------------ | | | | 57| 123| __LINE__, ## args) | | ------------------ | | 105| 123| } ------------------ 459| 123| rinfo->ssrc, rinfo->seq, stat->last.max_seq, seq, header->mbt); 460| | /* Desynchronization has happened. Treat it as a ssrc change */ 461| 123| update_rtpp_totals(stat, stat); 462| 123| stat->last.duplicates = 0; 463| 123| memset(stat->last.seen, '\0', sizeof(stat->last.seen)); 464| 123| stat->last.max_seq = stat->last.min_seq = seq; 465| 123| stat->last.pcount = 1; 466| 123| stat->desync_count += 1; 467| 123| idx = (seq % 131072) >> 5; 468| 123| stat->last.seen[idx] |= (uint32_t)1 << (rinfo->seq & 31); 469| 123| stat->last.seq = rinfo->seq; 470| 123| return (UPDATE_OK); 471| 123| } 472| | /* printf("last->max_seq=%u, seq=%u, m=%u\n", stat->last.max_seq, seq, header->mbt);*/ 473| 133| idx = (seq % 131072) >> 5; 474| 133| mask = stat->last.seen[idx]; 475| 133| if (((mask >> (seq & 31)) & 1) != 0) { ------------------ | Branch (475:9): [True: 22, False: 111] ------------------ 476| 22| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: DUP", ------------------ | | 103| 22| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 22, False: 0] | | ------------------ | | 104| 22| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 22|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 66|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 22|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 22| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 22|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 476| 22| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: DUP", | | | | | | | | ------------------ | | | | | | | | | | 31| 22|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 477| 22| rinfo->ssrc, rinfo->seq); | | | | | | ------------------ | | | | ------------------ | | | | 57| 22| __LINE__, ## args) | | ------------------ | | 105| 22| } ------------------ 477| 22| rinfo->ssrc, rinfo->seq); 478| 22| stat->last.duplicates += 1; 479| 22| stat->last.seq = rinfo->seq; 480| 22| return (UPDATE_OK); 481| 22| } 482| 111| stat->last.seen[idx] |= (uint32_t)1 << (rinfo->seq & 31); 483| 111| if (seq - stat->last.max_seq != 1) ------------------ | Branch (483:9): [True: 108, False: 3] ------------------ 484| 108| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: delta = %d", ------------------ | | 103| 108| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 108, False: 0] | | ------------------ | | 104| 108| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 108|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 324|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 108|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 108| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 108|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 484| 108| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: delta = %d", | | | | | | | | ------------------ | | | | | | | | | | 31| 108|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 485| 108| rinfo->ssrc, rinfo->seq, seq - stat->last.max_seq); | | | | | | ------------------ | | | | ------------------ | | | | 57| 108| __LINE__, ## args) | | ------------------ | | 105| 108| } ------------------ 485| 111| rinfo->ssrc, rinfo->seq, seq - stat->last.max_seq); 486| 111| if (seq >= stat->last.max_seq) { ------------------ | Branch (486:9): [True: 65, False: 46] ------------------ 487| 65| stat->last.max_seq = seq; 488| 65| stat->last.pcount += 1; 489| 65| stat->last.seq = rinfo->seq; 490| 65| return (UPDATE_OK); 491| 65| } 492| 46| if (seq >= stat->last.min_seq) { ------------------ | Branch (492:9): [True: 15, False: 31] ------------------ 493| 15| stat->last.pcount += 1; 494| 15| stat->last.seq = rinfo->seq; 495| 15| return (UPDATE_OK); 496| 15| } 497| 31| if (stat->last.seq_offset == 0 && seq < stat->last.min_seq) { ------------------ | Branch (497:9): [True: 2, False: 29] | Branch (497:39): [True: 2, False: 0] ------------------ 498| 2| stat->last.min_seq = seq; 499| 2| stat->last.pcount += 1; 500| 2| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: last->min_seq=%u", ------------------ | | 103| 2| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 2, False: 0] | | ------------------ | | 104| 2| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 2|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 6|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 2|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 2| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 2|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 500| 2| LOGD_IF_NOT_NULL(rlog, SSRC_FMT "/%d: last->min_seq=%u", | | | | | | | | ------------------ | | | | | | | | | | 31| 2|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 501| 2| rinfo->ssrc, rinfo->seq, stat->last.min_seq); | | | | | | ------------------ | | | | ------------------ | | | | 57| 2| __LINE__, ## args) | | ------------------ | | 105| 2| } ------------------ 501| 2| rinfo->ssrc, rinfo->seq, stat->last.min_seq); 502| 2| stat->last.seq = rinfo->seq; 503| 2| return (UPDATE_OK); 504| 2| } 505| | /* XXX something wrong with the stream */ 506| 29| stat->last.seq = rinfo->seq; 507| 29| return (UPDATE_ERR); 508| 31|} update_rtpp_totals: 512| 378|{ 513| | 514| 378| if (ostat != wstat) { ------------------ | Branch (514:9): [True: 0, False: 378] ------------------ 515| 0| ostat->psent = wstat->psent; 516| 0| ostat->precvd = wstat->precvd; 517| 0| ostat->duplicates = wstat->duplicates; 518| 0| } 519| 378| if (wstat->last.pcount == 0) ------------------ | Branch (519:9): [True: 0, False: 378] ------------------ 520| 0| return; 521| 378| ostat->psent += wstat->last.max_seq - wstat->last.min_seq + 1; 522| 378| ostat->precvd += wstat->last.pcount; 523| 378| ostat->duplicates += wstat->last.duplicates; 524| 378|} rtp_analyze.c:rtp_analyze_jt_ctor: 246| 1|{ 247| 1| struct rtp_analyze_jitter *jp; 248| | 249| 1| jp = rtpp_zmalloc(sizeof(*jp)); 250| 1| if (jp == NULL) { ------------------ | Branch (250:9): [True: 0, False: 1] ------------------ 251| 0| goto e0; 252| 0| } 253| 1| jp->first = rtp_analyze_jdata_ctor(); 254| 1| if (jp->first == NULL) { ------------------ | Branch (254:9): [True: 0, False: 1] ------------------ 255| 0| goto e1; 256| 0| } 257| 1| jp->jdlen = 1; 258| 1| return (jp); 259| | 260| 0|e1: 261| 0| free(jp); 262| 0|e0: 263| | return (NULL); 264| 0|} rtp_analyze.c:rtp_analyze_jdata_ctor: 225| 10|{ 226| 10| struct rtp_analyze_jdata *jdp; 227| | 228| 10| jdp = rtpp_zmalloc(sizeof(*jdp)); 229| 10| if (jdp == NULL) { ------------------ | Branch (229:9): [True: 0, False: 10] ------------------ 230| 0| goto e0; 231| 0| } 232| 10| jdp->ts_dedup = rtpp_ringbuf_ctor(sizeof(jdp->jss.prev_ts), 10); 233| 10| if (jdp->ts_dedup == NULL) { ------------------ | Branch (233:9): [True: 0, False: 10] ------------------ 234| 0| goto e1; 235| 0| } 236| 10| return (jdp); 237| | 238| 0|e1: 239| 0| free(jdp); 240| 0|e0: 241| | return (NULL); 242| 0|} rtp_analyze.c:jdata_by_ssrc: 293| 512|{ 294| 512| struct rtp_analyze_jdata *rjdp, *jdp_last, *jdp_prelast; 295| | 296| 512| if (jp->first->ssrc.inited == 0) { ------------------ | Branch (296:9): [True: 1, False: 511] ------------------ 297| 1| jp->first->ssrc.val = ssrc; 298| 1| jp->first->ssrc.inited = 1; 299| 1| return (jp->first); 300| 1| } 301| | 302| 511| jdp_last = jdp_prelast = NULL; 303| 3.48k| for (rjdp = jp->first; rjdp != NULL; rjdp = rjdp->next) { ------------------ | Branch (303:28): [True: 3.34k, False: 137] ------------------ 304| 3.34k| if (rjdp->ssrc.val == ssrc) { ------------------ | Branch (304:13): [True: 374, False: 2.97k] ------------------ 305| 374| return (rjdp); 306| 374| } 307| 2.97k| jdp_prelast = jdp_last; 308| 2.97k| jdp_last = rjdp; 309| 2.97k| } 310| | 311| 137| if (jp->jdlen == RTPC_JDATA_MAX) { ------------------ | | 115| 137|#define RTPC_JDATA_MAX 10 ------------------ | Branch (311:9): [True: 128, False: 9] ------------------ 312| | /* Re-use the last per-ssrc data */ 313| 128| rjdp = jdp_last; 314| 128| if (jdp_prelast != NULL) { ------------------ | Branch (314:13): [True: 128, False: 0] ------------------ 315| 128| RTPP_DBG_ASSERT(jdp_prelast->next == jdp_last); 316| 128| jdp_prelast->next = NULL; 317| 128| } else { 318| 0| jp->first = NULL; 319| 0| } 320| 128| CALL_SMETHOD(rjdp->ts_dedup, flush); ------------------ | | 156| 128|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | ------------------ | | | | 154| 128|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | ------------------ | | | | | | 118| 128|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | 119| 128| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | 120| 128| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | 121| 128| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | 122| 128| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | 123| 128| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | 124| 128| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | 125| 128| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | 126| 128| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | 127| 128| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | 128| 128| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | 129| 128| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | 130| 128| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | 131| 128| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | 132| 128| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | 133| 128| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | 134| 128| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | 135| 128| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | 136| 128| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | 137| 128| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | 138| 128| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | 139| 128| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | 140| 128| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | 141| 128| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | 142| 128| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | 143| 128| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | 144| 128| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | 145| 128| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | 146| 128| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | 147| 128| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | 148| 128| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | 149| 128|) | | | | ------------------ | | ------------------ ------------------ 321| 128| if (rjdp->jss.pcount >= 2) { ------------------ | Branch (321:13): [True: 12, False: 116] ------------------ 322| 12| if (jp->jmax_acum < rjdp->jss.jmax) { ------------------ | Branch (322:17): [True: 0, False: 12] ------------------ 323| 0| jp->jmax_acum = rjdp->jss.jmax; 324| 0| } 325| 12| jp->jtotal_acum += rjdp->jss.jtotal; 326| 12| jp->jvcount_acum += rjdp->jss.pcount - 1; 327| 12| jp->pcount_acum += rjdp->jss.pcount; 328| 12| } 329| 128| memset(&rjdp->jss, '\0', sizeof(rjdp->jss)); 330| 128| RTPP_DBG_ASSERT(rjdp->ssrc.inited == 1); 331| 128| } else { 332| | /* Allocate per-ssrc data */ 333| 9| rjdp = rtp_analyze_jdata_ctor(); 334| 9| if (rjdp == NULL) { ------------------ | Branch (334:13): [True: 0, False: 9] ------------------ 335| 0| return (NULL); 336| 0| } 337| 9| rjdp->ssrc.inited = 1; 338| 9| jp->jdlen += 1; 339| 9| } 340| 137| rjdp->ssrc.val = ssrc; 341| 137| rjdp->next = jp->first; 342| 137| jp->first = rjdp; 343| 137| return (rjdp); 344| 137|} rtp_analyze.c:update_jitter_stats: 120| 406|{ 121| 406| int64_t dval; 122| 406| uint64_t rtime_ts, wrcorr; 123| 406|#if FIX_TIMESTAMP_RESET 124| 406| int64_t rtime_ts_delta; 125| 406|#endif 126| | 127| 406| rtime_ts = rtp_dtime2time_ts64(rinfo->rtp_profile->ts_rate, rtime); 128| 406| if (rinfo->rtp_profile->pt_kind == RTP_PTK_AUDIO && ------------------ | Branch (128:9): [True: 406, False: 0] ------------------ 129| 406| CALL_SMETHOD(jdp->ts_dedup, locate, &rinfo->ts) >= 0) { ------------------ | | 156| 406|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | ------------------ | | | | 154| 406|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | ------------------ | | | | | | 118| 406|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | 119| 406| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | 120| 406| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | 121| 406| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | 122| 406| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | 123| 406| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | 124| 406| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | 125| 406| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | 126| 406| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | 127| 406| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | 128| 406| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | 129| 406| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | 130| 406| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | 131| 406| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | 132| 406| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | 133| 406| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | 134| 406| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | 135| 406| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | 136| 406| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | 137| 406| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | 138| 406| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | 139| 406| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | 140| 406| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | 141| 406| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | 142| 406| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | 143| 406| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | 144| 406| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | 145| 406| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | 146| 406| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | 147| 406| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | 148| 406| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | 149| 406|) | | | | ------------------ | | ------------------ ------------------ | Branch (129:7): [True: 62, False: 344] ------------------ 130| 62| jdp->jss.ts_dcount++; 131| 62| if (jdp->jss.pcount == 1) { ------------------ | Branch (131:13): [True: 0, False: 62] ------------------ 132| 0| jdp->jss.prev_rtime_ts = rtime_ts; 133| 0| jdp->jss.prev_ts = rinfo->ts; 134| 0| } 135| 62| return; 136| 62| } 137| 344| if (jdp->jss.prev_rtime_ts != 0) { ------------------ | Branch (137:9): [True: 0, False: 344] ------------------ 138| 0| if (hint == RTP_SEQ_RESET) { ------------------ | | 112| 0|#define RTP_SEQ_RESET 1 ------------------ | Branch (138:13): [True: 0, False: 0] ------------------ 139| 0| jdp->jss.seq_rcount++; 140| 0| goto saveandexit; 141| 0| } 142| 0|#if FIX_TIMESTAMP_RESET 143| 0| rtime_ts_delta = jdp->jss.prev_rtime_ts - rtime_ts; 144| 0|#endif 145| 0| if (jdp->jss.prev_ts > rinfo->ts) { ------------------ | Branch (145:13): [True: 0, False: 0] ------------------ 146| 0| if (((uint64_t)jdp->jss.prev_ts - (uint64_t)rinfo->ts) > ((uint32_t)1 << 31)) { ------------------ | Branch (146:17): [True: 0, False: 0] ------------------ 147| | /* Normal case, timestamp wrap */ 148| 0| wrcorr = (uint64_t)1 << 32; 149| 0|#if FIX_TIMESTAMP_RESET 150| 0| } else if (rtime_ts_delta != 0 && ((uint64_t)jdp->jss.prev_ts - (uint64_t)rinfo->ts) > ------------------ | Branch (150:24): [True: 0, False: 0] | Branch (150:47): [True: 0, False: 0] ------------------ 151| 0| ABS(rtime_ts_delta) * 50) { ------------------ | | 42| 0|#define ABS(x) ((x) > 0 ? (x) : (-x)) | | ------------------ | | | Branch (42:26): [True: 0, False: 0] | | ------------------ ------------------ 152| | /* Timestamp reset */ 153| 0|#if DEBUG_TIMESTAMP_RESET 154| 0| LOGD_IF_NOT_NULL(rlog, "update_jitter_stats() : timestamp reset : " SSRC_FMT ", %lld, %llu", ------------------ | | 103| 0| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 0, False: 0] | | ------------------ | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 0|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 0|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 154| 0| LOGD_IF_NOT_NULL(rlog, "update_jitter_stats() : timestamp reset : " SSRC_FMT ", %lld, %llu", | | | | | | | | 155| 0| rinfo->ssrc, T_printf(ABS(rtime_ts_delta)), | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (39:33): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (40:36): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (41:26): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | | | 156| 0| T_printf((uint64_t)jdp->jss.prev_ts - (uint64_t)rinfo->ts)); | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 57| 0| __LINE__, ## args) | | ------------------ | | 105| 0| } ------------------ 155| 0| rinfo->ssrc, T_printf(ABS(rtime_ts_delta)), 156| 0| T_printf((uint64_t)jdp->jss.prev_ts - (uint64_t)rinfo->ts)); 157| 0|#endif 158| 0| jdp->jss.ts_rcount++; 159| 0| goto saveandexit; 160| 0|#endif 161| 0| } else { 162| 0| wrcorr = 0; 163| 0| } 164| 0| } else { 165| 0|# if FIX_TIMESTAMP_RESET 166| 0| if (rtime_ts_delta != 0 && ((uint64_t)rinfo->ts - (uint64_t)jdp->jss.prev_ts) > ------------------ | Branch (166:17): [True: 0, False: 0] | Branch (166:40): [True: 0, False: 0] ------------------ 167| 0| ABS(rtime_ts_delta) * 1024) { ------------------ | | 42| 0|#define ABS(x) ((x) > 0 ? (x) : (-x)) | | ------------------ | | | Branch (42:26): [True: 0, False: 0] | | ------------------ ------------------ 168| | /* Timestamp jump */ 169| 0|#if DEBUG_TIMESTAMP_RESET 170| 0| LOGD_IF_NOT_NULL(rlog,"update_jitter_stats() : timestamp jump : " SSRC_FMT ", %lld, %lld", ------------------ | | 103| 0| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 0, False: 0] | | ------------------ | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 0|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 0|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 170| 0| LOGD_IF_NOT_NULL(rlog,"update_jitter_stats() : timestamp jump : " SSRC_FMT ", %lld, %lld", | | | | | | | | 171| 0| rinfo->ssrc, T_printf(ABS(rtime_ts_delta)), | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (39:33): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (40:36): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (41:26): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | | | 172| 0| T_printf((uint64_t)rinfo->ts - (uint64_t)jdp->jss.prev_ts)); | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | ------------------ | | | | 57| 0| __LINE__, ## args) | | ------------------ | | 105| 0| } ------------------ 171| 0| rinfo->ssrc, T_printf(ABS(rtime_ts_delta)), 172| 0| T_printf((uint64_t)rinfo->ts - (uint64_t)jdp->jss.prev_ts)); 173| 0|#endif 174| 0| jdp->jss.ts_jcount++; 175| 0| goto saveandexit; 176| 0| } 177| 0|#endif 178| 0| wrcorr = 0; 179| 0| } 180| 0| dval = (rtime_ts - ((uint64_t)rinfo->ts + wrcorr)) - 181| 0| (jdp->jss.prev_rtime_ts - (uint64_t)jdp->jss.prev_ts); 182| 0|#if DEBUG_TIMESTAMP_RESET 183| 0| if (dval > 10000) ------------------ | Branch (183:13): [True: 0, False: 0] ------------------ 184| 0| LOGD_IF_NOT_NULL(rlog, "##### LARGE VALUE #####" SSRC_FMT ",%lld,%llu,%u,%llu,%u,%llu,%lld", ------------------ | | 103| 0| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 0, False: 0] | | ------------------ | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 0|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 0|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 184| 0| LOGD_IF_NOT_NULL(rlog, "##### LARGE VALUE #####" SSRC_FMT ",%lld,%llu,%u,%llu,%u,%llu,%lld", | | | | | | | | 185| 0| rinfo->ssrc, jdp->jss.pcount, T_printf(rtime_ts), rinfo->ts, | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | | | 186| 0| T_printf(jdp->jss.prev_rtime_ts), jdp->jss.prev_ts, | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | | | 187| 0| T_printf(wrcorr), T_printf(dval)); | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | | | T_printf(wrcorr), T_printf(dval)); | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 57| 0| __LINE__, ## args) | | ------------------ | | 105| 0| } ------------------ 185| 0| rinfo->ssrc, jdp->jss.pcount, T_printf(rtime_ts), rinfo->ts, 186| 0| T_printf(jdp->jss.prev_rtime_ts), jdp->jss.prev_ts, 187| 0| T_printf(wrcorr), T_printf(dval)); 188| 0|#endif 189| 0| jdp->jss.jlast = jdp->jss.jlast + (double)(ABS(dval) - jdp->jss.jlast) / 16.0; ------------------ | | 42| 0|#define ABS(x) ((x) > 0 ? (x) : (-x)) | | ------------------ | | | Branch (42:26): [True: 0, False: 0] | | ------------------ ------------------ 190| 0| if (jdp->jss.jlast > jdp->jss.jmax) { ------------------ | Branch (190:13): [True: 0, False: 0] ------------------ 191| 0| jdp->jss.jmax = jdp->jss.jlast; 192| 0| } 193| 0| jdp->jss.jtotal += jdp->jss.jlast; 194| 0| } 195| 344| RTPP_DBGCODE(analyze > 1) { ------------------ | | 86| 344|#define RTPP_DBGCODE(x) if (_DCOND_##x) | | ------------------ | | | | 84| 344|#define _DCOND_analyze RTPP_DEBUG_analyze | | | | ------------------ | | | | | | 66| 344|# define RTPP_DEBUG_analyze RTPP_DBG_NO | | | | | | ------------------ | | | | | | | | 34| 344|#define RTPP_DBG_NO 0 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:29): [Folded, False: 344] | | ------------------ ------------------ 196| 0| LOGD_IF_NOT_NULL(rlog, SSRC_FMT ",%lld,%llu,%u,%f", rinfo->ssrc, jdp->jss.pcount, ------------------ | | 103| 0| if ((log) != NULL) { \ | | ------------------ | | | Branch (103:9): [True: 0, False: 0] | | ------------------ | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | ------------------ | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | ------------------ | | | | | | 83| 0|#define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 56| 0|#define RTPP_LOG(log, args...) CALL_METHOD((log), genwrite, __FUNCTION__, \ | | | | | | | | 57| | __LINE__, ## args) | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 104| 0| RTPP_LOG((log), RTPP_LOG_DBUG, ## args); \ | | | | | | | | ------------------ | | | | | | | | | | 44| 0|#define RTPP_LOG_DBUG LOG_DEBUG | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define CALL_METHOD(obj, method, args...) (obj)->method(obj, ## args) | | | | | | ------------------ | | | | | | | | 196| 0| LOGD_IF_NOT_NULL(rlog, SSRC_FMT ",%lld,%llu,%u,%f", rinfo->ssrc, jdp->jss.pcount, | | | | | | | | ------------------ | | | | | | | | | | 31| 0|#define SSRC_FMT "0x%.8X" | | | | | | | | ------------------ | | | | | | | | 197| 0| T_printf(rtime_ts), rinfo->ts, jdp->jss.jlast); | | | | | | | | ------------------ | | | | | | | | | | 39| 0|#define T_printf(val) _Generic((val), \ | | | | | | | | | | 40| 0| uint64_t: (unsigned long long)(val), \ | | | | | | | | | | 41| 0| int64_t: (long long)(val) \ | | | | | | | | | | 42| 0|) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 57| 0| __LINE__, ## args) | | ------------------ | | 105| 0| } ------------------ 197| 0| T_printf(rtime_ts), rinfo->ts, jdp->jss.jlast); 198| 0| } 199| 344| jdp->jss.pcount++; 200| 344|saveandexit: 201| 344| if (rinfo->rtp_profile->pt_kind == RTP_PTK_AUDIO) { ------------------ | Branch (201:9): [True: 344, False: 0] ------------------ 202| 344| CALL_SMETHOD(jdp->ts_dedup, push, &rinfo->ts); ------------------ | | 156| 344|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | ------------------ | | | | 154| 344|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | ------------------ | | | | | | 118| 344|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | 119| 344| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | 120| 344| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | 121| 344| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | 122| 344| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | 123| 344| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | 124| 344| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | 125| 344| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | 126| 344| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | 127| 344| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | 128| 344| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | 129| 344| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | 130| 344| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | 131| 344| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | 132| 344| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | 133| 344| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | 134| 344| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | 135| 344| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | 136| 344| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | 137| 344| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | 138| 344| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | 139| 344| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | 140| 344| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | 141| 344| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | 142| 344| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | 143| 344| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | 144| 344| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | 145| 344| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | 146| 344| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | 147| 344| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | 148| 344| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | 149| 344|) | | | | ------------------ | | ------------------ ------------------ 203| 344| } 204| 344| jdp->jss.prev_rtime_ts = rtime_ts; 205| 344| jdp->jss.prev_ts = rinfo->ts; 206| 344|} rtp_analyze.c:rtp_dtime2time_ts64: 96| 406|{ 97| | 98| 406| return (uint64_t)(dtime * (double)ts_rate); 99| 406|} rtp_analyze.c:rtp_ts2dtime: 89| 418|{ 90| | 91| 418| return ((double)ts) / ((double)ts_rate); 92| 418|} rtp_packet_alloc: 79| 602|{ 80| 602| struct rtp_packet_full *pkt; 81| | 82| 602| pkt = rtpp_rzmalloc(sizeof(*pkt), PVT_RCOFFS(pkt)); ------------------ | | 165| 602|#define PVT_RCOFFS(pvtp) (offsetof(typeof(*(pvtp)), pub) + offsetof(typeof((pvtp)->pub), rcnt)) ------------------ 83| 602| if (pkt == NULL) { ------------------ | Branch (83:9): [True: 0, False: 602] ------------------ 84| 0| return (NULL); 85| 0| } 86| | 87| 602| return &(pkt->pub); 88| 602|} rtp_packet_parse: 139| 602|{ 140| 602| struct rtp_packet_full *pkt_full; 141| 602| struct rtp_info *rinfo; 142| | 143| 602| if (pkt->parse_result != RTP_PARSER_NOTPARSED) { ------------------ | Branch (143:9): [True: 0, False: 602] ------------------ 144| 0| return (pkt->parse_result); 145| 0| } 146| 602| assert(pkt->parsed == NULL); ------------------ | Branch (146:5): [True: 0, False: 602] | Branch (146:5): [True: 602, False: 0] ------------------ 147| 602| pkt_full = (void *)pkt; 148| 602| rinfo = &(pkt_full->pvt.rinfo); 149| 602| if (rtp_packet_is_rtcp(pkt)) { ------------------ | Branch (149:9): [True: 6, False: 596] ------------------ 150| 6| pkt->parse_result = RTP_PARSER_ISRTCP; 151| 6| return (pkt->parse_result); 152| 6| } 153| 596| pkt->parse_result = rtp_packet_parse_raw(pkt->data.buf, pkt->size, rinfo); 154| 596| if (pkt->parse_result == RTP_PARSER_OK) { ------------------ | Branch (154:9): [True: 512, False: 84] ------------------ 155| 512| pkt->parsed = rinfo; 156| 512| } 157| 596| return (pkt->parse_result); 158| 602|} rtp_packet_is_rtcp: 165| 602|{ 166| 602| if (pkt->size < 2) ------------------ | Branch (166:9): [True: 2, False: 600] ------------------ 167| 2| return false; 168| | 169| 600| uint8_t version = (pkt->data.buf[0] >> 6) & 0b11; 170| 600| uint8_t packet_type = pkt->data.buf[1]; 171| | 172| | // Version should be 2 and RTCP packet types are in the range 200-213 173| | // https://www.iana.org/assignments/rtp-parameters/rtp-parameters.txt 174| 600| if (version == 2 && packet_type >= RTCP_PT_SR && packet_type <= RTCP_PR_SNM) ------------------ | | 160| 1.19k|#define RTCP_PT_SR 200 ------------------ if (version == 2 && packet_type >= RTCP_PT_SR && packet_type <= RTCP_PR_SNM) ------------------ | | 161| 75|#define RTCP_PR_SNM 213 ------------------ | Branch (174:9): [True: 591, False: 9] | Branch (174:25): [True: 75, False: 516] | Branch (174:54): [True: 6, False: 69] ------------------ 175| 6| return true; 176| 594| return false; 177| 600|} rtpp_analyzer_ctor: 72| 1|{ 73| 1| struct rtpp_analyzer_priv *pvt; 74| 1| struct rtpp_analyzer *rap; 75| | 76| 1| pvt = rtpp_rzmalloc(sizeof(struct rtpp_analyzer_priv), PVT_RCOFFS(pvt)); ------------------ | | 165| 1|#define PVT_RCOFFS(pvtp) (offsetof(typeof(*(pvtp)), pub) + offsetof(typeof((pvtp)->pub), rcnt)) ------------------ 77| 1| if (pvt == NULL) { ------------------ | Branch (77:9): [True: 0, False: 1] ------------------ 78| 0| return (NULL); 79| 0| } 80| 1| rap = &pvt->pub; 81| 1| if (rtpp_stats_init(&pvt->rstat) != 0) { ------------------ | Branch (81:9): [True: 0, False: 1] ------------------ 82| 0| goto e0; 83| 0| } 84| 1| pvt->log = log; 85| 1| RTPP_OBJ_INCREF(log); ------------------ | | 173| 1|#define RTPP_OBJ_INCREF(obj) RC_INCREF((obj)->rcnt) | | ------------------ | | | | 82| 1|#define RC_INCREF(rp, ...) _RC_CHOOSE(_RC_REF, __VA_ARGS__)(rp, incref, ##__VA_ARGS__) | | | | ------------------ | | | | | | 79| 1|#define _RC_CHOOSE(NAME, ...) _GET_ARG_3(__VA_ARGS__, NAME##_2, NAME##_1,) | | | | | | ------------------ | | | | | | | | 78| |#define _GET_ARG_3(_1, _2, _3, ...) _3 | | | | | | | | ------------------ | | | | | | | | | | 80| 1|#define _RC_REF_1(rp, method) CALL_SMETHOD(rp, method, HEREVAL) | | | | | | | | | | ------------------ | | | | | | | | | | | | 156| 1|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 154| 1|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 118| 1|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | | | | | | | | | | | 119| 1| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | | | | | | | | | | | 120| 1| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | | | | | | | | | | | 121| 1| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | | | | | | | | | | | 122| 1| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | | | | | | | | | | | 123| 1| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | | | | | | | | | | | 124| 1| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | | | | | | | | | | | 125| 1| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | | | | | | | | | | | 126| 1| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | | | | | | | | | | | 127| 1| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | | | | | | | | | | | 128| 1| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | | | | | | | | | | | 129| 1| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | | | | | | | | | | | 130| 1| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | | | | | | | | | | | 131| 1| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | | | | | | | | | | | 132| 1| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | | | | | | | | | | | 133| 1| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | | | | | | | | | | | 134| 1| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | | | | | | | | | | | 135| 1| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | | | | | | | | | | | 136| 1| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | | | | | | | | | | | 137| 1| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | | | | | | | | | | | 138| 1| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | | | | | | | | | | | 139| 1| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | | | | | | | | | | | 140| 1| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | | | | | | | | | | | 141| 1| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | | | | | | | | | | | 142| 1| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | | | | | | | | | | | 143| 1| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | | | | | | | | | | | 144| 1| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | | | | | | | | | | | 145| 1| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | | | | | | | | | | | 146| 1| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | | | | | | | | | | | 147| 1| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | | | | | | | | | | | 148| 1| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | | | | | | | | | | | 149| 1|) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 80| 1|#define _RC_REF_1(rp, method) CALL_SMETHOD(rp, method, HEREVAL) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 40| 1|#define HEREVAL ({static const struct rtpp_codeptr _here = {.fname = __FILE__, .linen = __LINE__, .funcn = __func__}; &_here;}) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 86| 1| PUBINST_FININIT(&pvt->pub, pvt, rtpp_analyzer_dtor); ------------------ | | 76| 1| RTPP_OBJ_DTOR_ATTACH_s((pub_inst), (rtpp_refcnt_dtor_t)(dtor), \ | | ------------------ | | | | 177| 1|#define RTPP_OBJ_DTOR_ATTACH_s(obj, f, p) CALL_SMETHOD((obj)->rcnt, attach_nc, \ | | | | ------------------ | | | | | | 156| 1|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | ------------------ | | | | | | | | 154| 1|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | | | | | ------------------ | | | | | | | | | | 118| 1|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | | | | | 119| 1| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | | | | | 120| 1| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | | | | | 121| 1| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | | | | | 122| 1| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | | | | | 123| 1| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | | | | | 124| 1| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | | | | | 125| 1| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | | | | | 126| 1| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | | | | | 127| 1| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | | | | | 128| 1| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | | | | | 129| 1| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | | | | | 130| 1| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | | | | | 131| 1| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | | | | | 132| 1| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | | | | | 133| 1| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | | | | | 134| 1| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | | | | | 135| 1| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | | | | | 136| 1| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | | | | | 137| 1| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | | | | | 138| 1| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | | | | | 139| 1| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | | | | | 140| 1| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | | | | | 141| 1| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | | | | | 142| 1| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | | | | | 143| 1| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | | | | | 144| 1| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | | | | | 145| 1| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | | | | | 146| 1| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | | | | | 147| 1| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | | | | | 148| 1| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | | | | | 149| 1|) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 178| 1| (rtpp_refcnt_dtor_t)(f), (p)) | | ------------------ | | 77| 1| pvt_inst); ------------------ 87| 1| return (rap); 88| 0|e0: 89| 0| RTPP_OBJ_DECREF(&(pvt->pub)); ------------------ | | 174| 0|#define RTPP_OBJ_DECREF(obj) RC_DECREF((obj)->rcnt) | | ------------------ | | | | 83| 0|#define RC_DECREF(rp, ...) _RC_CHOOSE(_RC_REF, __VA_ARGS__)(rp, decref, ##__VA_ARGS__) | | | | ------------------ | | | | | | 79| 0|#define _RC_CHOOSE(NAME, ...) _GET_ARG_3(__VA_ARGS__, NAME##_2, NAME##_1,) | | | | | | ------------------ | | | | | | | | 78| |#define _GET_ARG_3(_1, _2, _3, ...) _3 | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define _RC_REF_1(rp, method) CALL_SMETHOD(rp, method, HEREVAL) | | | | | | | | | | ------------------ | | | | | | | | | | | | 156| 0|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 154| 0|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 118| 0|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | | | | | | | | | | | 119| 0| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | | | | | | | | | | | 120| 0| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | | | | | | | | | | | 121| 0| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | | | | | | | | | | | 122| 0| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | | | | | | | | | | | 123| 0| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | | | | | | | | | | | 124| 0| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | | | | | | | | | | | 125| 0| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | | | | | | | | | | | 126| 0| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | | | | | | | | | | | 127| 0| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | | | | | | | | | | | 128| 0| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | | | | | | | | | | | 129| 0| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | | | | | | | | | | | 130| 0| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | | | | | | | | | | | 131| 0| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | | | | | | | | | | | 132| 0| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | | | | | | | | | | | 133| 0| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | | | | | | | | | | | 134| 0| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | | | | | | | | | | | 135| 0| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | | | | | | | | | | | 136| 0| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | | | | | | | | | | | 137| 0| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | | | | | | | | | | | 138| 0| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | | | | | | | | | | | 139| 0| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | | | | | | | | | | | 140| 0| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | | | | | | | | | | | 141| 0| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | | | | | | | | | | | 142| 0| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | | | | | | | | | | | 143| 0| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | | | | | | | | | | | 144| 0| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | | | | | | | | | | | 145| 0| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | | | | | | | | | | | 146| 0| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | | | | | | | | | | | 147| 0| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | | | | | | | | | | | 148| 0| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | | | | | | | | | | | 149| 0|) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 80| 0|#define _RC_REF_1(rp, method) CALL_SMETHOD(rp, method, HEREVAL) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 40| 0|#define HEREVAL ({static const struct rtpp_codeptr _here = {.fname = __FILE__, .linen = __LINE__, .funcn = __func__}; &_here;}) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 90| | return (NULL); 91| 1|} rtpp_analyzer.c:rtpp_analyzer_update: 95| 602|{ 96| 602| struct rtpp_analyzer_priv *pvt; 97| 602| enum update_rtpp_stats_rval rval; 98| | 99| 602| PUB2PVT(rap, pvt); ------------------ | | 169| 602| (pvtp) = (typeof(pvtp))((char *)(pubp) - offsetof(typeof(*(pvtp)), pub)) ------------------ 100| 602| if (rtp_packet_parse(pkt) != RTP_PARSER_OK) { ------------------ | Branch (100:9): [True: 90, False: 512] ------------------ 101| 90| pvt->pecount++; 102| 90| return (UPDATE_ERR); 103| 90| } 104| 512| rval = update_rtpp_stats(pvt->log, &(pvt->rstat), &(pkt->data.header), 105| 512| pkt->parsed, pkt->rtime.mono); 106| 512| if (rval == UPDATE_ERR) { ------------------ | Branch (106:9): [True: 29, False: 483] ------------------ 107| 29| pvt->aecount++; 108| 29| } 109| 512| pvt->rstat.last.pt = pkt->data.header.pt; 110| 512| return (rval); 111| 602|} rtpp_log_ctor: 73| 1|{ 74| 1| struct rtpp_log_priv *pvt; 75| | 76| 1| pvt = rtpp_rzmalloc(sizeof(struct rtpp_log_priv), PVT_RCOFFS(pvt)); ------------------ | | 165| 1|#define PVT_RCOFFS(pvtp) (offsetof(typeof(*(pvtp)), pub) + offsetof(typeof((pvtp)->pub), rcnt)) ------------------ 77| 1| if (pvt == NULL) { ------------------ | Branch (77:9): [True: 0, False: 1] ------------------ 78| 0| return (NULL); 79| 0| } 80| 1| pvt->pub.genwrite = rtpp_log_obj_write_early; 81| 1| pvt->pub.errwrite = rtpp_log_obj_ewrite_early; 82| 1| pvt->pub.setlevel = rtpp_log_obj_setlevel_early; 83| 1| pvt->pub.start = rtpp_log_obj_start; 84| 1| pvt->app = app; 85| 1| pvt->call_id = call_id; 86| 1| pvt->flags = flags; 87| 1| pvt->level = -1; 88| 1| RTPP_OBJ_DTOR_ATTACH_s(&pvt->pub, (rtpp_refcnt_dtor_t)&rtpp_log_obj_dtor, ------------------ | | 177| 1|#define RTPP_OBJ_DTOR_ATTACH_s(obj, f, p) CALL_SMETHOD((obj)->rcnt, attach_nc, \ | | ------------------ | | | | 156| 1|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | ------------------ | | | | | | 154| 1|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | | | ------------------ | | | | | | | | 118| 1|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | | | 119| 1| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | | | 120| 1| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | | | 121| 1| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | | | 122| 1| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | | | 123| 1| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | | | 124| 1| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | | | 125| 1| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | | | 126| 1| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | | | 127| 1| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | | | 128| 1| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | | | 129| 1| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | | | 130| 1| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | | | 131| 1| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | | | 132| 1| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | | | 133| 1| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | | | 134| 1| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | | | 135| 1| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | | | 136| 1| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | | | 137| 1| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | | | 138| 1| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | | | 139| 1| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | | | 140| 1| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | | | 141| 1| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | | | 142| 1| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | | | 143| 1| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | | | 144| 1| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | | | 145| 1| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | | | 146| 1| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | | | 147| 1| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | | | 148| 1| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | | | 149| 1|) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 178| 1| (rtpp_refcnt_dtor_t)(f), (p)) ------------------ 89| 1| pvt); 90| 1| return (&pvt->pub); 91| 1|} rtpp_log_obj.c:rtpp_log_obj_write_early: 155| 523|{ 156| 523| va_list ap; 157| 523| struct rtpp_log_priv *pvt; 158| | 159| 523| PUB2PVT(self, pvt); ------------------ | | 169| 523| (pvtp) = (typeof(pvtp))((char *)(pubp) - offsetof(typeof(*(pvtp)), pub)) ------------------ 160| 523| if (level > pvt->level) ------------------ | Branch (160:9): [True: 523, False: 0] ------------------ 161| 523| return; 162| 0| fprintf(stderr, "%s: ", fname); 163| 0| va_start(ap, fmt); 164| 0| vfprintf(stderr, fmt, ap); 165| 0| va_end(ap); 166| 0| fprintf(stderr, "\n"); 167| | fflush(stderr); 168| 0| return; 169| 523|} rtpp_zmalloc: 63| 21|{ 64| 21| void *rval; 65| | 66| 21|#if !defined(RTPP_CHECK_LEAKS) 67| 21| rval = rtpp_aligned_malloc(msize, rtpp_refcnt_oalign); 68| |#else 69| | rval = rtpp_memdeb_malloc(msize, memdeb_p, mlp); 70| |#endif 71| 21| if (rval != NULL) { ------------------ | Branch (71:9): [True: 21, False: 0] ------------------ 72| 21| memset(rval, '\0', msize); 73| 21| } 74| 21| return (rval); 75| 21|} rtpp_rzmalloc: 86| 614|{ 87| 614| void *rval; 88| 614| struct rtpp_refcnt *rcnt; 89| 614| size_t pad_size, asize, alignment; 90| 614| void *rco; 91| | 92| 614| RTPP_DBG_ASSERT(msize >= rcntp_offs + sizeof(struct rtpp_refcnt *)); 93| 614| alignment = rtpp_refcnt_oalign; 94| 614| RTPP_DBG_ASSERT((alignment & (alignment - 1)) == 0); 95| 614| pad_size = (alignment - (msize & (alignment - 1))) & (alignment - 1); 96| 614| asize = msize + pad_size + rtpp_refcnt_osize; 97| 614|#if !defined(RTPP_CHECK_LEAKS) 98| 614| rval = rtpp_aligned_malloc(asize, alignment); 99| |#else 100| | rval = rtpp_memdeb_malloc(asize, memdeb_p, mlp); 101| |#endif 102| 614| if (rval == NULL) { ------------------ | Branch (102:9): [True: 0, False: 614] ------------------ 103| 0| return (NULL); 104| 0| } 105| 614| memset(rval, '\0', asize); 106| 614| rco = (char *)rval + msize + pad_size; 107| 614| rcnt = rtpp_refcnt_ctor_pa(rco, rval); 108| 614| *PpP(rval, rcntp_offs, struct rtpp_refcnt **) = rcnt; ------------------ | | 77| 614|#define PpP(p1, p2, type) (type)(((char *)p1) + ((size_t)p2)) ------------------ 109| | 110| 614| return (rval); 111| 614|} rtpp_mallocs.c:rtpp_aligned_malloc: 43| 635|{ 44| 635| void *rval; 45| | 46| 635| if (alignment < sizeof(void *)) { ------------------ | Branch (46:9): [True: 0, False: 635] ------------------ 47| 0| alignment = sizeof(void *); 48| 0| } 49| 635| RTPP_DBG_ASSERT((alignment & (alignment - 1)) == 0); 50| 635| if (posix_memalign(&rval, alignment, msize) != 0) { ------------------ | Branch (50:9): [True: 0, False: 635] ------------------ 51| 0| return (NULL); 52| 0| } 53| 635| return (rval); 54| 635|} rtpp_refcnt_ctor_pa: 165| 614|{ 166| 614| struct rtpp_refcnt_priv *pvt; 167| | 168| 614| pvt = (struct rtpp_refcnt_priv *)pap; 169| 614| if (data != NULL) { ------------------ | Branch (169:9): [True: 614, False: 0] ------------------ 170| 614|#if !defined(RTPP_CHECK_LEAKS) 171| 614| pvt->dtors[0] = DTOR_PAIR_INIT(free, data); ------------------ | | 129| 614|#define DTOR_PAIR_INIT(fn, fd) (struct dtor_pair){.f=(fn), .data=(fd)} ------------------ 172| |#else 173| | pvt->dtors[0] = DTOR_PAIR_INIT(rtpp_refcnt_free, data); 174| |#endif 175| 614| } else { 176| 0| atomic_init(&pvt->ulen, -1); 177| 0| } 178| |#if defined(RTPP_DEBUG) 179| | pvt->pub.smethods = rtpp_refcnt_smethods; 180| |#endif 181| 614| return (&pvt->pub); 182| 614|} rtpp_refcnt.c:rtpp_refcnt_incref: 233| 1|{ 234| 1| struct rtpp_refcnt_priv *pvt; 235| 1| MAYBE_UNUSED int oldcnt; ------------------ | | 196| 1|#define MAYBE_UNUSED [[maybe_unused]] ------------------ 236| | 237| 1| PUB2PVT(pub, pvt); ------------------ | | 169| 1| (pvtp) = (typeof(pvtp))((char *)(pubp) - offsetof(typeof(*(pvtp)), pub)) ------------------ 238| 1| RTPP_DBGCODE() { ------------------ | | 86| 1|#define RTPP_DBGCODE(x) if (_DCOND_##x) | | ------------------ | | | | 77| 1|#define _DCOND_ RTPP_DBG_NO | | | | ------------------ | | | | | | 34| 1|#define RTPP_DBG_NO 0 | | | | | | ------------------ | | | | | | | Branch (34:21): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 239| 0| oldcnt = atomic_load_explicit(&pvt->cnt, memory_order_relaxed); 240| 0| RTPP_DBG_ASSERT(oldcnt >= 0 && oldcnt < RC_ABS_MAX); 241| 0| } 242| 1| if (pvt->shared) { ------------------ | Branch (242:9): [True: 0, False: 1] ------------------ 243| 0| oldcnt = atomic_fetch_add_explicit(&pvt->cnt, 1, memory_order_relaxed); 244| 1| } else { 245| 1| oldcnt = 0; 246| 1| pvt->shared = 1; 247| 1| atomic_store_explicit(&pvt->cnt, 1, memory_order_release); 248| 1| } 249| 1|#if RTPP_DEBUG_refcnt 250| 1| if (pvt->trace == 1) { ------------------ | Branch (250:9): [True: 0, False: 1] ------------------ 251| |#ifdef RTPP_DEBUG 252| | char *dbuf; 253| | rtpp_memdeb_asprintf(&dbuf, MEMDEB_SYM, mlp, 254| | CODEPTR_FMT(": rtpp_refcnt(%p, %u).incref()", mlp, pub, oldcnt+1)); 255| | if (dbuf != NULL) { 256| | rtpp_stacktrace_print(dbuf); 257| | free(dbuf); 258| | } 259| |#else 260| 0| fprintf(stderr, CODEPTR_FMT(": rtpp_refcnt(%p, %u).incref()\n", mlp, pub, oldcnt+1)); ------------------ | | 30| 0|#define CODEPTR_FMT(fmt, mlp, args...) ("%s+%d, %s()" fmt), (mlp)->fname, (mlp)->linen, (mlp)->funcn, ## args ------------------ 261| 0|#endif 262| 0| } 263| 1|#endif 264| 1| RTPP_DBG_ASSERT(oldcnt >= 0); 265| 1|} rtpp_refcnt.c:rtpp_refcnt_decref: 290| 602|{ 291| 602| struct rtpp_refcnt_priv *pvt; 292| 602| int oldcnt; 293| | 294| 602| PUB2PVT(pub, pvt); ------------------ | | 169| 602| (pvtp) = (typeof(pvtp))((char *)(pubp) - offsetof(typeof(*(pvtp)), pub)) ------------------ 295| 602| RTPP_DBGCODE() { ------------------ | | 86| 602|#define RTPP_DBGCODE(x) if (_DCOND_##x) | | ------------------ | | | | 77| 602|#define _DCOND_ RTPP_DBG_NO | | | | ------------------ | | | | | | 34| 602|#define RTPP_DBG_NO 0 | | | | | | ------------------ | | | | | | | Branch (34:21): [Folded, False: 602] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 296| 0| oldcnt = atomic_load_explicit(&pvt->cnt, memory_order_relaxed); 297| 0| RTPP_DBG_ASSERT(oldcnt >= 0 && oldcnt < RC_ABS_MAX); 298| 0| } 299| 602|#if RTPP_DEBUG_refcnt 300| | /* 301| | * Fetch flags before decrement, otherwise we can decrement and then 302| | * somebody decrements it and deallocates. Atomic is not needed since 303| | * this initialized at the init time. 304| | */ 305| 602| unsigned int trace = pvt->trace; 306| 602|#endif 307| 602| if (pvt->shared) { ------------------ | Branch (307:9): [True: 0, False: 602] ------------------ 308| 0| oldcnt = atomic_fetch_sub_explicit(&pvt->cnt, 1, memory_order_release); 309| 602| } else { 310| 602| oldcnt = 0; 311| 602| } 312| 602|#if RTPP_DEBUG_refcnt 313| 602| if (trace) { ------------------ | Branch (313:9): [True: 0, False: 602] ------------------ 314| |#ifdef RTPP_DEBUG 315| | char *dbuf; 316| | rtpp_memdeb_asprintf(&dbuf, MEMDEB_SYM, mlp, 317| | CODEPTR_FMT(": rtpp_refcnt(%p, %u).decref()", mlp, pub, oldcnt+1)); 318| | if (dbuf != NULL) { 319| | rtpp_stacktrace_print(dbuf); 320| | free(dbuf); 321| | } 322| |#else 323| 0| fprintf(stderr, CODEPTR_FMT(": rtpp_refcnt(%p, %u).decref()\n", mlp, pub, oldcnt+1)); ------------------ | | 30| 0|#define CODEPTR_FMT(fmt, mlp, args...) ("%s+%d, %s()" fmt), (mlp)->fname, (mlp)->linen, (mlp)->funcn, ## args ------------------ 324| 0|#endif 325| 0| } 326| 602|#endif 327| 602| RTPP_DBG_ASSERT(oldcnt >= 0); 328| 602| if (oldcnt == 0) { ------------------ | Branch (328:9): [True: 602, False: 0] ------------------ 329| 602| if (pvt->shared) { ------------------ | Branch (329:13): [True: 0, False: 602] ------------------ 330| 0| atomic_thread_fence(memory_order_acquire); 331| 0| } 332| 602| int ulen = atomic_load_explicit(&pvt->ulen, memory_order_relaxed); 333| 1.20k| for (int i = ulen; i >= 0; i--) { ------------------ | Branch (333:28): [True: 602, False: 602] ------------------ 334| 602| struct dtor_pair *dp = &pvt->dtors[i]; 335| 602|#if RTPP_DEBUG_refcnt 336| 602| if (trace) { ------------------ | Branch (336:17): [True: 0, False: 602] ------------------ 337| 0| Dl_info info; 338| 0| if (dladdr(dp->f, &info) && info.dli_sname != NULL) ------------------ | Branch (338:21): [True: 0, False: 0] | Branch (338:45): [True: 0, False: 0] ------------------ 339| 0| fprintf(stderr, "calling destructor %s@<%p>(%p)\n", info.dli_sname, 340| 0| dp->f, dp->data); 341| 0| else 342| 0| fprintf(stderr, "calling destructor @<%p>(%p)\n", dp->f, dp->data); 343| 0| } 344| 602|#endif 345| 602| if (i == 0) ------------------ | Branch (345:17): [True: 602, False: 0] ------------------ 346| 602| rtpp_refcnt_fin(pub); 347| 602| if (dp->f != NULL) { ------------------ | Branch (347:17): [True: 602, False: 0] ------------------ 348| 602| dp->f(dp->data); 349| 602| } else { 350| 0| struct rtpp_refcnt *other = dp->rcnt; 351| 0| rtpp_refcnt_decref(other, mlp); 352| 0| } 353| 602| } 354| 602| } 355| 602|} rtpp_refcnt.c:rtpp_refcnt_attach: 187| 12|{ 188| 12| struct rtpp_refcnt_priv *pvt; 189| | 190| 12| PUB2PVT(pub, pvt); ------------------ | | 169| 12| (pvtp) = (typeof(pvtp))((char *)(pubp) - offsetof(typeof(*(pvtp)), pub)) ------------------ 191| 12| int ulen = atomic_fetch_add_explicit(&pvt->ulen, 1, memory_order_relaxed) + 1; 192| 12| if (ulen >= MAX_DTORS) { ------------------ | | 32| 12|#define MAX_DTORS 24 ------------------ | Branch (192:9): [True: 0, False: 12] ------------------ 193| 0| atomic_fetch_sub_explicit(&pvt->ulen, 1, memory_order_relaxed); 194| 0| return -1; 195| 0| } 196| 12| pvt->dtors[ulen] = DTOR_PAIR_INIT(dtor_f, data); ------------------ | | 129| 12|#define DTOR_PAIR_INIT(fn, fd) (struct dtor_pair){.f=(fn), .data=(fd)} ------------------ 197| 12| return 0; 198| 12|} rtpp_refcnt.c:rtpp_refcnt_attach_nc: 203| 12|{ 204| 12| MAYBE_UNUSED int r = rtpp_refcnt_attach(pub, dtor_f, data); ------------------ | | 196| 12|#define MAYBE_UNUSED [[maybe_unused]] ------------------ 205| 12| RTPP_DBG_ASSERT(r == 0); 206| 12|} rtpp_ringbuf_ctor: 63| 10|{ 64| 10| struct rtpp_ringbuf_priv *pvt; 65| | 66| 10| pvt = rtpp_rzmalloc(sizeof(struct rtpp_ringbuf_priv), PVT_RCOFFS(pvt)); ------------------ | | 165| 10|#define PVT_RCOFFS(pvtp) (offsetof(typeof(*(pvtp)), pub) + offsetof(typeof((pvtp)->pub), rcnt)) ------------------ 67| 10| if (pvt == NULL) { ------------------ | Branch (67:9): [True: 0, False: 10] ------------------ 68| 0| goto e0; 69| 0| } 70| 10| pvt->elements = rtpp_zmalloc(el_size * nelements); 71| 10| if (pvt->elements == NULL) { ------------------ | Branch (71:9): [True: 0, False: 10] ------------------ 72| 0| goto e1; 73| 0| } 74| 10| pvt->el_size = el_size; 75| 10| pvt->nelements = nelements; 76| 10| PUBINST_FININIT(&pvt->pub, pvt, rtpp_ringbuf_dtor); ------------------ | | 76| 10| RTPP_OBJ_DTOR_ATTACH_s((pub_inst), (rtpp_refcnt_dtor_t)(dtor), \ | | ------------------ | | | | 177| 10|#define RTPP_OBJ_DTOR_ATTACH_s(obj, f, p) CALL_SMETHOD((obj)->rcnt, attach_nc, \ | | | | ------------------ | | | | | | 156| 10|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | ------------------ | | | | | | | | 154| 10|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | | | | | ------------------ | | | | | | | | | | 118| 10|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | | | | | 119| 10| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | | | | | 120| 10| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | | | | | 121| 10| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | | | | | 122| 10| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | | | | | 123| 10| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | | | | | 124| 10| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | | | | | 125| 10| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | | | | | 126| 10| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | | | | | 127| 10| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | | | | | 128| 10| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | | | | | 129| 10| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | | | | | 130| 10| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | | | | | 131| 10| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | | | | | 132| 10| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | | | | | 133| 10| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | | | | | 134| 10| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | | | | | 135| 10| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | | | | | 136| 10| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | | | | | 137| 10| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | | | | | 138| 10| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | | | | | 139| 10| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | | | | | 140| 10| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | | | | | 141| 10| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | | | | | 142| 10| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | | | | | 143| 10| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | | | | | 144| 10| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | | | | | 145| 10| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | | | | | 146| 10| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | | | | | 147| 10| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | | | | | 148| 10| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | | | | | 149| 10|) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 178| 10| (rtpp_refcnt_dtor_t)(f), (p)) | | ------------------ | | 77| 10| pvt_inst); ------------------ 77| 10| return (&pvt->pub); 78| 0|e1: 79| 0| RTPP_OBJ_DECREF(&(pvt->pub)); ------------------ | | 174| 0|#define RTPP_OBJ_DECREF(obj) RC_DECREF((obj)->rcnt) | | ------------------ | | | | 83| 0|#define RC_DECREF(rp, ...) _RC_CHOOSE(_RC_REF, __VA_ARGS__)(rp, decref, ##__VA_ARGS__) | | | | ------------------ | | | | | | 79| 0|#define _RC_CHOOSE(NAME, ...) _GET_ARG_3(__VA_ARGS__, NAME##_2, NAME##_1,) | | | | | | ------------------ | | | | | | | | 78| |#define _GET_ARG_3(_1, _2, _3, ...) _3 | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define _RC_REF_1(rp, method) CALL_SMETHOD(rp, method, HEREVAL) | | | | | | | | | | ------------------ | | | | | | | | | | | | 156| 0|#define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 154| 0|#define GET_SMETHOD(obj, method) (GET_SMETHODS(obj)->method) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 118| 0|#define GET_SMETHODS(obj) _Generic((obj), \ | | | | | | | | | | | | | | | | 119| 0| struct rtpp_refcnt *: rtpp_refcnt_smethods, \ | | | | | | | | | | | | | | | | 120| 0| struct rtpp_pearson_perfect *: rtpp_pearson_perfect_smethods, \ | | | | | | | | | | | | | | | | 121| 0| struct rtpp_netaddr *: rtpp_netaddr_smethods, \ | | | | | | | | | | | | | | | | 122| 0| struct rtpp_server *: rtpp_server_smethods, \ | | | | | | | | | | | | | | | | 123| 0| struct rtpp_stats *: rtpp_stats_smethods, \ | | | | | | | | | | | | | | | | 124| 0| struct rtpp_timed *: rtpp_timed_smethods, \ | | | | | | | | | | | | | | | | 125| 0| struct rtpp_stream *: rtpp_stream_smethods, \ | | | | | | | | | | | | | | | | 126| 0| struct rtpp_pcount *: rtpp_pcount_smethods, \ | | | | | | | | | | | | | | | | 127| 0| struct rtpp_record *: rtpp_record_smethods, \ | | | | | | | | | | | | | | | | 128| 0| struct rtpp_hash_table *: rtpp_hash_table_smethods, \ | | | | | | | | | | | | | | | | 129| 0| struct rtpp_weakref *: rtpp_weakref_smethods, \ | | | | | | | | | | | | | | | | 130| 0| struct rtpp_analyzer *: rtpp_analyzer_smethods, \ | | | | | | | | | | | | | | | | 131| 0| struct rtpp_pcnt_strm *: rtpp_pcnt_strm_smethods, \ | | | | | | | | | | | | | | | | 132| 0| struct rtpp_ttl *: rtpp_ttl_smethods, \ | | | | | | | | | | | | | | | | 133| 0| struct rtpp_pipe *: rtpp_pipe_smethods, \ | | | | | | | | | | | | | | | | 134| 0| struct rtpp_ringbuf *: rtpp_ringbuf_smethods, \ | | | | | | | | | | | | | | | | 135| 0| struct rtpp_sessinfo *: rtpp_sessinfo_smethods, \ | | | | | | | | | | | | | | | | 136| 0| struct rtpp_rw_lock *: rtpp_rw_lock_smethods, \ | | | | | | | | | | | | | | | | 137| 0| struct rtpp_proc_servers *: rtpp_proc_servers_smethods, \ | | | | | | | | | | | | | | | | 138| 0| struct rtpp_proc_wakeup *: rtpp_proc_wakeup_smethods, \ | | | | | | | | | | | | | | | | 139| 0| struct pproc_manager *: pproc_manager_smethods, \ | | | | | | | | | | | | | | | | 140| 0| struct rtpp_dtls_conn *: rtpp_dtls_conn_smethods, \ | | | | | | | | | | | | | | | | 141| 0| struct rtpp_bindaddrs *: rtpp_bindaddrs_smethods, \ | | | | | | | | | | | | | | | | 142| 0| struct rtpp_socket *: rtpp_socket_smethods, \ | | | | | | | | | | | | | | | | 143| 0| struct rtpp_session *: rtpp_session_smethods, \ | | | | | | | | | | | | | | | | 144| 0| struct rtpp_packetport_int *: rtpp_packetport_int_smethods, \ | | | | | | | | | | | | | | | | 145| 0| struct rtpp_refproxy *: rtpp_refproxy_smethods, \ | | | | | | | | | | | | | | | | 146| 0| struct rtpp_wref *: rtpp_wref_smethods, \ | | | | | | | | | | | | | | | | 147| 0| struct rtpc_reply *: rtpc_reply_smethods, \ | | | | | | | | | | | | | | | | 148| 0| struct rtpp_genuid *: rtpp_genuid_smethods \ | | | | | | | | | | | | | | | | 149| 0|) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define CALL_SMETHOD(obj, method, args...) GET_SMETHOD(obj, method)(obj, ## args) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 80| 0|#define _RC_REF_1(rp, method) CALL_SMETHOD(rp, method, HEREVAL) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 40| 0|#define HEREVAL ({static const struct rtpp_codeptr _here = {.fname = __FILE__, .linen = __LINE__, .funcn = __func__}; &_here;}) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 80| 0|e0: 81| | return (NULL); 82| 0|} rtpp_ringbuf.c:rtpp_ringbuf_push: 94| 344|{ 95| 344| struct rtpp_ringbuf_priv *pvt; 96| 344| void *dp; 97| | 98| 344| PUB2PVT(self, pvt); ------------------ | | 169| 344| (pvtp) = (typeof(pvtp))((char *)(pubp) - offsetof(typeof(*(pvtp)), pub)) ------------------ 99| 344| dp = (char *)pvt->elements + (pvt->el_size * pvt->c_elem); 100| 344| memcpy(dp, data, pvt->el_size); 101| 344| pvt->c_elem++; 102| 344| if (pvt->c_elem == pvt->nelements) { ------------------ | Branch (102:9): [True: 20, False: 324] ------------------ 103| 20| if (pvt->b_full == 0) { ------------------ | Branch (103:13): [True: 10, False: 10] ------------------ 104| 10| pvt->b_full = 1; 105| 10| } 106| 20| pvt->c_elem = 0; 107| 20| } 108| 344|} rtpp_ringbuf.c:rtpp_ringbuf_flush: 112| 128|{ 113| 128| struct rtpp_ringbuf_priv *pvt; 114| | 115| | PUB2PVT(self, pvt); ------------------ | | 169| 128| (pvtp) = (typeof(pvtp))((char *)(pubp) - offsetof(typeof(*(pvtp)), pub)) ------------------ 116| 128| pvt->b_full = 0; 117| 128| pvt->c_elem = 0; 118| 128|} rtpp_ringbuf.c:rtpp_ringbuf_locate: 122| 406|{ 123| 406| struct rtpp_ringbuf_priv *pvt; 124| 406| int i, last_el; 125| 406| void *dp; 126| | 127| 406| PUB2PVT(self, pvt); ------------------ | | 169| 406| (pvtp) = (typeof(pvtp))((char *)(pubp) - offsetof(typeof(*(pvtp)), pub)) ------------------ 128| 406| last_el = (pvt->b_full != 0) ? pvt->nelements : pvt->c_elem; ------------------ | Branch (128:15): [True: 182, False: 224] ------------------ 129| 2.48k| for (i = 0; i < last_el; i++) { ------------------ | Branch (129:17): [True: 2.14k, False: 344] ------------------ 130| 2.14k| dp = (char *)pvt->elements + (pvt->el_size * i); 131| 2.14k| if (memcmp(dp, data, pvt->el_size) == 0) { ------------------ | Branch (131:13): [True: 62, False: 2.08k] ------------------ 132| 62| return (i); 133| 62| } 134| 2.14k| } 135| 344| return (-1); 136| 406|}