From cb7bfdf98a7da758ffdb1a084dff856b3da0aee8 Mon Sep 17 00:00:00 2001
From: Wim Taymans <wtaymans@redhat.com>
Date: Mon, 16 Mar 2020 12:52:28 +0100
Subject: [PATCH] sprinkly SPA_LIKELY/UNLIKELY around

---
 pipewire-jack/src/pipewire-jack.c       | 121 +++++++++++-------------
 spa/include/spa/utils/hook.h            |   6 +-
 spa/plugins/alsa/alsa-pcm.c             |  44 ++++-----
 spa/plugins/audioconvert/audioconvert.c |   6 +-
 spa/plugins/audioconvert/fmt-ops-sse2.c |   2 +-
 spa/plugins/audiomixer/mix-ops-sse.c    |   4 +-
 spa/plugins/audiomixer/mixer-dsp.c      |  10 +-
 spa/plugins/support/loop.c              |  19 ++--
 src/pipewire/impl-node.c                |  33 ++++---
 src/pipewire/impl-port.c                |   2 +-
 10 files changed, 118 insertions(+), 129 deletions(-)

diff --git a/pipewire-jack/src/pipewire-jack.c b/pipewire-jack/src/pipewire-jack.c
index ae8cffc69..0bc6d3dc7 100644
--- a/pipewire-jack/src/pipewire-jack.c
+++ b/pipewire-jack/src/pipewire-jack.c
@@ -502,16 +502,16 @@ static struct object *find_link(struct client *c, uint32_t src, uint32_t dst)
 
 static struct buffer *dequeue_buffer(struct mix *mix)
 {
-        struct buffer *b;
+	struct buffer *b;
 
-        if (spa_list_is_empty(&mix->queue))
-                return NULL;
+	if (SPA_UNLIKELY(spa_list_is_empty(&mix->queue)))
+		return NULL;
 
-        b = spa_list_first(&mix->queue, struct buffer, link);
-        spa_list_remove(&b->link);
+	b = spa_list_first(&mix->queue, struct buffer, link);
+	spa_list_remove(&b->link);
 	SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT);
 
-        return b;
+	return b;
 }
 
 #if defined (__SSE__)
@@ -710,9 +710,8 @@ static void convert_to_midi(struct spa_pod_sequence **seq, uint32_t n_seq, void
 	struct spa_pod_control *c[n_seq];
 	uint32_t i;
 
-	for (i = 0; i < n_seq; i++) {
+	for (i = 0; i < n_seq; i++)
 		c[i] = spa_pod_control_first(&seq[i]->body);
-	}
 
 	while (true) {
 		struct spa_pod_control *next = NULL;
@@ -728,7 +727,7 @@ static void convert_to_midi(struct spa_pod_sequence **seq, uint32_t n_seq, void
 				next_index = i;
 			}
 		}
-		if (next == NULL)
+		if (SPA_UNLIKELY(next == NULL))
 			break;
 
 		switch(next->type) {
@@ -752,16 +751,16 @@ static void *get_buffer_output(struct client *c, struct port *p, uint32_t frames
 	p->io.status = -EPIPE;
 	p->io.buffer_id = SPA_ID_INVALID;
 
-	if ((mix = find_mix(c, p, -1)) != NULL) {
+	if (SPA_LIKELY((mix = find_mix(c, p, -1)) != NULL)) {
 		struct buffer *b;
 
-		if (mix->n_buffers == 0)
+		if (SPA_UNLIKELY(mix->n_buffers == 0))
 			goto done;
 
 		pw_log_trace(NAME" %p: port %p %d get buffer %d n_buffers:%d",
 				c, p, p->id, frames, mix->n_buffers);
 
-		if ((b = dequeue_buffer(mix)) == NULL) {
+		if (SPA_UNLIKELY((b = dequeue_buffer(mix)) == NULL)) {
 			pw_log_warn("port %p: out of buffers", p);
 			goto done;
 		}
@@ -778,7 +777,7 @@ static void *get_buffer_output(struct client *c, struct port *p, uint32_t frames
 done:
 	spa_list_for_each(mix, &p->mix, port_link) {
 		struct spa_io_buffers *mio = mix->io;
-		if (mio == NULL)
+		if (SPA_UNLIKELY(mio == NULL))
 			continue;
 		pw_log_trace(NAME" %p: port %p tee %d.%d get buffer %d io:%p",
 				c, p, p->id, mix->id, frames, mio);
@@ -794,18 +793,18 @@ static void process_tee(struct client *c, uint32_t frames)
 	spa_list_for_each(p, &c->ports[SPA_DIRECTION_OUTPUT], link) {
 		void *ptr;
 
-		if (!p->empty_out)
+		if (SPA_LIKELY(!p->empty_out))
 			continue;
 
 		switch (p->object->port.type_id) {
 		case TYPE_ID_AUDIO:
 			ptr = get_buffer_output(c, p, frames, sizeof(float));
-			if (ptr != NULL)
+			if (SPA_LIKELY(ptr != NULL))
 				memcpy(ptr, p->emptyptr, frames * sizeof(float));
 			break;
 		case TYPE_ID_MIDI:
 			ptr = get_buffer_output(c, p, MAX_BUFFER_FRAMES, 1);
-			if (ptr != NULL)
+			if (SPA_LIKELY(ptr != NULL))
 				convert_from_midi(p->emptyptr, ptr, MAX_BUFFER_FRAMES * sizeof(float));
 			break;
 		default:
@@ -892,10 +891,9 @@ static inline jack_transport_state_t position_to_jack(struct pw_node_activation
 			state = JackTransportRolling;
 		break;
 	}
-	if (d == NULL)
+	if (SPA_UNLIKELY(d == NULL))
 		return state;
 
-
 	d->unique_1++;
 	d->usecs = s->clock.nsec / SPA_NSEC_PER_USEC;
 	d->frame_rate = s->clock.rate.denom;
@@ -942,7 +940,7 @@ static inline jack_transport_state_t position_to_jack(struct pw_node_activation
 static inline void check_buffer_frames(struct client *c)
 {
 	uint32_t buffer_frames = c->position->clock.duration;
-	if (buffer_frames != c->buffer_frames) {
+	if (SPA_UNLIKELY(buffer_frames != c->buffer_frames)) {
 		pw_log_info(NAME" %p: bufferframes %d", c, buffer_frames);
 		c->buffer_frames = buffer_frames;
 		if (c->bufsize_callback)
@@ -953,7 +951,7 @@ static inline void check_buffer_frames(struct client *c)
 static inline void check_sample_rate(struct client *c)
 {
 	uint32_t sample_rate = c->position->clock.rate.denom;
-	if (sample_rate != c->sample_rate) {
+	if (SPA_UNLIKELY(sample_rate != c->sample_rate)) {
 		pw_log_info(NAME" %p: sample_rate %d", c, sample_rate);
 		c->sample_rate = sample_rate;
 		if (c->srate_callback)
@@ -971,15 +969,15 @@ static inline uint32_t cycle_run(struct client *c)
 	struct pw_node_activation *driver = c->driver_activation;
 
 	/* this is blocking if nothing ready */
-	if (read(fd, &cmd, sizeof(cmd)) != sizeof(cmd)) {
+	if (SPA_UNLIKELY(read(fd, &cmd, sizeof(cmd)) != sizeof(cmd))) {
 		pw_log_warn(NAME" %p: read failed %m", c);
 		if (errno == EWOULDBLOCK)
 			return 0;
 	}
-	if (cmd > 1)
+	if (SPA_UNLIKELY(cmd > 1))
 		pw_log_warn(NAME" %p: missed %"PRIu64" wakeups", c, cmd - 1);
 
-	if (pos == NULL) {
+	if (SPA_UNLIKELY(pos == NULL)) {
 		pw_log_error(NAME" %p: missing position", c);
 		return 0;
 	}
@@ -988,7 +986,7 @@ static inline uint32_t cycle_run(struct client *c)
 	activation->status = PW_NODE_ACTIVATION_AWAKE;
 	activation->awake_time = SPA_TIMESPEC_TO_NSEC(&ts);
 
-	if (c->first) {
+	if (SPA_UNLIKELY(c->first)) {
 		if (c->thread_init_callback)
 			c->thread_init_callback(c->thread_init_arg);
 		c->first = false;
@@ -999,14 +997,14 @@ static inline uint32_t cycle_run(struct client *c)
 
 	c->jack_state = position_to_jack(driver, &c->jack_position);
 
-	if (driver) {
-		if (activation->pending_sync) {
+	if (SPA_LIKELY(driver)) {
+		if (SPA_UNLIKELY(activation->pending_sync)) {
 			if (c->sync_callback == NULL ||
 			    c->sync_callback(c->jack_state, &c->jack_position, c->sync_arg))
 				activation->pending_sync = false;
 		}
-		if (c->xrun_count != driver->xrun_count &&
-		    c->xrun_count != 0 && c->xrun_callback)
+		if (SPA_UNLIKELY(c->xrun_count != driver->xrun_count &&
+		    c->xrun_count != 0 && c->xrun_callback))
 			c->xrun_callback(c->xrun_arg);
 		c->xrun_count = driver->xrun_count;
 	}
@@ -1022,7 +1020,7 @@ static inline uint32_t cycle_wait(struct client *c)
 	int res;
 
 	res = pw_data_loop_wait(c->loop, -1);
-	if (res <= 0) {
+	if (SPA_UNLIKELY(res <= 0)) {
 		pw_log_warn(NAME" %p: wait error %m", c);
 		return 0;
 	}
@@ -1047,7 +1045,7 @@ static inline void signal_sync(struct client *c)
 	spa_list_for_each(l, &c->target_links, target_link) {
 		struct pw_node_activation_state *state;
 
-		if (l->activation == NULL)
+		if (SPA_UNLIKELY(l->activation == NULL))
 			continue;
 
 		state = &l->activation->state[0];
@@ -1061,7 +1059,7 @@ static inline void signal_sync(struct client *c)
 
 			pw_log_trace(NAME" %p: signal %p %p", c, l, state);
 
-			if (write(l->signalfd, &cmd, sizeof(cmd)) != sizeof(cmd))
+			if (SPA_UNLIKELY(write(l->signalfd, &cmd, sizeof(cmd)) != sizeof(cmd)))
 				pw_log_warn(NAME" %p: write failed %m", c);
 		}
 	}
@@ -1072,7 +1070,7 @@ static inline void cycle_signal(struct client *c, int status)
 	struct pw_node_activation *driver = c->driver_activation;
 	struct pw_node_activation *activation = c->activation;
 
-	if (status == 0) {
+	if (SPA_LIKELY(status == 0)) {
 		if (c->timebase_callback && driver && driver->segment_owner[0] == c->node_id) {
 			if (activation->pending_new_pos ||
 			    c->jack_state == JackTransportRolling ||
@@ -1098,18 +1096,17 @@ on_rtsocket_condition(void *data, int fd, uint32_t mask)
 {
 	struct client *c = data;
 
-	if (mask & (SPA_IO_ERR | SPA_IO_HUP)) {
+	if (SPA_UNLIKELY(mask & (SPA_IO_ERR | SPA_IO_HUP))) {
 		pw_log_warn(NAME" %p: got error", c);
 		unhandle_socket(c);
 		return;
 	}
-	if (c->thread_callback) {
+	if (SPA_UNLIKELY(c->thread_callback)) {
 		if (!c->thread_entered) {
 			c->thread_entered = true;
 			c->thread_callback(c->thread_arg);
 		}
-		return;
-	} else if (mask & SPA_IO_IN) {
+	} else if (SPA_LIKELY(mask & SPA_IO_IN)) {
 		uint32_t buffer_frames;
 		int status;
 
@@ -3141,7 +3138,7 @@ static inline void *get_buffer_output_float(struct client *c, struct port *p, ja
 	void *ptr;
 
 	ptr = get_buffer_output(c, p, frames, sizeof(float));
-	if (ptr == NULL) {
+	if (SPA_UNLIKELY(ptr == NULL)) {
 		p->empty_out = true;
 		ptr = p->emptyptr;
 	} else {
@@ -3167,11 +3164,6 @@ void * jack_port_get_buffer (jack_port_t *port, jack_nframes_t frames)
 	spa_return_val_if_fail(o != NULL, NULL);
 
 	c = o->client;
-
-	if (o->type != INTERFACE_Port || o->port.port_id == SPA_ID_INVALID) {
-		pw_log_error(NAME" %p: invalid port %p", c, port);
-		return NULL;
-	}
 	p = GET_PORT(c, GET_DIRECTION(o->port.flags), o->port.port_id);
 
 	if (p->direction == SPA_DIRECTION_INPUT) {
@@ -3206,7 +3198,6 @@ void * jack_port_get_buffer (jack_port_t *port, jack_nframes_t frames)
 			break;
 		}
 	}
-
 	pw_log_trace(NAME" %p: port %p buffer %p empty:%u", c, p, ptr, p->empty_out);
 	return ptr;
 }
@@ -4019,7 +4010,7 @@ jack_nframes_t jack_frames_since_cycle_start (const jack_client_t *client)
 
 	spa_return_val_if_fail(c != NULL, 0);
 
-	if ((pos = c->position) == NULL)
+	if (SPA_UNLIKELY((pos = c->position) == NULL))
 		return 0;
 
 	clock_gettime(CLOCK_MONOTONIC, &ts);
@@ -4043,7 +4034,7 @@ jack_nframes_t jack_last_frame_time (const jack_client_t *client)
 
 	spa_return_val_if_fail(c != NULL, 0);
 
-	if ((pos = c->position) == NULL)
+	if (SPA_UNLIKELY((pos = c->position) == NULL))
 		return 0;
 
 	return pos->clock.position;
@@ -4061,7 +4052,7 @@ int jack_get_cycle_times(const jack_client_t *client,
 
 	spa_return_val_if_fail(c != NULL, -EINVAL);
 
-	if ((pos = c->position) == NULL)
+	if (SPA_UNLIKELY((pos = c->position) == NULL))
 		return -EIO;
 
 	*current_frames = pos->clock.position;
@@ -4083,7 +4074,7 @@ jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t fram
 
 	spa_return_val_if_fail(c != NULL, -EINVAL);
 
-	if ((pos = c->position) == NULL)
+	if (SPA_UNLIKELY((pos = c->position) == NULL))
 		return 0;
 
 	df = (frames - pos->clock.position) * (double)SPA_NSEC_PER_SEC / c->sample_rate;
@@ -4099,7 +4090,7 @@ jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t usec
 
 	spa_return_val_if_fail(c != NULL, -EINVAL);
 
-	if ((pos = c->position) == NULL)
+	if (SPA_UNLIKELY((pos = c->position) == NULL))
 		return 0;
 
 	du = (usecs - pos->clock.nsec/SPA_NSEC_PER_USEC) * (double)c->sample_rate / SPA_USEC_PER_SEC;
@@ -4268,7 +4259,7 @@ jack_transport_state_t jack_transport_query (const jack_client_t *client,
 
 	spa_return_val_if_fail(c != NULL, JackTransportStopped);
 
-	if ((a = c->driver_activation) != NULL)
+	if (SPA_LIKELY((a = c->driver_activation) != NULL))
 		jack_state = position_to_jack(a, pos);
 	else if (pos != NULL)
 		memset(pos, 0, sizeof(jack_position_t));
@@ -4287,7 +4278,7 @@ jack_nframes_t jack_get_current_transport_frame (const jack_client_t *client)
 
 	spa_return_val_if_fail(c != NULL, -EINVAL);
 
-	if ((a = c->driver_activation) == NULL)
+	if (SPA_UNLIKELY((a = c->driver_activation) == NULL))
 		return -EIO;
 
 	pos = &a->position;
@@ -4517,7 +4508,7 @@ void jack_set_thread_creator (jack_thread_creator_t creator)
 static inline uint8_t * midi_event_data (void* port_buffer,
                       const struct midi_event* event)
 {
-        if (event->size <= MIDI_INLINE_MAX)
+        if (SPA_LIKELY(event->size <= MIDI_INLINE_MAX))
                 return (uint8_t *)event->inline_data;
         else
                 return SPA_MEMBER(port_buffer, event->byte_offset, uint8_t);
@@ -4580,9 +4571,9 @@ size_t jack_midi_max_event_size(void* port_buffer)
                            + ((mb->event_count + 1)
                               * sizeof(struct midi_event));
 
-        if (used_size > buffer_size) {
+        if (SPA_UNLIKELY(used_size > buffer_size)) {
                 return 0;
-        } else if ((buffer_size - used_size) < MIDI_INLINE_MAX) {
+        } else if (SPA_LIKELY((buffer_size - used_size) < MIDI_INLINE_MAX)) {
                 return MIDI_INLINE_MAX;
         } else {
                 return buffer_size - used_size;
@@ -4602,21 +4593,21 @@ jack_midi_data_t* jack_midi_event_reserve(void *port_buffer,
 
 	buffer_size = mb->buffer_size;
 
-	if (time < 0 || time >= mb->nframes) {
+	if (SPA_UNLIKELY(time < 0 || time >= mb->nframes)) {
 		pw_log_warn("midi %p: time:%d frames:%d", port_buffer, time, mb->nframes);
 		goto failed;
 	}
 
-	if (mb->event_count > 0 && time < events[mb->event_count - 1].time) {
+	if (SPA_UNLIKELY(mb->event_count > 0 && time < events[mb->event_count - 1].time)) {
 		pw_log_warn("midi %p: time:%d ev:%d", port_buffer, time, mb->event_count);
 		goto failed;
 	}
 
 	/* Check if data_size is >0 and there is enough space in the buffer for the event. */
-	if (data_size <= 0) {
+	if (SPA_UNLIKELY(data_size <= 0)) {
 		pw_log_warn("midi %p: data_size:%zd", port_buffer, data_size);
 		goto failed; // return NULL?
-	} else if (jack_midi_max_event_size (port_buffer) < data_size) {
+	} else if (SPA_UNLIKELY(jack_midi_max_event_size (port_buffer) < data_size)) {
 		pw_log_warn("midi %p: event too large: data_size:%zd", port_buffer, data_size);
 		goto failed;
 	} else {
@@ -4625,7 +4616,7 @@ jack_midi_data_t* jack_midi_event_reserve(void *port_buffer,
 
 		ev->time = time;
 		ev->size = data_size;
-		if (data_size <= MIDI_INLINE_MAX) {
+		if (SPA_LIKELY(data_size <= MIDI_INLINE_MAX)) {
 			res = ev->inline_data;
 		} else {
 			mb->write_pos += data_size;
@@ -4647,12 +4638,10 @@ int jack_midi_event_write(void *port_buffer,
                       size_t data_size)
 {
 	jack_midi_data_t *retbuf = jack_midi_event_reserve (port_buffer, time, data_size);
-        if (retbuf) {
-                memcpy (retbuf, data, data_size);
-                return 0;
-        } else {
+        if (SPA_UNLIKELY(retbuf == NULL))
                 return -ENOBUFS;
-        }
+	memcpy (retbuf, data, data_size);
+	return 0;
 }
 
 SPA_EXPORT
@@ -4674,12 +4663,12 @@ int jack_get_video_image_size(jack_client_t *client, jack_image_size_t *size)
 	spa_return_val_if_fail(c != NULL, 0);
 
 	a = c->driver_activation;
-	if (a == NULL)
+	if (SPA_UNLIKELY(a == NULL))
 		a = c->activation;
-	if (a == NULL)
+	if (SPA_UNLIKELY(a == NULL))
 		return -EIO;
 
-	if (!(a->position.video.flags & SPA_IO_VIDEO_SIZE_VALID))
+	if (SPA_UNLIKELY(!(a->position.video.flags & SPA_IO_VIDEO_SIZE_VALID)))
 		return -EIO;
 
 	size->width = a->position.video.size.width;
diff --git a/spa/include/spa/utils/hook.h b/spa/include/spa/utils/hook.h
index 9c7fea475..7490644e2 100644
--- a/spa/include/spa/utils/hook.h
+++ b/spa/include/spa/utils/hook.h
@@ -133,14 +133,14 @@ spa_hook_list_join(struct spa_hook_list *list,
 #define spa_callbacks_call(callbacks,type,method,vers,...)			\
 ({										\
 	const type *_f = (const type *) (callbacks)->funcs;			\
-	if (_f && _f->version >= (vers) && _f->method)				\
+	if (SPA_LIKELY(_f && _f->version >= (vers) && _f->method))				\
 		_f->method((callbacks)->data, ## __VA_ARGS__);			\
 })
 
 #define spa_callbacks_call_res(callbacks,type,res,method,vers,...)		\
 ({										\
 	const type *_f = (const type *) (callbacks)->funcs;			\
-	if (_f && _f->version >= (vers) && _f->method)				\
+	if (SPA_LIKELY(_f && _f->version >= (vers) && _f->method))				\
 		res = _f->method((callbacks)->data, ## __VA_ARGS__);		\
 	res;									\
 })
@@ -171,7 +171,7 @@ spa_hook_list_join(struct spa_hook_list *list,
 	spa_list_cursor_start(cursor, s, link);					\
 	spa_list_for_each_cursor(ci, cursor, &list->list, link) {		\
 		const type *_f = (const type *)ci->cb.funcs;			\
-		if (_f && _f->version >= (vers) && _f->method) {		\
+		if (SPA_LIKELY(_f && _f->version >= (vers) && _f->method)) {	\
 			_f->method(ci->cb.data, ## __VA_ARGS__);		\
 			count++;						\
 			if (once)						\
diff --git a/spa/plugins/alsa/alsa-pcm.c b/spa/plugins/alsa/alsa-pcm.c
index 944fd9f11..059366e2f 100644
--- a/spa/plugins/alsa/alsa-pcm.c
+++ b/spa/plugins/alsa/alsa-pcm.c
@@ -546,7 +546,7 @@ static int alsa_recover(struct state *state, int err)
 	snd_pcm_status_t *status;
 
 	snd_pcm_status_alloca(&status);
-	if ((res = snd_pcm_status(state->hndl, status)) < 0) {
+	if (SPA_UNLIKELY((res = snd_pcm_status(state->hndl, status)) < 0)) {
 		spa_log_error(state->log, NAME" %p: snd_pcm_status error: %s",
 				state, snd_strerror(res));
 		return res;
@@ -581,7 +581,7 @@ static int alsa_recover(struct state *state, int err)
 		break;
 	}
 
-	if ((res = snd_pcm_recover(state->hndl, err, true)) < 0) {
+	if (SPA_UNLIKELY((res = snd_pcm_recover(state->hndl, err, true)) < 0)) {
 		spa_log_error(state->log, NAME" %p: snd_pcm_recover error: %s",
 				state, snd_strerror(res));
 		return res;
@@ -609,7 +609,7 @@ static int get_status(struct state *state, snd_pcm_uframes_t *delay, snd_pcm_ufr
 	snd_pcm_sframes_t avail;
 	int res;
 
-	if ((avail = snd_pcm_avail(state->hndl)) < 0) {
+	if (SPA_UNLIKELY((avail = snd_pcm_avail(state->hndl)) < 0)) {
 		if ((res = alsa_recover(state, avail)) < 0)
 			return res;
 		if ((avail = snd_pcm_avail(state->hndl)) < 0) {
@@ -659,7 +659,7 @@ static int update_time(struct state *state, uint64_t nsec, snd_pcm_sframes_t del
 	else
 		err = (target + 128) - delay;
 
-	if (state->bw == 0.0) {
+	if (SPA_UNLIKELY(state->bw == 0.0)) {
 		set_loop(state, BW_MAX);
 		state->next_time = nsec;
 		state->base_time = nsec;
@@ -670,7 +670,7 @@ static int update_time(struct state *state, uint64_t nsec, snd_pcm_sframes_t del
 
 	corr = 1.0 - (state->z2 + state->z3);
 
-	if (state->last_threshold != state->threshold) {
+	if (SPA_UNLIKELY(state->last_threshold != state->threshold)) {
 		int32_t diff = (int32_t) (state->last_threshold - state->threshold);
 		spa_log_trace(state->log, NAME" %p: follower:%d quantum change %d",
 				state, follower, diff);
@@ -678,7 +678,7 @@ static int update_time(struct state *state, uint64_t nsec, snd_pcm_sframes_t del
 		state->last_threshold = state->threshold;
 	}
 
-	if ((state->next_time - state->base_time) > BW_PERIOD) {
+	if (SPA_UNLIKELY((state->next_time - state->base_time) > BW_PERIOD)) {
 		state->base_time = state->next_time;
 		if (state->bw == BW_MAX)
 			set_loop(state, BW_MED);
@@ -701,7 +701,7 @@ static int update_time(struct state *state, uint64_t nsec, snd_pcm_sframes_t del
 
 	state->next_time += state->threshold / corr * 1e9 / state->rate;
 
-	if (!follower && state->clock) {
+	if (SPA_LIKELY(!follower && state->clock)) {
 		state->clock->nsec = nsec;
 		state->clock->position += state->duration;
 		state->clock->duration = state->duration;
@@ -724,7 +724,7 @@ int spa_alsa_write(struct state *state, snd_pcm_uframes_t silence)
 	snd_pcm_uframes_t written, frames, offset, off, to_write, total_written;
 	int res;
 
-	if (state->position && state->duration != state->position->clock.duration) {
+	if (SPA_LIKELY(state->position && state->duration != state->position->clock.duration)) {
 		state->duration = state->position->clock.duration;
 		state->threshold = (state->duration * state->rate + state->rate_denom-1) / state->rate_denom;
 	}
@@ -733,16 +733,16 @@ int spa_alsa_write(struct state *state, snd_pcm_uframes_t silence)
 		uint64_t nsec;
 		snd_pcm_uframes_t delay, target;
 
-		if ((res = get_status(state, &delay, &target)) < 0)
+		if (SPA_UNLIKELY((res = get_status(state, &delay, &target)) < 0))
 			return res;
 
-		if (!state->alsa_recovering && delay > target + state->threshold) {
+		if (SPA_UNLIKELY(!state->alsa_recovering && delay > target + state->threshold)) {
 			spa_log_warn(state->log, NAME" %p: follower delay:%ld resync %f %f %f",
 					state, delay, state->z1, state->z2, state->z3);
 			init_loop(state);
 			state->alsa_sync = true;
 		}
-		if (state->alsa_sync) {
+		if (SPA_UNLIKELY(state->alsa_sync)) {
 			if (delay > target)
 				snd_pcm_rewind(state->hndl, delay - target);
 			else
@@ -753,14 +753,14 @@ int spa_alsa_write(struct state *state, snd_pcm_uframes_t silence)
 		}
 
 		nsec = state->position->clock.nsec;
-		if ((res = update_time(state, nsec, delay, target, true)) < 0)
+		if (SPA_UNLIKELY((res = update_time(state, nsec, delay, target, true)) < 0))
 			return res;
 	}
 
 	total_written = 0;
 again:
 	frames = state->buffer_frames;
-	if ((res = snd_pcm_mmap_begin(hndl, &my_areas, &offset, &frames)) < 0) {
+	if (SPA_UNLIKELY((res = snd_pcm_mmap_begin(hndl, &my_areas, &offset, &frames)) < 0)) {
 		spa_log_error(state->log, NAME" %p: snd_pcm_mmap_begin error: %s",
 				state, snd_strerror(res));
 		return res;
@@ -801,7 +801,7 @@ again:
 		l1 = n_bytes - l0;
 
 		spa_memcpy(dst, src + offs, l0);
-		if (l1 > 0)
+		if (SPA_UNLIKELY(l1 > 0))
 			spa_memcpy(dst + l0, src, l1);
 
 		state->ready_offset += n_bytes;
@@ -825,7 +825,7 @@ again:
 			silence = 0;
 	}
 
-	if (silence > 0) {
+	if (SPA_UNLIKELY(silence > 0)) {
 		spa_log_trace_fp(state->log, NAME" %p: silence %ld", state, silence);
 		snd_pcm_areas_silence(my_areas, off, state->channels, silence, state->format);
 		written += silence;
@@ -835,7 +835,7 @@ again:
 			state, offset, written, state->sample_count);
 	total_written += written;
 
-	if ((res = snd_pcm_mmap_commit(hndl, offset, written)) < 0) {
+	if (SPA_UNLIKELY((res = snd_pcm_mmap_commit(hndl, offset, written)) < 0)) {
 		spa_log_error(state->log, NAME" %p: snd_pcm_mmap_commit error: %s",
 				state, snd_strerror(res));
 		if (res != -EPIPE && res != -ESTRPIPE)
@@ -847,7 +847,7 @@ again:
 
 	state->sample_count += total_written;
 
-	if (!state->alsa_started && total_written > 0) {
+	if (SPA_UNLIKELY(!state->alsa_started && total_written > 0)) {
 		spa_log_trace(state->log, NAME" %p: snd_pcm_start %lu", state, written);
 		if ((res = snd_pcm_start(hndl)) < 0) {
 			spa_log_error(state->log, NAME" %p: snd_pcm_start: %s",
@@ -1012,13 +1012,13 @@ static int handle_play(struct state *state, uint64_t nsec,
 {
 	int res;
 
-	if (delay > target + state->last_threshold) {
+	if (SPA_UNLIKELY(delay > target + state->last_threshold)) {
 		spa_log_trace(state->log, NAME" %p: early wakeup %ld %ld", state, delay, target);
 		state->next_time = nsec + (delay - target) * SPA_NSEC_PER_SEC / state->rate;
 		return -EAGAIN;
 	}
 
-	if ((res = update_time(state, nsec, delay, target, false)) < 0)
+	if (SPA_UNLIKELY((res = update_time(state, nsec, delay, target, false)) < 0))
 		return res;
 
 	if (spa_list_is_empty(&state->ready)) {
@@ -1076,15 +1076,15 @@ static void alsa_on_timeout_event(struct spa_source *source)
 	uint64_t expire;
 	int res;
 
-	if (state->started && spa_system_timerfd_read(state->data_system, state->timerfd, &expire) < 0)
+	if (SPA_UNLIKELY(state->started && spa_system_timerfd_read(state->data_system, state->timerfd, &expire) < 0))
 		spa_log_warn(state->log, NAME" %p: error reading timerfd: %m", state);
 
-	if (state->position) {
+	if (SPA_LIKELY(state->position)) {
 		state->duration = state->position->clock.duration;
 		state->threshold = (state->duration * state->rate + state->rate_denom-1) / state->rate_denom;
 	}
 
-	if ((res = get_status(state, &delay, &target)) < 0)
+	if (SPA_UNLIKELY((res = get_status(state, &delay, &target)) < 0))
 		return;
 
 	state->current_time = state->next_time;
diff --git a/spa/plugins/audioconvert/audioconvert.c b/spa/plugins/audioconvert/audioconvert.c
index 948c36781..21275997a 100644
--- a/spa/plugins/audioconvert/audioconvert.c
+++ b/spa/plugins/audioconvert/audioconvert.c
@@ -1074,15 +1074,15 @@ static int impl_node_process(void *object)
 			r = spa_node_process(this->nodes[i]);
 			spa_log_trace_fp(this->log, NAME " %p: process %d %d: %s",
 					this, i, r, r < 0 ? spa_strerror(r) : "ok");
-			if (r < 0)
+			if (SPA_UNLIKELY(r < 0))
 				return r;
 
 			if (r & SPA_STATUS_HAVE_DATA)
 				ready++;
 
-			if (i == 0)
+			if (SPA_UNLIKELY(i == 0))
 				res |= r & SPA_STATUS_NEED_DATA;
-			if (i == this->n_nodes-1)
+			if (SPA_UNLIKELY(i == this->n_nodes-1))
 				res |= r & SPA_STATUS_HAVE_DATA;
 		}
 		if (res & SPA_STATUS_HAVE_DATA)
diff --git a/spa/plugins/audioconvert/fmt-ops-sse2.c b/spa/plugins/audioconvert/fmt-ops-sse2.c
index 7051e2e92..18b30fd96 100644
--- a/spa/plugins/audioconvert/fmt-ops-sse2.c
+++ b/spa/plugins/audioconvert/fmt-ops-sse2.c
@@ -37,7 +37,7 @@ conv_s16_to_f32d_1s_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA
 	__m128i in;
 	__m128 out, factor = _mm_set1_ps(1.0f / S16_SCALE);
 
-	if (SPA_IS_ALIGNED(d0, 16))
+	if (SPA_LIKELY(SPA_IS_ALIGNED(d0, 16)))
 		unrolled = n_samples & ~3;
 	else
 		unrolled = 0;
diff --git a/spa/plugins/audiomixer/mix-ops-sse.c b/spa/plugins/audiomixer/mix-ops-sse.c
index 040f7f2d2..5db17605e 100644
--- a/spa/plugins/audiomixer/mix-ops-sse.c
+++ b/spa/plugins/audiomixer/mix-ops-sse.c
@@ -37,8 +37,8 @@ static inline void mix_2(float * dst, const float * SPA_RESTRICT src, uint32_t n
 	uint32_t n, unrolled;
 	__m128 in1[4], in2[4];
 
-	if (SPA_IS_ALIGNED(src, 16) &&
-	    SPA_IS_ALIGNED(dst, 16))
+	if (SPA_LIKELY(SPA_IS_ALIGNED(src, 16) &&
+	    SPA_IS_ALIGNED(dst, 16)))
 		unrolled = n_samples & ~15;
 	else
 		unrolled = 0;
diff --git a/spa/plugins/audiomixer/mixer-dsp.c b/spa/plugins/audiomixer/mixer-dsp.c
index b7d973ba1..f8aa11745 100644
--- a/spa/plugins/audiomixer/mixer-dsp.c
+++ b/spa/plugins/audiomixer/mixer-dsp.c
@@ -666,11 +666,11 @@ static int impl_node_process(void *object)
 	spa_log_trace_fp(this->log, NAME " %p: status %p %d %d",
 			this, outio, outio->status, outio->buffer_id);
 
-	if (outio->status == SPA_STATUS_HAVE_DATA)
+	if (SPA_UNLIKELY(outio->status == SPA_STATUS_HAVE_DATA))
 		return outio->status;
 
 	/* recycle */
-	if (outio->buffer_id < outport->n_buffers) {
+	if (SPA_LIKELY(outio->buffer_id < outport->n_buffers)) {
 		queue_buffer(this, outport, &outport->buffers[outio->buffer_id]);
 		outio->buffer_id = SPA_ID_INVALID;
 	}
@@ -686,10 +686,10 @@ static int impl_node_process(void *object)
 		struct spa_io_buffers *inio = NULL;
 		struct buffer *inb;
 
-		if (!inport->valid ||
+		if (SPA_UNLIKELY(!inport->valid ||
 		    (inio = inport->io) == NULL ||
 		    inio->buffer_id >= inport->n_buffers ||
-		    inio->status != SPA_STATUS_HAVE_DATA) {
+		    inio->status != SPA_STATUS_HAVE_DATA)) {
 			spa_log_trace_fp(this->log, NAME " %p: skip input idx:%d valid:%d "
 					"io:%p status:%d buf_id:%d n_buffers:%d", this,
 				i, inport->valid, inio,
@@ -711,7 +711,7 @@ static int impl_node_process(void *object)
 	}
 
 	outb = dequeue_buffer(this, outport);
-        if (outb == NULL) {
+        if (SPA_UNLIKELY(outb == NULL)) {
                 spa_log_trace(this->log, NAME " %p: out of buffers", this);
                 return -EPIPE;
         }
diff --git a/spa/plugins/support/loop.c b/spa/plugins/support/loop.c
index 29d12c391..430d594d9 100644
--- a/spa/plugins/support/loop.c
+++ b/spa/plugins/support/loop.c
@@ -297,10 +297,11 @@ static int loop_iterate(void *object, int timeout)
 	}
 	for (i = 0; i < nfds; i++) {
 		struct spa_source *s = ep[i].data;
-		if (s->rmask && s->fd != -1 && s->loop == loop)
+		if (SPA_LIKELY(s->rmask && s->fd != -1 && s->loop == loop))
 			s->func(s);
 	}
-	process_destroy(impl);
+	if (SPA_UNLIKELY(!spa_list_is_empty(&impl->destroy_list)))
+		process_destroy(impl);
 
 	return nfds;
 }
@@ -478,7 +479,7 @@ static int loop_signal_event(void *object, struct spa_source *source)
 	struct source_impl *impl = SPA_CONTAINER_OF(source, struct source_impl, source);
 	int res;
 
-	if ((res = spa_system_eventfd_write(impl->impl->system, source->fd, 1)) < 0)
+	if (SPA_UNLIKELY((res = spa_system_eventfd_write(impl->impl->system, source->fd, 1)) < 0))
 		spa_log_warn(impl->impl->log, NAME " %p: failed to write event fd %d: %s",
 				source, source->fd, spa_strerror(res));
 	return res;
@@ -490,8 +491,8 @@ static void source_timer_func(struct spa_source *source)
 	uint64_t expirations;
 	int res;
 
-	if ((res = spa_system_timerfd_read(impl->impl->system,
-				source->fd, &expirations)) < 0)
+	if (SPA_UNLIKELY((res = spa_system_timerfd_read(impl->impl->system,
+				source->fd, &expirations)) < 0))
 		spa_log_warn(impl->impl->log, NAME " %p: failed to read timer fd %d: %s",
 				source, source->fd, spa_strerror(res));
 
@@ -547,18 +548,18 @@ loop_update_timer(void *object, struct spa_source *source,
 	int flags = 0, res;
 
 	spa_zero(its);
-	if (value) {
+	if (SPA_LIKELY(value)) {
 		its.it_value = *value;
 	} else if (interval) {
 		its.it_value = *interval;
 		absolute = true;
 	}
-	if (interval)
+	if (SPA_UNLIKELY(interval))
 		its.it_interval = *interval;
-	if (absolute)
+	if (SPA_LIKELY(absolute))
 		flags |= SPA_FD_TIMER_ABSTIME;
 
-	if ((res = spa_system_timerfd_settime(impl->system, source->fd, flags, &its, NULL)) < 0)
+	if (SPA_UNLIKELY((res = spa_system_timerfd_settime(impl->system, source->fd, flags, &its, NULL)) < 0))
 		return res;
 
 	return 0;
diff --git a/src/pipewire/impl-node.c b/src/pipewire/impl-node.c
index 271e49f16..65fdd721c 100644
--- a/src/pipewire/impl-node.c
+++ b/src/pipewire/impl-node.c
@@ -814,7 +814,7 @@ static inline int resume_node(struct pw_impl_node *this, int status)
 
 static inline void calculate_stats(struct pw_impl_node *this,  struct pw_node_activation *a)
 {
-	if (a->signal_time > a->prev_signal_time) {
+	if (SPA_LIKELY(a->signal_time > a->prev_signal_time)) {
 		uint64_t process_time = a->finish_time - a->signal_time;
 		uint64_t period_time = a->signal_time - a->prev_signal_time;
 		float load = (float) process_time / (float) period_time;
@@ -854,7 +854,7 @@ static inline int process_node(void *data)
 			spa_node_process(p->mix);
 	}
 
-	if (this == this->driver_node && !this->exported) {
+	if (SPA_UNLIKELY(this == this->driver_node && !this->exported)) {
 		spa_system_clock_gettime(data_system, CLOCK_MONOTONIC, &ts);
 		a->status = PW_NODE_ACTIVATION_FINISHED;
 		a->signal_time = a->finish_time;
@@ -886,15 +886,15 @@ static void node_on_fd_events(struct spa_source *source)
 	struct pw_impl_node *this = source->data;
 	struct spa_system *data_system = this->context->data_system;
 
-	if (source->rmask & (SPA_IO_ERR | SPA_IO_HUP)) {
+	if (SPA_UNLIKELY(source->rmask & (SPA_IO_ERR | SPA_IO_HUP))) {
 		pw_log_warn(NAME" %p: got socket error %08x", this, source->rmask);
 		return;
 	}
 
-	if (source->rmask & SPA_IO_IN) {
+	if (SPA_LIKELY(source->rmask & SPA_IO_IN)) {
 		uint64_t cmd;
 
-		if (spa_system_eventfd_read(data_system, this->source.fd, &cmd) < 0 || cmd != 1)
+		if (SPA_UNLIKELY(spa_system_eventfd_read(data_system, this->source.fd, &cmd) < 0 || cmd != 1))
 			pw_log_warn(NAME" %p: read %"PRIu64" failed %m", this, cmd);
 
 		pw_log_trace_fp(NAME" %p: got process", this);
@@ -1222,13 +1222,13 @@ static int check_updates(struct pw_impl_node *node, uint32_t *reposition_owner)
 	struct pw_node_activation *a = node->rt.activation;
 	uint32_t command;
 
-	if (a->position.offset == INT64_MIN)
+	if (SPA_UNLIKELY(a->position.offset == INT64_MIN))
 		a->position.offset = a->position.clock.position;
 
 	command = ATOMIC_XCHG(a->command, PW_NODE_ACTIVATION_COMMAND_NONE);
 	*reposition_owner = ATOMIC_XCHG(a->reposition_owner, 0);
 
-	if (command != PW_NODE_ACTIVATION_COMMAND_NONE) {
+	if (SPA_UNLIKELY(command != PW_NODE_ACTIVATION_COMMAND_NONE)) {
 		pw_log_debug(NAME" %p: update command:%u", node, command);
 		switch (command) {
 		case PW_NODE_ACTIVATION_COMMAND_STOP:
@@ -1309,13 +1309,13 @@ static int node_ready(void *data, int status)
 	pw_log_trace_fp(NAME" %p: ready driver:%d exported:%d %p status:%d", node,
 			node->driver, node->exported, driver, status);
 
-	if (node == driver) {
+	if (SPA_UNLIKELY(node == driver)) {
 		struct pw_node_activation *a = node->rt.activation;
 		int sync_type, all_ready, update_sync, target_sync;
 		uint32_t owner[2], reposition_owner;
 		uint64_t min_timeout = UINT64_MAX;
 
-		if (a->state[0].pending > 0) {
+		if (SPA_UNLIKELY(a->state[0].pending > 0)) {
 			pw_log_warn(NAME" %p: graph not finished: pending %d", node, a->state[0].pending);
 			pw_context_driver_emit_incomplete(node->context, node);
 			dump_states(node);
@@ -1335,23 +1335,23 @@ static int node_ready(void *data, int status)
 			ta->status = PW_NODE_ACTIVATION_NOT_TRIGGERED;
 			pw_node_activation_state_reset(&ta->state[0]);
 
-			if (t->node) {
+			if (SPA_LIKELY(t->node)) {
 				uint32_t id = t->node->info.id;
 
 				/* this is the node with reposition info */
-				if (id == reposition_owner)
+				if (SPA_UNLIKELY(id == reposition_owner))
 					reposition_node = t->node;
 
 				/* update extra segment info if it is the owner */
-				if (id == owner[0])
+				if (SPA_UNLIKELY(id == owner[0]))
 					a->position.segments[0].bar = ta->segment.bar;
-				if (id == owner[1])
+				if (SPA_UNLIKELY(id == owner[1]))
 					a->position.segments[0].video = ta->segment.video;
 
 				min_timeout = SPA_MIN(min_timeout, ta->sync_timeout);
 			}
 
-			if (update_sync) {
+			if (SPA_UNLIKELY(update_sync)) {
 				ta->pending_sync = target_sync;
 				ta->pending_new_pos = target_sync;
 			} else {
@@ -1361,19 +1361,18 @@ static int node_ready(void *data, int status)
 		a->prev_signal_time = a->signal_time;
 		a->sync_timeout = SPA_MIN(min_timeout, DEFAULT_SYNC_TIMEOUT);
 
-		if (reposition_node)
+		if (SPA_UNLIKELY(reposition_node))
 			do_reposition(node, reposition_node);
 
 		update_position(node, all_ready);
 	}
-	if (node->driver && !node->master)
+	if (SPA_UNLIKELY(node->driver && !node->master))
 		return 0;
 
 	if (status & SPA_STATUS_HAVE_DATA) {
 		spa_list_for_each(p, &node->rt.output_mix, rt.node_link)
 			spa_node_process(p->mix);
 	}
-
 	return resume_node(node, status);
 }
 
diff --git a/src/pipewire/impl-port.c b/src/pipewire/impl-port.c
index d3d4a495f..f2215f271 100644
--- a/src/pipewire/impl-port.c
+++ b/src/pipewire/impl-port.c
@@ -153,7 +153,7 @@ static int schedule_mix_input(void *object)
 	struct spa_io_buffers *io = &this->rt.io;
 	struct pw_impl_port_mix *mix;
 
-	if (PW_IMPL_PORT_IS_CONTROL(this))
+	if (SPA_UNLIKELY(PW_IMPL_PORT_IS_CONTROL(this)))
 		return SPA_STATUS_HAVE_DATA | SPA_STATUS_NEED_DATA;
 
 	spa_list_for_each(mix, &this->rt.mix_list, rt_link) {