MT#55283 convert ssrc to int64_t

Change-Id: Ibdf18621fa6c2015ab7f4d6a68e27938f0cbe120

daemon/call.c

@@ -4193,18 +4193,18 @@ void call_destroy(call_t *c) {
 
 				ilog(LOG_INFO, "--- SSRC %s%" PRIx32 "%s", FMT_M(se->h.ssrc));
 				ilog(LOG_INFO, "------ Average MOS %" PRIu64 ".%" PRIu64 ", "
-						"lowest MOS %" PRIu64 ".%" PRIu64 " (at %u:%02u), "
-						"highest MOS %" PRIu64 ".%" PRIu64 " (at %u:%02u) lost:%u",
+						"lowest MOS %" PRIu64 ".%" PRIu64 " (at %" PRId64 ":%02" PRId64 "), "
+						"highest MOS %" PRIu64 ".%" PRIu64 " (at %" PRId64 ":%02" PRId64 ") lost:%u",
 					se->average_mos.mos / mos_samples / 10,
 					se->average_mos.mos / mos_samples % 10,
 					se->lowest_mos->mos / 10,
 					se->lowest_mos->mos % 10,
-					(unsigned int) (timeval_diff(se->lowest_mos->reported, c->created) / 1000000) / 60,
-					(unsigned int) (timeval_diff(se->lowest_mos->reported, c->created) / 1000000) % 60,
+					((se->lowest_mos->reported - timeval_us(c->created)) / 1000000) / 60,
+					((se->lowest_mos->reported - timeval_us(c->created)) / 1000000) % 60,
 					se->highest_mos->mos / 10,
 					se->highest_mos->mos % 10,
-					(unsigned int) (timeval_diff(se->highest_mos->reported, c->created) / 1000000) / 60,
-					(unsigned int) (timeval_diff(se->highest_mos->reported, c->created) / 1000000) % 60,
+					((se->highest_mos->reported - timeval_us(c->created)) / 1000000) / 60,
+					((se->highest_mos->reported - timeval_us(c->created)) / 1000000) % 60,
 					(unsigned int) se->packets_lost);
 				ilog(LOG_INFO, "------ respective (avg/min/max) jitter %" PRIu64 "/%" PRIu64 "/%" PRIu64 " ms, "
 						"RTT-e2e %" PRIu64 ".%" PRIu64 "/%" PRIu64 ".%" PRIu64

daemon/call_interfaces.c

@@ -3013,7 +3013,7 @@ static void ng_stats_ssrc_mos_entry(const ng_parser_t *parser, parser_arg subent
 		struct ssrc_stats_block *sb)
 {
 	ng_stats_ssrc_mos_entry_common(parser, subent, sb, 1);
-	parser->dict_add_int(subent, "reported at", sb->reported.tv_sec);
+	parser->dict_add_int(subent, "reported at", sb->reported / 1000000);
 }
 static void ng_stats_ssrc_mos_entry_dict(const ng_parser_t *parser, parser_arg ent, const char *label,
 		struct ssrc_stats_block *sb)
@@ -3054,17 +3054,17 @@ static void ng_stats_ssrc(const ng_parser_t *parser, parser_arg dict, const stru
 		// aim for about 10 entries to the list
 		GList *listent = se->stats_blocks.head;
 		struct ssrc_stats_block *sb = listent->data;
-		int interval
-			= ((struct ssrc_stats_block *) se->stats_blocks.tail->data)->reported.tv_sec
-			- sb->reported.tv_sec;
+		int64_t interval
+			= ((struct ssrc_stats_block *) se->stats_blocks.tail->data)->reported
+			- sb->reported;
 		interval /= 10;
-		parser->dict_add_int(progdict, "interval", interval);
-		time_t next_step = sb->reported.tv_sec;
+		parser->dict_add_int(progdict, "interval", interval / 1000000);
+		int64_t next_step = sb->reported;
 		parser_arg entlist = parser->dict_add_list(progdict, "entries");
 
 		for (; listent; listent = listent->next) {
 			sb = listent->data;
-			if (sb->reported.tv_sec < next_step)
+			if (sb->reported < next_step)
 				continue;
 			next_step += interval;
 			parser_arg cent = parser->list_add_dict(entlist);

daemon/media_player.c

@@ -312,8 +312,8 @@ static void send_timer_rtcp(struct send_timer *st, struct ssrc_ctx *ssrc_out) {
 
 	rtcp_send_report(media, ssrc_out);
 
-	ssrc_out->next_rtcp = timeval_from_us(rtpe_now);
-	ssrc_out->next_rtcp = timeval_add_usec(ssrc_out->next_rtcp, 5000000 + (ssl_random() % 2000000));
+	ssrc_out->next_rtcp = rtpe_now;
+	ssrc_out->next_rtcp += 5000000 + (ssl_random() % 2000000);
 }
 
 struct async_send_req {
@@ -404,9 +404,9 @@ static void __send_timer_send_common(struct send_timer *st, struct codec_packet
 
 	// do we send RTCP?
 	struct ssrc_ctx *ssrc_out = cp->ssrc_out;
-	if (ssrc_out && ssrc_out->next_rtcp.tv_sec) {
+	if (ssrc_out && ssrc_out->next_rtcp) {
 		mutex_lock(&ssrc_out->parent->h.lock);
-		int64_t diff = timeval_diff(ssrc_out->next_rtcp, timeval_from_us(rtpe_now));
+		int64_t diff = ssrc_out->next_rtcp - rtpe_now;
 		mutex_unlock(&ssrc_out->parent->h.lock);
 		if (diff < 0)
 			send_timer_rtcp(st, ssrc_out);
@@ -1144,7 +1144,7 @@ void media_player_set_media(struct media_player *mp, struct call_media *media) {
 	}
 	if (!mp->ssrc_out || mp->ssrc_out->parent->h.ssrc != mp->ssrc) {
 		struct ssrc_ctx *ssrc_ctx = get_ssrc_ctx(mp->ssrc, &media->ssrc_hash, SSRC_DIR_OUTPUT);
-		ssrc_ctx->next_rtcp = timeval_from_us(rtpe_now);
+		ssrc_ctx->next_rtcp = rtpe_now;
 		mp->ssrc_out = ssrc_ctx;
 	}
 }

daemon/rtcp.c

@@ -1266,19 +1266,19 @@ static void logging_destroy(struct rtcp_process_ctx *ctx) {
 
 
 static void mos_sr(struct rtcp_process_ctx *ctx, struct sender_report_packet *sr) {
-	ssrc_sender_report(ctx->mp->media, &ctx->scratch.sr, timeval_from_us(ctx->mp->tv));
+	ssrc_sender_report(ctx->mp->media, &ctx->scratch.sr, ctx->mp->tv);
 }
 static void mos_rr(struct rtcp_process_ctx *ctx, struct report_block *rr) {
-	ssrc_receiver_report(ctx->mp->media, ctx->mp->sfd, &ctx->scratch.rr, timeval_from_us(ctx->mp->tv));
+	ssrc_receiver_report(ctx->mp->media, ctx->mp->sfd, &ctx->scratch.rr, ctx->mp->tv);
 }
 static void mos_xr_rr_time(struct rtcp_process_ctx *ctx, const struct xr_rb_rr_time *rr) {
-	ssrc_receiver_rr_time(ctx->mp->media, &ctx->scratch.xr_rr, timeval_from_us(ctx->mp->tv));
+	ssrc_receiver_rr_time(ctx->mp->media, &ctx->scratch.xr_rr, ctx->mp->tv);
 }
 static void mos_xr_dlrr(struct rtcp_process_ctx *ctx, const struct xr_rb_dlrr *dlrr) {
-	ssrc_receiver_dlrr(ctx->mp->media, &ctx->scratch.xr_dlrr, timeval_from_us(ctx->mp->tv));
+	ssrc_receiver_dlrr(ctx->mp->media, &ctx->scratch.xr_dlrr, ctx->mp->tv);
 }
 static void mos_xr_voip_metrics(struct rtcp_process_ctx *ctx, const struct xr_rb_voip_metrics *rb_voip_mtc) {
-	ssrc_voip_metrics(ctx->mp->media, &ctx->scratch.xr_vm, timeval_from_us(ctx->mp->tv));
+	ssrc_voip_metrics(ctx->mp->media, &ctx->scratch.xr_vm, ctx->mp->tv);
 }
 
 
@@ -1450,12 +1450,12 @@ static GString *rtcp_sender_report(struct ssrc_sender_report *ssr,
 
 			// last received SR?
 			struct ssrc_entry_call *se = s->parent;
-			long long tv_diff = 0;
+			int64_t tv_diff = 0;
 			uint32_t ntp_middle_bits = 0;
 			mutex_lock(&se->h.lock);
 			if (se->sender_reports.length) {
 				struct ssrc_time_item *si = se->sender_reports.tail->data;
-				tv_diff = timeval_diff(timeval_from_us(rtpe_now), si->received);
+				tv_diff = rtpe_now - si->received;
 				ntp_middle_bits = si->ntp_middle_bits;
 			}
 			uint32_t jitter = se->jitter;
@@ -1609,10 +1609,10 @@ void rtcp_send_report(struct call_media *media, struct ssrc_ctx *ssrc_out) {
 		struct packet_stream *sink = sh->sink;
 		struct call_media *other_media = sink->media;
 
-		ssrc_sender_report(other_media, &ssr, timeval_from_us(rtpe_now));
+		ssrc_sender_report(other_media, &ssr, rtpe_now);
 		for (GList *k = srrs.head; k; k = k->next) {
 			struct ssrc_receiver_report *srr = k->data;
-			ssrc_receiver_report(other_media, sink->selected_sfd, srr, timeval_from_us(rtpe_now));
+			ssrc_receiver_report(other_media, sink->selected_sfd, srr, rtpe_now);
 		}
 	}
 	while (srrs.length) {

daemon/ssrc.c

@@ -308,7 +308,7 @@ struct ssrc_ctx *get_ssrc_ctx(uint32_t ssrc, struct ssrc_hash *ht, enum ssrc_dir
 
 
 static void *__do_time_report_item(struct call_media *m, size_t struct_size, size_t reports_queue_offset,
-		const struct timeval tv, uint32_t ssrc, uint32_t ntp_msw, uint32_t ntp_lsw,
+		int64_t tv, uint32_t ssrc, uint32_t ntp_msw, uint32_t ntp_lsw,
 		GDestroyNotify free_func, struct ssrc_entry **e_p)
 {
 	struct ssrc_entry *e;
@@ -398,7 +398,7 @@ static int64_t __calc_rtt(struct call_media *m, struct crtt_args a)
 
 found:;
 	// `e` remains locked for access to `sti`
-	int64_t rtt = timeval_diff(a.tv, sti->received);
+	int64_t rtt = a.tv - sti->received;
 
 	mutex_unlock(&e->h.lock);
 
@@ -418,7 +418,7 @@ found:;
 }
 
 void ssrc_sender_report(struct call_media *m, const struct ssrc_sender_report *sr,
-		const struct timeval tv)
+		int64_t tv)
 {
 	struct ssrc_entry *e;
 	struct ssrc_sender_report_item *seri = __do_time_report_item(m, sizeof(*seri),
@@ -437,7 +437,7 @@ void ssrc_sender_report(struct call_media *m, const struct ssrc_sender_report *s
 	obj_put(e);
 }
 void ssrc_receiver_report(struct call_media *m, stream_fd *sfd, const struct ssrc_receiver_report *rr,
-		const struct timeval tv)
+		int64_t tv)
 {
 	ilog(LOG_DEBUG, "RR from %s%x%s about %s%x%s: FL %u TL %u HSR %u J %u LSR %u DLSR %u",
 			FMT_M(rr->from), FMT_M(rr->ssrc), rr->fraction_lost, rr->packets_lost,
@@ -515,7 +515,7 @@ void ssrc_receiver_report(struct call_media *m, stream_fd *sfd, const struct ssr
 	// discard stats block if last has been received less than a second ago
 	if (G_LIKELY(other_e->stats_blocks.length > 0)) {
 		struct ssrc_stats_block *last_ssb = g_queue_peek_tail(&other_e->stats_blocks);
-		if (G_UNLIKELY(timeval_diff(tv, last_ssb->reported) < 1000000LL)) {
+		if (G_UNLIKELY(tv - last_ssb->reported < 1000000LL)) {
 			free_stats_block(ssb);
 			goto out_ul_oe;
 		}
@@ -552,7 +552,7 @@ out_nl:
 }
 
 void ssrc_receiver_rr_time(struct call_media *m, const struct ssrc_xr_rr_time *rr,
-		const struct timeval tv)
+		int64_t tv)
 {
 	struct ssrc_entry *e;
 	struct ssrc_rr_time_item *srti = __do_time_report_item(m, sizeof(*srti),
@@ -570,7 +570,7 @@ void ssrc_receiver_rr_time(struct call_media *m, const struct ssrc_xr_rr_time *r
 }
 
 void ssrc_receiver_dlrr(struct call_media *m, const struct ssrc_xr_dlrr *dlrr,
-		const struct timeval tv)
+		int64_t tv)
 {
 	ilog(LOG_DEBUG, "XR DLRR from %s%x%s about %s%x%s: LRR %u DLRR %u",
 			FMT_M(dlrr->from), FMT_M(dlrr->ssrc),
@@ -587,7 +587,7 @@ void ssrc_receiver_dlrr(struct call_media *m, const struct ssrc_xr_dlrr *dlrr,
 }
 
 void ssrc_voip_metrics(struct call_media *m, const struct ssrc_xr_voip_metrics *vm,
-		const struct timeval tv)
+		int64_t tv)
 {
 	ilog(LOG_DEBUG, "XR VM from %s%x%s about %s%x%s: LR %u DR %u BD %u GD %u BDu %u GDu %u RTD %u "
 			"ESD %u SL %u NL %u RERL %u GMin %u R %u eR %u MOSL %u MOSC %u RX %u "

include/ssrc.h

@@ -13,7 +13,6 @@
 #define MAX_SSRC_ENTRIES 20
 
 struct call_media;
-struct timeval;
 struct ssrc_entry;
 struct ssrc_entry_call;
 enum ssrc_dir;
@@ -61,7 +60,7 @@ struct ssrc_ctx {
 		 sample_packets_lost,
 		 sample_duplicates;
 
-	struct timeval next_rtcp; // for self-generated RTCP reports
+	int64_t next_rtcp; // for self-generated RTCP reports
 };
 
 INLINE uint64_t ssrc_timeval_to_ts(const struct timeval tv) {
@@ -73,7 +72,7 @@ INLINE struct timeval ssrc_ts_to_timeval(uint64_t ts) {
 
 
 struct ssrc_stats_block {
-	struct timeval reported;
+	int64_t reported;
 	uint64_t jitter; // ms
 	uint64_t rtt; // us - combined from both sides
 	uint32_t rtt_leg; // RTT only for the leg receiving the RTCP report
@@ -121,7 +120,7 @@ enum ssrc_dir { // these values must not be used externally
 };
 
 struct ssrc_time_item {
-	struct timeval received;
+	int64_t received;
 	uint32_t ntp_middle_bits; // to match up with lsr/dlrr
 	double ntp_ts; // XXX convert to int?
 };
@@ -196,7 +195,7 @@ struct ssrc_xr_voip_metrics {
 
 struct crtt_args {
 	struct ssrc_hash *ht;
-	const struct timeval tv;
+	int64_t tv;
 	int *pt_p;
 	uint32_t ssrc;
 	uint32_t ntp_middle_bits;
@@ -221,15 +220,11 @@ INLINE void *get_ssrc(uint32_t ssrc, struct ssrc_hash *ht) {
 struct ssrc_ctx *get_ssrc_ctx(uint32_t, struct ssrc_hash *, enum ssrc_dir); // creates new entry if not found
 
 
-void ssrc_sender_report(struct call_media *, const struct ssrc_sender_report *, const struct timeval);
-void ssrc_receiver_report(struct call_media *, stream_fd *, const struct ssrc_receiver_report *,
-		const struct timeval);
-void ssrc_receiver_rr_time(struct call_media *m, const struct ssrc_xr_rr_time *rr,
-		const struct timeval);
-void ssrc_receiver_dlrr(struct call_media *m, const struct ssrc_xr_dlrr *dlrr,
-		const struct timeval);
-void ssrc_voip_metrics(struct call_media *m, const struct ssrc_xr_voip_metrics *vm,
-		const struct timeval);
+void ssrc_sender_report(struct call_media *, const struct ssrc_sender_report *, int64_t);
+void ssrc_receiver_report(struct call_media *, stream_fd *, const struct ssrc_receiver_report *, int64_t);
+void ssrc_receiver_rr_time(struct call_media *m, const struct ssrc_xr_rr_time *rr, int64_t);
+void ssrc_receiver_dlrr(struct call_media *m, const struct ssrc_xr_dlrr *dlrr, int64_t);
+void ssrc_voip_metrics(struct call_media *m, const struct ssrc_xr_voip_metrics *vm, int64_t);
 
 
 void ssrc_collect_metrics(struct call_media *);