system/pipewire
system/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire synced 2024-10-01 13:44:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix compilation with -Werror=float-conversion

Browse source 
Better make the conversions explicit so that we don't get any surprises.

Fixes #4065
This commit is contained in:
Wim Taymans 2024-06-18 12:17:56 +02:00
parent 50870aac57
commit 1ae4374ccf
71 changed files with 286 additions and 284 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
meson.build
View file

@ -94,6 +94,7 @@ common_flags = [
'-Wdeprecated-declarations', '-Wdeprecated-declarations',
'-Wunused-result', '-Wunused-result',
'-Werror=return-type', '-Werror=return-type',
'-Werror=float-conversion',
] ]
cc_flags = common_flags + [ cc_flags = common_flags + [

22
pipewire-jack/src/pipewire-jack.c
View file

@ -1736,7 +1736,7 @@ static inline jack_transport_state_t position_to_jack(struct pw_node_activation
running = s->clock.position - s->offset; running = s->clock.position - s->offset;
if (running >= seg->start && if (running >= seg->start &&
(seg->duration == 0 || running < seg->start + seg->duration)) (seg->duration == 0 || running < seg->start + seg->duration))
d->frame = (running - seg->start) * seg->rate + seg->position; d->frame = (unsigned int)((running - seg->start) * seg->rate + seg->position);
else else
d->frame = seg->position; d->frame = seg->position;
} }
@ -1758,12 +1758,12 @@ static inline jack_transport_state_t position_to_jack(struct pw_node_activation
abs_beat = seg->bar.beat; abs_beat = seg->bar.beat;
d->bar = abs_beat / d->beats_per_bar; d->bar = (int32_t) (abs_beat / d->beats_per_bar);
beats = d->bar * d->beats_per_bar; beats = (long int) (d->bar * d->beats_per_bar);
d->bar_start_tick = beats * d->ticks_per_beat; d->bar_start_tick = beats * d->ticks_per_beat;
d->beat = abs_beat - beats; d->beat = (int32_t) (abs_beat - beats);
beats += d->beat; beats += d->beat;
d->tick = (abs_beat - beats) * d->ticks_per_beat; d->tick = (int32_t) ((abs_beat - beats) * d->ticks_per_beat);
d->bar++; d->bar++;
d->beat++; d->beat++;
} }
@ -6322,10 +6322,10 @@ void jack_port_get_latency_range (jack_port_t *port, jack_latency_callback_mode_
rate = jack_get_sample_rate((jack_client_t*)c); rate = jack_get_sample_rate((jack_client_t*)c);
info = &o->port.latency[direction]; info = &o->port.latency[direction];
range->min = (info->min_quantum * nframes) + range->min = (jack_nframes_t)((info->min_quantum * nframes) +
info->min_rate + (info->min_ns * rate) / SPA_NSEC_PER_SEC; info->min_rate + (info->min_ns * rate) / SPA_NSEC_PER_SEC);
range->max = (info->max_quantum * nframes) + range->max = (jack_nframes_t)((info->max_quantum * nframes) +
info->max_rate + (info->max_ns * rate) / SPA_NSEC_PER_SEC; info->max_rate + (info->max_ns * rate) / SPA_NSEC_PER_SEC);
pw_log_debug("%p: %s get %d latency range %d %d", c, o->port.name, pw_log_debug("%p: %s get %d latency range %d %d", c, o->port.name,
mode, range->min, range->max); mode, range->min, range->max);
@ -6688,8 +6688,8 @@ int jack_get_cycle_times(const jack_client_t *client,
*current_frames = times.frames; *current_frames = times.frames;
*next_usecs = times.next_nsec / SPA_NSEC_PER_USEC; *next_usecs = times.next_nsec / SPA_NSEC_PER_USEC;
*period_usecs = times.buffer_frames * *period_usecs = (float)(times.buffer_frames *
(float)SPA_USEC_PER_SEC / (times.sample_rate * times.rate_diff); SPA_USEC_PER_SEC / (times.sample_rate * times.rate_diff));
*current_usecs = *next_usecs - (jack_time_t)*period_usecs; *current_usecs = *next_usecs - (jack_time_t)*period_usecs;
pw_log_trace("%p: %d %"PRIu64" %"PRIu64" %f", c, *current_frames, pw_log_trace("%p: %d %"PRIu64" %"PRIu64" %f", c, *current_frames,

2
spa/include/spa/pod/builder.h
View file

@ -481,7 +481,7 @@ do { \
spa_pod_builder_long(builder, va_arg(args, int64_t)); \ spa_pod_builder_long(builder, va_arg(args, int64_t)); \
break; \ break; \
case 'f': \ case 'f': \
spa_pod_builder_float(builder, va_arg(args, double)); \ spa_pod_builder_float(builder, (float)va_arg(args, double)); \
break; \ break; \
case 'd': \ case 'd': \
spa_pod_builder_double(builder, va_arg(args, double)); \ spa_pod_builder_double(builder, va_arg(args, double)); \

8
spa/include/spa/utils/json-pod.h
View file

@ -77,17 +77,17 @@ static inline int spa_json_to_pod_part(struct spa_pod_builder *b, uint32_t flags
spa_pod_builder_bool(b, val >= 0.5f); spa_pod_builder_bool(b, val >= 0.5f);
break; break;
case SPA_TYPE_Id: case SPA_TYPE_Id:
spa_pod_builder_id(b, val); spa_pod_builder_id(b, (uint32_t)val);
break; break;
case SPA_TYPE_Int: case SPA_TYPE_Int:
spa_pod_builder_int(b, val); spa_pod_builder_int(b, (int32_t)val);
break; break;
case SPA_TYPE_Long: case SPA_TYPE_Long:
spa_pod_builder_long(b, val); spa_pod_builder_long(b, (int64_t)val);
break; break;
case SPA_TYPE_Struct: case SPA_TYPE_Struct:
if (spa_json_is_int(value, len)) if (spa_json_is_int(value, len))
spa_pod_builder_int(b, val); spa_pod_builder_int(b, (int32_t)val);
else else
spa_pod_builder_float(b, val); spa_pod_builder_float(b, val);
break; break;

6
spa/plugins/alsa/acp-tool.c
View file

@ -388,7 +388,7 @@ static int cmd_set_volume(struct data *data, const struct command *cmd, int argc
return -EINVAL; return -EINVAL;
} }
dev_id = atoi(argv[1]); dev_id = atoi(argv[1]);
vol = atof(argv[2]); vol = (float)atof(argv[2]);
if (dev_id >= card->n_devices) if (dev_id >= card->n_devices)
return -EINVAL; return -EINVAL;
@ -418,12 +418,12 @@ static int adjust_volume(struct data *data, const struct command *cmd, int argc,
static int cmd_inc_volume(struct data *data, const struct command *cmd, int argc, char *argv[]) static int cmd_inc_volume(struct data *data, const struct command *cmd, int argc, char *argv[])
{ {
return adjust_volume(data, cmd, argc, argv, 0.2); return adjust_volume(data, cmd, argc, argv, 0.2f);
} }
static int cmd_dec_volume(struct data *data, const struct command *cmd, int argc, char *argv[]) static int cmd_dec_volume(struct data *data, const struct command *cmd, int argc, char *argv[])
{ {
return adjust_volume(data, cmd, argc, argv, -0.2); return adjust_volume(data, cmd, argc, argv, -0.2f);
} }
static int cmd_get_mute(struct data *data, const struct command *cmd, int argc, char *argv[]) static int cmd_get_mute(struct data *data, const struct command *cmd, int argc, char *argv[])

4
spa/plugins/alsa/acp/acp.c
View file

@ -1335,7 +1335,7 @@ static void mixer_volume_init(pa_card *impl, pa_alsa_device *dev)
pa_log_info("Using hardware volume control. Hardware dB scale %s.", pa_log_info("Using hardware volume control. Hardware dB scale %s.",
dev->mixer_path->has_dB ? "supported" : "not supported"); dev->mixer_path->has_dB ? "supported" : "not supported");
} }
dev->device.base_volume = pa_sw_volume_to_linear(dev->base_volume); dev->device.base_volume = (float)pa_sw_volume_to_linear(dev->base_volume);
dev->device.volume_step = 1.0f / dev->n_volume_steps; dev->device.volume_step = 1.0f / dev->n_volume_steps;
if (impl->soft_mixer || !dev->mixer_path || !dev->mixer_path->has_mute) { if (impl->soft_mixer || !dev->mixer_path || !dev->mixer_path->has_mute) {
@ -2022,7 +2022,7 @@ static int get_volume(pa_cvolume *v, float *volume, uint32_t n_volume)
if (v->channels == 0) if (v->channels == 0)
return -EIO; return -EIO;
for (i = 0; i < n_volume; i++) for (i = 0; i < n_volume; i++)
volume[i] = pa_sw_volume_to_linear(v->values[i % v->channels]); volume[i] = (float)pa_sw_volume_to_linear(v->values[i % v->channels]);
return 0; return 0;
} }

2
spa/plugins/alsa/acp/alsa-mixer.c
View file

@ -1147,7 +1147,7 @@ static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_chann
int rounding; int rounding;
if (e->volume_limit >= 0 && value > (e->max_dB * 100)) if (e->volume_limit >= 0 && value > (e->max_dB * 100))
value = e->max_dB * 100; value = (long) (e->max_dB * 100);
if (e->direction == PA_ALSA_DIRECTION_OUTPUT) { if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
/* If we call set_playback_volume() without checking first /* If we call set_playback_volume() without checking first

4
spa/plugins/alsa/acp/alsa-ucm.c
View file

@ -1206,7 +1206,7 @@ static unsigned devset_playback_priority(pa_idxset *devices, bool invert) {
} }
if (priority > 0 && invert) if (priority > 0 && invert)
return 1.0 / priority; return (unsigned)(1.0 / priority);
return (unsigned) priority; return (unsigned) priority;
} }
@ -1224,7 +1224,7 @@ static unsigned devset_capture_priority(pa_idxset *devices, bool invert) {
} }
if (priority > 0 && invert) if (priority > 0 && invert)
return 1.0 / priority; return (unsigned)(1.0 / priority);
return (unsigned) priority; return (unsigned) priority;
} }

18
spa/plugins/alsa/alsa-pcm.c
View file

@ -2283,11 +2283,11 @@ int spa_alsa_update_rate_match(struct state *state)
* means that to adjust the playback rate, we need to apply the inverse * means that to adjust the playback rate, we need to apply the inverse
* of the given rate. */ * of the given rate. */
if (state->stream == SND_PCM_STREAM_CAPTURE) { if (state->stream == SND_PCM_STREAM_CAPTURE) {
pitch = 1000000 * state->rate_match->rate; pitch = (uint64_t)(1000000 * state->rate_match->rate);
last_pitch = 1000000 * state->last_rate; last_pitch = (uint64_t)(1000000 * state->last_rate);
} else { } else {
pitch = 1000000 / state->rate_match->rate; pitch = (uint64_t)(1000000 / state->rate_match->rate);
last_pitch = 1000000 / state->last_rate; last_pitch = (uint64_t)(1000000 / state->last_rate);
} }
/* The pitch adjustment is limited to 1 ppm */ /* The pitch adjustment is limited to 1 ppm */
@ -2727,7 +2727,7 @@ static int update_time(struct state *state, uint64_t current_time, snd_pcm_sfram
corr = 1.0; corr = 1.0;
if (diff < 0) if (diff < 0)
state->next_time += diff / corr * 1e9 / state->rate; state->next_time += (uint64_t)(diff / corr * 1e9 / state->rate);
if (SPA_UNLIKELY((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; state->base_time = state->next_time;
@ -2751,7 +2751,7 @@ static int update_time(struct state *state, uint64_t current_time, snd_pcm_sfram
SPA_FLAG_UPDATE(state->rate_match->flags, SPA_IO_RATE_MATCH_FLAG_ACTIVE, state->matching); SPA_FLAG_UPDATE(state->rate_match->flags, SPA_IO_RATE_MATCH_FLAG_ACTIVE, state->matching);
} }
state->next_time += state->threshold / corr * 1e9 / state->rate; state->next_time += (uint64_t)(state->threshold / corr * 1e9 / state->rate);
if (SPA_LIKELY(!follower && state->clock)) { if (SPA_LIKELY(!follower && state->clock)) {
state->clock->nsec = current_time; state->clock->nsec = current_time;
@ -2859,7 +2859,7 @@ static int alsa_write_sync(struct state *state, uint64_t current_time)
if (SPA_UNLIKELY((res = get_status(state, current_time, &avail, &delay, &target)) < 0)) { if (SPA_UNLIKELY((res = get_status(state, current_time, &avail, &delay, &target)) < 0)) {
spa_log_error(state->log, "get_status error: %s", spa_strerror(res)); spa_log_error(state->log, "get_status error: %s", spa_strerror(res));
state->next_time += state->threshold * 1e9 / state->rate; state->next_time += (uint64_t)(state->threshold * 1e9 / state->rate);
return res; return res;
} }
@ -3120,7 +3120,7 @@ static int alsa_read_sync(struct state *state, uint64_t current_time)
if (SPA_UNLIKELY((res = get_status(state, current_time, &avail, &delay, &target)) < 0)) { if (SPA_UNLIKELY((res = get_status(state, current_time, &avail, &delay, &target)) < 0)) {
spa_log_error(state->log, "get_status error: %s", spa_strerror(res)); spa_log_error(state->log, "get_status error: %s", spa_strerror(res));
state->next_time += state->threshold * 1e9 / state->rate; state->next_time += (uint64_t)(state->threshold * 1e9 / state->rate);
return res; return res;
} }
@ -3442,7 +3442,7 @@ static void alsa_timer_wakeup_event(struct spa_source *source)
state->next_time - current_time, state->threshold, state->next_time - current_time, state->threshold,
state->sample_count, suppressed); state->sample_count, suppressed);
} }
state->next_time = current_time + state->threshold * 1e9 / state->rate; state->next_time = (uint64_t)(current_time + state->threshold * 1e9 / state->rate);
} }
set_timeout(state, state->next_time); set_timeout(state, state->next_time);
} }

8
spa/plugins/alsa/alsa-seq.c
View file

@ -797,9 +797,9 @@ static int update_time(struct seq_state *state, uint64_t nsec, bool follower)
* use the rate correction, else we will use the rate correction only for the new * use the rate correction, else we will use the rate correction only for the new
* timeout. */ * timeout. */
if (state->following) if (state->following)
state->queue_next += state->threshold * corr * 1e9 / state->rate.denom; state->queue_next += (uint64_t)(state->threshold * corr * 1e9 / state->rate.denom);
else else
state->queue_next += state->threshold * 1e9 / state->rate.denom; state->queue_next += (uint64_t)(state->threshold * 1e9 / state->rate.denom);
if ((state->next_time - state->base_time) > BW_PERIOD) { if ((state->next_time - state->base_time) > BW_PERIOD) {
state->base_time = state->next_time; state->base_time = state->next_time;
@ -807,14 +807,14 @@ static int update_time(struct seq_state *state, uint64_t nsec, bool follower)
state, follower, corr, state->dll.bw, err, state, follower, corr, state->dll.bw, err,
state->dll.z1, state->dll.z2, state->dll.z3); state->dll.z1, state->dll.z2, state->dll.z3);
} }
state->next_time += state->threshold / corr * 1e9 / state->rate.denom; state->next_time += (uint64_t)(state->threshold / corr * 1e9 / state->rate.denom);
if (!follower && state->clock) { if (!follower && state->clock) {
state->clock->nsec = nsec; state->clock->nsec = nsec;
state->clock->rate = state->rate; state->clock->rate = state->rate;
state->clock->position += state->clock->duration; state->clock->position += state->clock->duration;
state->clock->duration = state->duration; state->clock->duration = state->duration;
state->clock->delay = state->duration * corr; state->clock->delay = (int64_t)(state->duration * corr);
state->clock->rate_diff = corr; state->clock->rate_diff = corr;
state->clock->next_nsec = state->next_time; state->clock->next_nsec = state->next_time;
} }

12
spa/plugins/alsa/test-timer.c
View file

@ -16,7 +16,7 @@
#define DEFAULT_DEVICE "hw:0" #define DEFAULT_DEVICE "hw:0"
#define M_PI_M2 (M_PI + M_PI) #define M_PI_M2f (M_PIf + M_PIf)
#define BW_PERIOD (SPA_NSEC_PER_SEC * 3) #define BW_PERIOD (SPA_NSEC_PER_SEC * 3)
@ -63,10 +63,10 @@ static int set_timeout(struct state *state, uint64_t time)
type *samples, v; \ type *samples, v; \
samples = (type*)((uint8_t*)areas[0].addr + (areas[0].first + offset*areas[0].step) / 8); \ samples = (type*)((uint8_t*)areas[0].addr + (areas[0].first + offset*areas[0].step) / 8); \
for (i = 0; i < frames; i++) { \ for (i = 0; i < frames; i++) { \
state->accumulator += M_PI_M2 * 440 / state->rate; \ state->accumulator += M_PI_M2f * 440.0f / state->rate; \
if (state->accumulator >= M_PI_M2) \ if (state->accumulator >= M_PI_M2f) \
state->accumulator -= M_PI_M2; \ state->accumulator -= M_PI_M2f; \
v = sin(state->accumulator) * scale; \ v = (type)(sin(state->accumulator) * scale); \
for (j = 0; j < state->channels; j++) \ for (j = 0; j < state->channels; j++) \
*samples++ = v; \ *samples++ = v; \
} \ } \
@ -135,7 +135,7 @@ static int on_timer_wakeup(struct state *state)
/* set our new adjusted timeout. alternatively, this value can /* set our new adjusted timeout. alternatively, this value can
* instead be used to drive a resampler if this device is * instead be used to drive a resampler if this device is
* slaved. */ * slaved. */
state->next_time += state->period / corr * 1e9 / state->rate; state->next_time += (uint64_t)(state->period / corr * 1e9 / state->rate);
set_timeout(state, state->next_time); set_timeout(state, state->next_time);
if (state->next_time - state->prev_time > BW_PERIOD) { if (state->next_time - state->prev_time > BW_PERIOD) {

10
spa/plugins/audioconvert/biquad.c
View file

@ -26,11 +26,11 @@ static void set_coefficient(struct biquad *bq, double b0, double b1, double b2,
double a0, double a1, double a2) double a0, double a1, double a2)
{ {
double a0_inv = 1 / a0; double a0_inv = 1 / a0;
bq->b0 = b0 * a0_inv; bq->b0 = (float)(b0 * a0_inv);
bq->b1 = b1 * a0_inv; bq->b1 = (float)(b1 * a0_inv);
bq->b2 = b2 * a0_inv; bq->b2 = (float)(b2 * a0_inv);
bq->a1 = a1 * a0_inv; bq->a1 = (float)(a1 * a0_inv);
bq->a2 = a2 * a0_inv; bq->a2 = (float)(a2 * a0_inv);
} }
static void biquad_lowpass(struct biquad *bq, double cutoff) static void biquad_lowpass(struct biquad *bq, double cutoff)

4
spa/plugins/audioconvert/channelmix-ops.c
View file

@ -649,7 +649,7 @@ done:
spa_debug_type_find_short_name(spa_type_audio_channel, j + _SH)); spa_debug_type_find_short_name(spa_type_audio_channel, j + _SH));
mix->matrix_orig[ic][jc++] = matrix[i][j]; mix->matrix_orig[ic][jc++] = matrix[i][j];
sum += fabs(matrix[i][j]); sum += fabsf(matrix[i][j]);
if (matrix[i][j] == 0.0f) if (matrix[i][j] == 0.0f)
spa_strbuf_append(&sb1, " "); spa_strbuf_append(&sb1, " ");
@ -772,7 +772,7 @@ int channelmix_init(struct channelmix *mix)
mix->process = info->process; mix->process = info->process;
mix->set_volume = impl_channelmix_set_volume; mix->set_volume = impl_channelmix_set_volume;
mix->cpu_flags = info->cpu_flags; mix->cpu_flags = info->cpu_flags;
mix->delay = mix->rear_delay * mix->freq / 1000.0f; mix->delay = (uint32_t)(mix->rear_delay * mix->freq / 1000.0f);
mix->func_name = info->name; mix->func_name = info->name;
spa_log_debug(mix->log, "selected %s delay:%d options:%08x", info->name, mix->delay, spa_log_debug(mix->log, "selected %s delay:%d options:%08x", info->name, mix->delay,

11
spa/plugins/audioconvert/fmt-ops-sse2.c
View file

@ -969,7 +969,8 @@ conv_deinterleave_32s_1s_sse2(void *data, void * SPA_RESTRICT dst[], const void
s += 4*n_channels; s += 4*n_channels;
} }
for(; n < n_samples; n++) { for(; n < n_samples; n++) {
d0[n] = bswap_32(*s); uint32_t *di = (uint32_t*)&d0[n], *si = (uint32_t*)s;
*di = bswap_32(*si);
s += n_channels; s += n_channels;
} }
} }
@ -1011,10 +1012,10 @@ conv_deinterleave_32s_4s_sse2(void *data, void * SPA_RESTRICT dst[], const void
s += 4 * n_channels; s += 4 * n_channels;
} }
for(; n < n_samples; n++) { for(; n < n_samples; n++) {
d0[n] = bswap_32(s[0]); *((uint32_t*)&d0[n]) = bswap_32(*((uint32_t*)&s[0]));
d1[n] = bswap_32(s[1]); *((uint32_t*)&d1[n]) = bswap_32(*((uint32_t*)&s[1]));
d2[n] = bswap_32(s[2]); *((uint32_t*)&d2[n]) = bswap_32(*((uint32_t*)&s[2]));
d3[n] = bswap_32(s[3]); *((uint32_t*)&d3[n]) = bswap_32(*((uint32_t*)&s[3]));
s += n_channels; s += n_channels;
} }
} }

8
spa/plugins/audioconvert/hilbert.h
View file

@ -17,9 +17,9 @@ static inline void blackman_window(float *taps, int n_taps)
{ {
int n; int n;
for (n = 0; n < n_taps; n++) { for (n = 0; n < n_taps; n++) {
float w = 2 * M_PI * n / (n_taps-1); float w = 2.0f * M_PIf * n / (n_taps-1);
taps[n] = 0.3635819 - 0.4891775 * cos(w) taps[n] = 0.3635819f - 0.4891775f * cosf(w)
+ 0.1365995 * cos(2 * w) - 0.0106411 * cos(3 * w); + 0.1365995f * cosf(2 * w) - 0.0106411f * cosf(3 * w);
} }
} }
@ -33,7 +33,7 @@ static inline int hilbert_generate(float *taps, int n_taps)
for (i = 0; i < n_taps; i++) { for (i = 0; i < n_taps; i++) {
int k = -(n_taps / 2) + i; int k = -(n_taps / 2) + i;
if (k & 1) { if (k & 1) {
float pk = M_PI * k; float pk = M_PIf * k;
taps[i] *= (1.0f - cosf(pk)) / pk; taps[i] *= (1.0f - cosf(pk)) / pk;
} else { } else {
taps[i] = 0.0f; taps[i] = 0.0f;

4
spa/plugins/audioconvert/resample-native-impl.h
View file

@ -99,7 +99,7 @@ DEFINE_RESAMPLER(full,arch) \
float *d = dst[c]; \ float *d = dst[c]; \
\ \
index = ioffs; \ index = ioffs; \
phase = data->phase; \ phase = (uint32_t)data->phase; \
\ \
for (o = ooffs; o < olen && index + n_taps <= ilen; o++) { \ for (o = ooffs; o < olen && index + n_taps <= ilen; o++) { \
inner_product_##arch(&d[o], &s[index], \ inner_product_##arch(&d[o], &s[index], \
@ -136,7 +136,7 @@ DEFINE_RESAMPLER(inter,arch) \
\ \
for (o = ooffs; o < olen && index + n_taps <= ilen; o++) { \ for (o = ooffs; o < olen && index + n_taps <= ilen; o++) { \
float ph = phase * n_phases / out_rate; \ float ph = phase * n_phases / out_rate; \
uint32_t offset = floorf(ph); \ uint32_t offset = (uint32_t)floorf(ph); \
inner_product_ip_##arch(&d[o], &s[index], \ inner_product_ip_##arch(&d[o], &s[index], \
&data->filter[(offset + 0) * stride], \ &data->filter[(offset + 0) * stride], \
&data->filter[(offset + 1) * stride], \ &data->filter[(offset + 1) * stride], \

10
spa/plugins/audioconvert/resample-native.c
View file

@ -72,8 +72,8 @@ static int build_filter(float *taps, uint32_t stride, uint32_t n_taps, uint32_t
for (j = 0; j < n_taps12; j++, t += 1.0) { for (j = 0; j < n_taps12; j++, t += 1.0) {
/* exploit symmetry in filter taps */ /* exploit symmetry in filter taps */
taps[(n_phases - i) * stride + n_taps12 + j] = taps[(n_phases - i) * stride + n_taps12 + j] =
taps[i * stride + (n_taps12 - j - 1)] = taps[i * stride + (n_taps12 - j - 1)] = (float)
cutoff * sinc(t * cutoff) * window(t, n_taps); (cutoff * sinc(t * cutoff) * window(t, n_taps));
} }
} }
return 0; return 0;
@ -141,7 +141,7 @@ static void impl_native_update_rate(struct resample *r, double rate)
return; return;
old_out_rate = data->out_rate; old_out_rate = data->out_rate;
in_rate = r->i_rate / rate; in_rate = (uint32_t)(r->i_rate / rate);
out_rate = r->o_rate; out_rate = r->o_rate;
phase = data->phase; phase = data->phase;
@ -180,7 +180,7 @@ static uint32_t impl_native_in_len(struct resample *r, uint32_t out_len)
struct native_data *data = r->data; struct native_data *data = r->data;
uint32_t in_len; uint32_t in_len;
in_len = (data->phase + out_len * data->frac) / data->out_rate; in_len = (uint32_t)((data->phase + out_len * data->frac) / data->out_rate);
in_len += out_len * data->inc + (data->n_taps - data->hist); in_len += out_len * data->inc + (data->n_taps - data->hist);
spa_log_trace_fp(r->log, "native %p: hist:%d %d->%d", r, data->hist, out_len, in_len); spa_log_trace_fp(r->log, "native %p: hist:%d %d->%d", r, data->hist, out_len, in_len);
@ -194,7 +194,7 @@ static uint32_t impl_native_out_len(struct resample *r, uint32_t in_len)
uint32_t out_len; uint32_t out_len;
in_len = in_len - SPA_MIN(in_len, (data->n_taps - data->hist) + 1); in_len = in_len - SPA_MIN(in_len, (data->n_taps - data->hist) + 1);
out_len = in_len * data->out_rate - data->phase; out_len = (uint32_t)(in_len * data->out_rate - data->phase);
out_len = (out_len + data->in_rate - 1) / data->in_rate; out_len = (out_len + data->in_rate - 1) / data->in_rate;
spa_log_trace_fp(r->log, "native %p: hist:%d %d->%d", r, data->hist, in_len, out_len); spa_log_trace_fp(r->log, "native %p: hist:%d %d->%d", r, data->hist, in_len, out_len);

12
spa/plugins/audioconvert/test-channelmix.c
View file

@ -18,14 +18,14 @@ static uint32_t cpu_flags;
SPA_LOG_IMPL(logger); SPA_LOG_IMPL(logger);
#define MATRIX(...) (float[]) { __VA_ARGS__ } #define MATRIX(...) (double[]) { __VA_ARGS__ }
#include "test-helper.h" #include "test-helper.h"
#include "channelmix-ops.c" #include "channelmix-ops.c"
#define CLOSE_ENOUGH(a,b) (fabs((a)-(b)) < 0.000001f) #define CLOSE_ENOUGH(a,b) (fabs((a)-(b)) < 0.000001f)
static void dump_matrix(struct channelmix *mix, float *coeff) static void dump_matrix(struct channelmix *mix, double *coeff)
{ {
uint32_t i, j; uint32_t i, j;
@ -33,13 +33,13 @@ static void dump_matrix(struct channelmix *mix, float *coeff)
for (j = 0; j < mix->src_chan; j++) { for (j = 0; j < mix->src_chan; j++) {
float v = mix->matrix[i][j]; float v = mix->matrix[i][j];
spa_log_debug(mix->log, "%d %d: %f <-> %f", i, j, v, *coeff); spa_log_debug(mix->log, "%d %d: %f <-> %f", i, j, v, *coeff);
spa_assert_se(CLOSE_ENOUGH(v, *coeff)); spa_assert_se(CLOSE_ENOUGH(v, (float)*coeff));
coeff++; coeff++;
} }
} }
} }
static void test_mix(uint32_t src_chan, uint32_t src_mask, uint32_t dst_chan, uint32_t dst_mask, uint32_t options, float *coeff) static void test_mix(uint32_t src_chan, uint32_t src_mask, uint32_t dst_chan, uint32_t dst_mask, uint32_t options, double *coeff)
{ {
struct channelmix mix; struct channelmix mix;
@ -336,7 +336,7 @@ static void test_n_m_impl(void)
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
for (j = 0; j < N_SAMPLES; j++) for (j = 0; j < N_SAMPLES; j++)
src_data[i][j] = (drand48() - 0.5f) * 2.5f; src_data[i][j] = (float)((drand48() - 0.5f) * 2.5f);
src[i] = src_data[i]; src[i] = src_data[i];
} }
@ -360,7 +360,7 @@ static void test_n_m_impl(void)
/* random matrix */ /* random matrix */
for (i = 0; i < mix.dst_chan; i++) { for (i = 0; i < mix.dst_chan; i++) {
for (j = 0; j < mix.src_chan; j++) { for (j = 0; j < mix.src_chan; j++) {
mix.matrix_orig[i][j] = drand48() - 0.5f; mix.matrix_orig[i][j] = (float)(drand48() - 0.5f);
} }
} }
channelmix_set_volume(&mix, 1.0f, false, 0, NULL); channelmix_set_volume(&mix, 1.0f, false, 0, NULL);

2
spa/plugins/audioconvert/test-fmt-ops.c
View file

@ -321,7 +321,7 @@ static void test_f32_s32(void)
static void test_s32_f32(void) static void test_s32_f32(void)
{ {
static const int32_t in[] = { 0, 0x7fffff00, 0x80000000, 0x40000000, 0xc0000000 }; static const int32_t in[] = { 0, 0x7fffff00, 0x80000000, 0x40000000, 0xc0000000 };
static const float out[] = { 0.0f, 0.999999880791, -1.0f, 0.5, -0.5, }; static const float out[] = { 0.0f, 0.999999880791f, -1.0f, 0.5, -0.5, };
run_test("test_s32_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out), run_test("test_s32_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_s32_to_f32d_c); true, false, conv_s32_to_f32d_c);

2
spa/plugins/audioconvert/test-peaks.c
View file

@ -30,7 +30,7 @@ static void test_impl(void)
float min[2] = { 0.0f, 0.0f }, max[2] = { 0.0f, 0.0f }, absmax[2] = { 0.0f, 0.0f }; float min[2] = { 0.0f, 0.0f }, max[2] = { 0.0f, 0.0f }, absmax[2] = { 0.0f, 0.0f };
for (i = 0; i < SPA_N_ELEMENTS(vals); i++) for (i = 0; i < SPA_N_ELEMENTS(vals); i++)
vals[i] = (drand48() - 0.5f) * 2.5f; vals[i] = (float)((drand48() - 0.5f) * 2.5f);
peaks_min_max_c(&peaks, &vals[1], SPA_N_ELEMENTS(vals) - 1, &min[0], &max[0]); peaks_min_max_c(&peaks, &vals[1], SPA_N_ELEMENTS(vals) - 1, &min[0], &max[0]);
printf("c peaks min:%f max:%f\n", min[0], max[0]); printf("c peaks min:%f max:%f\n", min[0], max[0]);

16
spa/plugins/audiotestsrc/render.c
View file

@ -4,7 +4,7 @@
#include <math.h> #include <math.h>
#define M_PI_M2 ( M_PI + M_PI ) #define M_PI_M2f ( M_PIf + M_PIf )
#define DEFINE_SINE(type,scale) \ #define DEFINE_SINE(type,scale) \
static void \ static void \
@ -17,24 +17,24 @@ audio_test_src_create_sine_##type (struct impl *this, type *samples, size_t n_sa
float volume = this->props.volume; \ float volume = this->props.volume; \
\ \
channels = this->port.current_format.info.raw.channels; \ channels = this->port.current_format.info.raw.channels; \
step = M_PI_M2 * freq / this->port.current_format.info.raw.rate; \ step = M_PI_M2f * freq / this->port.current_format.info.raw.rate; \
amp = volume * scale; \ amp = volume * scale; \
\ \
for (i = 0; i < n_samples; i++) { \ for (i = 0; i < n_samples; i++) { \
type val; \ type val; \
this->port.accumulator += step; \ this->port.accumulator += step; \
if (this->port.accumulator >= M_PI_M2) \ if (this->port.accumulator >= M_PI_M2f) \
this->port.accumulator -= M_PI_M2; \ this->port.accumulator -= M_PI_M2f; \
val = (type) (sin (this->port.accumulator) * amp); \ val = (type) (sin (this->port.accumulator) * amp); \
for (c = 0; c < channels; ++c) \ for (c = 0; c < channels; ++c) \
*samples++ = val; \ *samples++ = val; \
} \ } \
} }
DEFINE_SINE(int16_t, 32767.0); DEFINE_SINE(int16_t, 32767.0f);
DEFINE_SINE(int32_t, 2147483647.0); DEFINE_SINE(int32_t, 2147483647.0f);
DEFINE_SINE(float, 1.0); DEFINE_SINE(float, 1.0f);
DEFINE_SINE(double, 1.0); DEFINE_SINE(double, 1.0f);
static const render_func_t sine_funcs[] = { static const render_func_t sine_funcs[] = {
(render_func_t) audio_test_src_create_sine_int16_t, (render_func_t) audio_test_src_create_sine_int16_t,

4
spa/plugins/bluez5/backend-native.c
View file

@ -246,7 +246,7 @@ static int rfcomm_new_transport(struct rfcomm *rfcomm)
t->volumes[i].active = rfcomm->volumes[i].active; t->volumes[i].active = rfcomm->volumes[i].active;
t->volumes[i].hw_volume_max = SPA_BT_VOLUME_HS_MAX; t->volumes[i].hw_volume_max = SPA_BT_VOLUME_HS_MAX;
if (rfcomm->volumes[i].active && rfcomm->volumes[i].hw_volume != SPA_BT_VOLUME_INVALID) if (rfcomm->volumes[i].active && rfcomm->volumes[i].hw_volume != SPA_BT_VOLUME_INVALID)
t->volumes[i].volume = t->volumes[i].volume = (float)
spa_bt_volume_hw_to_linear(rfcomm->volumes[i].hw_volume, t->volumes[i].hw_volume_max); spa_bt_volume_hw_to_linear(rfcomm->volumes[i].hw_volume, t->volumes[i].hw_volume_max);
} }
@ -424,7 +424,7 @@ static void rfcomm_emit_volume_changed(struct rfcomm *rfcomm, int id, int hw_vol
for (int i = 0; i < SPA_BT_VOLUME_ID_TERM ; ++i) { for (int i = 0; i < SPA_BT_VOLUME_ID_TERM ; ++i) {
t_volume = &rfcomm->transport->volumes[i]; t_volume = &rfcomm->transport->volumes[i];
t_volume->active = rfcomm->volumes[i].active; t_volume->active = rfcomm->volumes[i].active;
t_volume->volume = t_volume->volume = (float)
spa_bt_volume_hw_to_linear(rfcomm->volumes[i].hw_volume, t_volume->hw_volume_max); spa_bt_volume_hw_to_linear(rfcomm->volumes[i].hw_volume, t_volume->hw_volume_max);
} }

2
spa/plugins/bluez5/bluez5-dbus.c
View file

@ -3172,7 +3172,7 @@ static void spa_bt_transport_volume_changed(struct spa_bt_transport *transport)
if (t_volume->hw_volume != t_volume->new_hw_volume) { if (t_volume->hw_volume != t_volume->new_hw_volume) {
t_volume->hw_volume = t_volume->new_hw_volume; t_volume->hw_volume = t_volume->new_hw_volume;
t_volume->volume = spa_bt_volume_hw_to_linear(t_volume->hw_volume, t_volume->volume = (float)spa_bt_volume_hw_to_linear(t_volume->hw_volume,
t_volume->hw_volume_max); t_volume->hw_volume_max);
spa_log_debug(monitor->log, "transport %p: volume changed %d(%f) ", spa_log_debug(monitor->log, "transport %p: volume changed %d(%f) ",
transport, t_volume->new_hw_volume, t_volume->volume); transport, t_volume->new_hw_volume, t_volume->volume);

2
spa/plugins/bluez5/bluez5-device.c
View file

@ -581,7 +581,7 @@ static void emit_device_set_node(struct impl *this, uint32_t id)
for (i = 0; i < node->n_channels; ++i) { for (i = 0; i < node->n_channels; ++i) {
/* Session manager will override this, so put in some safe number */ /* Session manager will override this, so put in some safe number */
node->volumes[i] = node->soft_volumes[i] = 0.064; node->volumes[i] = node->soft_volumes[i] = 0.064f;
} }
/* Produce member info json */ /* Produce member info json */

2
spa/plugins/bluez5/decode-buffer.h
View file

@ -253,7 +253,7 @@ static void spa_bt_decode_buffer_process(struct spa_bt_decode_buffer *this, uint
level = SPA_MAX(level, -max_level); level = SPA_MAX(level, -max_level);
this->prev_consumed = SPA_MIN(this->prev_consumed, avg_period); this->prev_consumed = SPA_MIN(this->prev_consumed, avg_period);
spa_bt_ptp_update(&this->spike, this->ctl.avg - level, this->prev_consumed); spa_bt_ptp_update(&this->spike, (int32_t)(this->ctl.avg - level), this->prev_consumed);
/* Update target level */ /* Update target level */
if (this->target) if (this->target)

6
spa/plugins/bluez5/media-sink.c
View file

@ -1045,7 +1045,7 @@ static void media_iso_pull(struct spa_bt_iso_io *iso_io)
max_err = iso_io->duration; max_err = iso_io->duration;
if (iso_io->resync && err >= 0) { if (iso_io->resync && err >= 0) {
unsigned int req = err * port->current_format.info.raw.rate / SPA_NSEC_PER_SEC; unsigned int req = (unsigned int)(err * port->current_format.info.raw.rate / SPA_NSEC_PER_SEC);
if (req > 0) { if (req > 0) {
spa_bt_rate_control_init(&port->ratectl, 0); spa_bt_rate_control_init(&port->ratectl, 0);
@ -1053,7 +1053,7 @@ static void media_iso_pull(struct spa_bt_iso_io *iso_io)
} }
spa_log_debug(this->log, "%p: ISO sync skip frames:%u", this, req); spa_log_debug(this->log, "%p: ISO sync skip frames:%u", this, req);
} else if (iso_io->resync && -err >= 0) { } else if (iso_io->resync && -err >= 0) {
unsigned int req = -err * port->current_format.info.raw.rate / SPA_NSEC_PER_SEC; unsigned int req = (unsigned int)(-err * port->current_format.info.raw.rate / SPA_NSEC_PER_SEC);
static const uint8_t empty[8192] = {0}; static const uint8_t empty[8192] = {0};
if (req > 0) { if (req > 0) {
@ -1172,7 +1172,7 @@ static void media_on_timeout(struct spa_source *source)
setup_matching(this); setup_matching(this);
this->next_time = now_time + duration * SPA_NSEC_PER_SEC / rate * port->ratectl.corr; this->next_time = (uint64_t)(now_time + duration * SPA_NSEC_PER_SEC / rate * port->ratectl.corr);
if (SPA_LIKELY(this->clock)) { if (SPA_LIKELY(this->clock)) {
this->clock->nsec = now_time; this->clock->nsec = now_time;

2
spa/plugins/bluez5/media-source.c
View file

@ -620,7 +620,7 @@ static void media_on_timeout(struct spa_source *source)
setup_matching(this); setup_matching(this);
this->next_time = now_time + duration * SPA_NSEC_PER_SEC / port->buffer.corr / rate; this->next_time = (uint64_t)(now_time + duration * SPA_NSEC_PER_SEC / port->buffer.corr / rate);
if (SPA_LIKELY(this->clock)) { if (SPA_LIKELY(this->clock)) {
this->clock->nsec = now_time; this->clock->nsec = now_time;

2
spa/plugins/bluez5/midi-node.c
View file

@ -598,7 +598,7 @@ again:
-SPA_CLAMP(err_nsec, -20*SPA_NSEC_PER_MSEC, 20*SPA_NSEC_PER_MSEC) -SPA_CLAMP(err_nsec, -20*SPA_NSEC_PER_MSEC, 20*SPA_NSEC_PER_MSEC)
* this->rate / SPA_NSEC_PER_SEC); * this->rate / SPA_NSEC_PER_SEC);
tcorr = SPA_MIN(device_elapsed, SPA_NSEC_PER_SEC) * (corr - 1); tcorr = SPA_MIN(device_elapsed, SPA_NSEC_PER_SEC) * (corr - 1);
sync->device_time += tcorr; sync->device_time += (uint64_t)tcorr;
/* reset if too much off */ /* reset if too much off */
if (err_nsec < -50 * SPA_NSEC_PER_MSEC || if (err_nsec < -50 * SPA_NSEC_PER_MSEC ||

2
spa/plugins/bluez5/sco-source.c
View file

@ -667,7 +667,7 @@ static void sco_on_timeout(struct spa_source *source)
setup_matching(this); setup_matching(this);
this->next_time = now_time + duration * SPA_NSEC_PER_SEC / port->buffer.corr / rate; this->next_time = (uint64_t)(now_time + duration * SPA_NSEC_PER_SEC / port->buffer.corr / rate);
if (SPA_LIKELY(this->clock)) { if (SPA_LIKELY(this->clock)) {
this->clock->nsec = now_time; this->clock->nsec = now_time;

6
spa/plugins/support/node-driver.c
View file

@ -318,7 +318,7 @@ static inline uint64_t scale_u64(uint64_t val, uint32_t num, uint32_t denom)
#if 0 #if 0
return ((__uint128_t)val * num) / denom; return ((__uint128_t)val * num) / denom;
#else #else
return (double)val / denom * num; return (uint64_t)((double)val / denom * num);
#endif #endif
} }
@ -390,7 +390,7 @@ static void on_timeout(struct spa_source *source)
} }
} }
corr = spa_dll_update(&this->dll, err); corr = spa_dll_update(&this->dll, err);
this->next_time = nsec + duration / corr * 1e9 / rate; this->next_time = (uint64_t)(nsec + duration / corr * 1e9 / rate);
} else { } else {
corr = 1.0; corr = 1.0;
this->next_time = scale_u64(position + duration, SPA_NSEC_PER_SEC, rate); this->next_time = scale_u64(position + duration, SPA_NSEC_PER_SEC, rate);
@ -710,7 +710,7 @@ impl_init(const struct spa_handle_factory *factory,
} else if (spa_streq(k, "freewheel.wait")) { } else if (spa_streq(k, "freewheel.wait")) {
this->props.freewheel_wait = atoi(s); this->props.freewheel_wait = atoi(s);
} else if (spa_streq(k, "resync.ms")) { } else if (spa_streq(k, "resync.ms")) {
this->props.resync_ms = atof(s); this->props.resync_ms = (float)atof(s);
} }
} }
if (this->props.clock_name[0] == '\0') { if (this->props.clock_name[0] == '\0') {

2
src/examples/audio-capture.c
View file

@ -63,7 +63,7 @@ static void on_process(void *userdata)
for (n = c; n < n_samples; n += n_channels) for (n = c; n < n_samples; n += n_channels)
max = fmaxf(max, fabsf(samples[n])); max = fmaxf(max, fabsf(samples[n]));
peak = SPA_CLAMP(max * 30, 0, 39); peak = (uint32_t)SPA_CLAMPF(max * 30, 0.f, 39.f);
fprintf(stdout, "channel %d: |%*s%*s| peak:%f\n", fprintf(stdout, "channel %d: |%*s%*s| peak:%f\n",
c, peak+1, "*", 40 - peak, "", max); c, peak+1, "*", 40 - peak, "", max);

14
src/examples/audio-dsp-src.c
View file

@ -16,17 +16,17 @@
#include <pipewire/pipewire.h> #include <pipewire/pipewire.h>
#include <pipewire/filter.h> #include <pipewire/filter.h>
#define M_PI_M2 ( M_PI + M_PI ) #define M_PI_M2f ( M_PIf + M_PIf )
#define DEFAULT_RATE 44100 #define DEFAULT_RATE 44100
#define DEFAULT_FREQ 440 #define DEFAULT_FREQ 440
#define DEFAULT_VOLUME 0.7 #define DEFAULT_VOLUME 0.7f
struct data; struct data;
struct port { struct port {
struct data *data; struct data *data;
double accumulator; float accumulator;
}; };
struct data { struct data {
@ -61,11 +61,11 @@ static void on_process(void *userdata, struct spa_io_position *position)
return; return;
for (i = 0; i < n_samples; i++) { for (i = 0; i < n_samples; i++) {
out_port->accumulator += M_PI_M2 * DEFAULT_FREQ / DEFAULT_RATE; out_port->accumulator += M_PI_M2f * DEFAULT_FREQ / DEFAULT_RATE;
if (out_port->accumulator >= M_PI_M2) if (out_port->accumulator >= M_PI_M2f)
out_port->accumulator -= M_PI_M2; out_port->accumulator -= M_PI_M2f;
*out++ = sin(out_port->accumulator) * DEFAULT_VOLUME; *out++ = sinf(out_port->accumulator) * DEFAULT_VOLUME;
} }
} }

14
src/examples/audio-src.c
View file

@ -17,17 +17,17 @@
#include <pipewire/pipewire.h> #include <pipewire/pipewire.h>
#define M_PI_M2 ( M_PI + M_PI ) #define M_PI_M2f ( M_PIf + M_PIf )
#define DEFAULT_RATE 44100 #define DEFAULT_RATE 44100
#define DEFAULT_CHANNELS 2 #define DEFAULT_CHANNELS 2
#define DEFAULT_VOLUME 0.7 #define DEFAULT_VOLUME 0.7f
struct data { struct data {
struct pw_main_loop *loop; struct pw_main_loop *loop;
struct pw_stream *stream; struct pw_stream *stream;
double accumulator; float accumulator;
}; };
static void fill_f32(struct data *d, void *dest, int n_frames) static void fill_f32(struct data *d, void *dest, int n_frames)
@ -36,11 +36,11 @@ static void fill_f32(struct data *d, void *dest, int n_frames)
int i, c; int i, c;
for (i = 0; i < n_frames; i++) { for (i = 0; i < n_frames; i++) {
d->accumulator += M_PI_M2 * 440 / DEFAULT_RATE; d->accumulator += M_PI_M2f * 440 / DEFAULT_RATE;
if (d->accumulator >= M_PI_M2) if (d->accumulator >= M_PI_M2f)
d->accumulator -= M_PI_M2; d->accumulator -= M_PI_M2f;
val = sin(d->accumulator) * DEFAULT_VOLUME; val = sinf(d->accumulator) * DEFAULT_VOLUME;
for (c = 0; c < DEFAULT_CHANNELS; c++) for (c = 0; c < DEFAULT_CHANNELS; c++)
*dst++ = val; *dst++ = val;
} }

12
src/examples/export-sink.c
View file

@ -29,7 +29,7 @@
#include "sdl.h" #include "sdl.h"
#define M_PI_M2 ( M_PI + M_PI ) #define M_PI_M2f ( M_PIf + M_PIf )
#define MAX_BUFFERS 64 #define MAX_BUFFERS 64
@ -65,7 +65,7 @@ struct data {
struct spa_io_buffers *io; struct spa_io_buffers *io;
struct spa_io_sequence *io_notify; struct spa_io_sequence *io_notify;
uint32_t io_notify_size; uint32_t io_notify_size;
double param_accum; float param_accum;
uint8_t buffer[1024]; uint8_t buffer[1024];
@ -106,13 +106,13 @@ static void update_param(struct data *data)
spa_pod_builder_control(&b, 0, SPA_CONTROL_Properties); spa_pod_builder_control(&b, 0, SPA_CONTROL_Properties);
spa_pod_builder_push_object(&b, &f[1], SPA_TYPE_OBJECT_Props, 0); spa_pod_builder_push_object(&b, &f[1], SPA_TYPE_OBJECT_Props, 0);
spa_pod_builder_prop(&b, SPA_PROP_contrast, 0); spa_pod_builder_prop(&b, SPA_PROP_contrast, 0);
spa_pod_builder_float(&b, (sin(data->param_accum) * 127.0) + 127.0); spa_pod_builder_float(&b, (sinf(data->param_accum) * 127.0f) + 127.0f);
spa_pod_builder_pop(&b, &f[1]); spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b, &f[0]); spa_pod_builder_pop(&b, &f[0]);
data->param_accum += M_PI_M2 / 30.0; data->param_accum += M_PI_M2f / 30.0f;
if (data->param_accum >= M_PI_M2) if (data->param_accum >= M_PI_M2f)
data->param_accum -= M_PI_M2; data->param_accum -= M_PI_M2f;
} }
static int impl_send_command(void *object, const struct spa_command *command) static int impl_send_command(void *object, const struct spa_command *command)

30
src/examples/export-source.c
View file

@ -23,7 +23,7 @@
#include <pipewire/pipewire.h> #include <pipewire/pipewire.h>
#define M_PI_M2 ( M_PI + M_PI ) #define M_PI_M2f ( M_PIf + M_PIf )
#define BUFFER_SAMPLES 128 #define BUFFER_SAMPLES 128
#define MAX_BUFFERS 32 #define MAX_BUFFERS 32
@ -64,8 +64,8 @@ struct data {
uint32_t n_buffers; uint32_t n_buffers;
struct spa_list empty; struct spa_list empty;
double accumulator; float accumulator;
double volume_accum; float volume_accum;
}; };
static void update_volume(struct data *data) static void update_volume(struct data *data)
@ -81,13 +81,13 @@ static void update_volume(struct data *data)
spa_pod_builder_control(&b, 0, SPA_CONTROL_Properties); spa_pod_builder_control(&b, 0, SPA_CONTROL_Properties);
spa_pod_builder_push_object(&b, &f[1], SPA_TYPE_OBJECT_Props, 0); spa_pod_builder_push_object(&b, &f[1], SPA_TYPE_OBJECT_Props, 0);
spa_pod_builder_prop(&b, SPA_PROP_volume, 0); spa_pod_builder_prop(&b, SPA_PROP_volume, 0);
spa_pod_builder_float(&b, (sin(data->volume_accum) / 2.0) + 0.5); spa_pod_builder_float(&b, (sinf(data->volume_accum) / 2.0f) + 0.5f);
spa_pod_builder_pop(&b, &f[1]); spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b, &f[0]); spa_pod_builder_pop(&b, &f[0]);
data->volume_accum += M_PI_M2 / 1000.0; data->volume_accum += M_PI_M2f / 1000.0f;
if (data->volume_accum >= M_PI_M2) if (data->volume_accum >= M_PI_M2f)
data->volume_accum -= M_PI_M2; data->volume_accum -= M_PI_M2f;
} }
static int impl_send_command(void *object, const struct spa_command *command) static int impl_send_command(void *object, const struct spa_command *command)
@ -364,11 +364,11 @@ static void fill_f32(struct data *d, void *dest, int avail)
for (i = 0; i < n_samples; i++) { for (i = 0; i < n_samples; i++) {
float val; float val;
d->accumulator += M_PI_M2 * 440 / d->format.rate; d->accumulator += M_PI_M2f * 440 / d->format.rate;
if (d->accumulator >= M_PI_M2) if (d->accumulator >= M_PI_M2f)
d->accumulator -= M_PI_M2; d->accumulator -= M_PI_M2f;
val = sin(d->accumulator); val = sinf(d->accumulator);
for (c = 0; c < d->format.channels; c++) for (c = 0; c < d->format.channels; c++)
*dst++ = val; *dst++ = val;
@ -385,11 +385,11 @@ static void fill_s16(struct data *d, void *dest, int avail)
for (i = 0; i < n_samples; i++) { for (i = 0; i < n_samples; i++) {
int16_t val; int16_t val;
d->accumulator += M_PI_M2 * 440 / d->format.rate; d->accumulator += M_PI_M2f * 440 / d->format.rate;
if (d->accumulator >= M_PI_M2) if (d->accumulator >= M_PI_M2f)
d->accumulator -= M_PI_M2; d->accumulator -= M_PI_M2f;
val = (int16_t) (sin(d->accumulator) * 32767.0); val = (int16_t) (sinf(d->accumulator) * 32767.0f);
for (c = 0; c < d->format.channels; c++) for (c = 0; c < d->format.channels; c++)
*dst++ = val; *dst++ = val;

8
src/examples/video-dsp-play.c
View file

@ -128,10 +128,10 @@ on_process(void *_data, struct spa_io_position *position)
for (i = 0; i < data->position->video.size.height; i++) { for (i = 0; i < data->position->video.size.height; i++) {
struct pixel *p = (struct pixel *) src; struct pixel *p = (struct pixel *) src;
for (j = 0; j < data->position->video.size.width; j++) { for (j = 0; j < data->position->video.size.width; j++) {
dst[j * 4 + 0] = SPA_CLAMP(p[j].r * 255.0f, 0, 255); dst[j * 4 + 0] = SPA_CLAMP((uint8_t)(p[j].r * 255.0f), 0, 255);
dst[j * 4 + 1] = SPA_CLAMP(p[j].g * 255.0f, 0, 255); dst[j * 4 + 1] = SPA_CLAMP((uint8_t)(p[j].g * 255.0f), 0, 255);
dst[j * 4 + 2] = SPA_CLAMP(p[j].b * 255.0f, 0, 255); dst[j * 4 + 2] = SPA_CLAMP((uint8_t)(p[j].b * 255.0f), 0, 255);
dst[j * 4 + 3] = SPA_CLAMP(p[j].a * 255.0f, 0, 255); dst[j * 4 + 3] = SPA_CLAMP((uint8_t)(p[j].a * 255.0f), 0, 255);
} }
src += sstride; src += sstride;
dst += dstride; dst += dstride;

14
src/examples/video-dsp-src.c
View file

@ -123,18 +123,18 @@ static void on_process(void *userdata)
} }
if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) { if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) {
data->crop = (sin(data->accumulator) + 1.0) * 32.0; data->crop = (sin(data->accumulator) + 1.0) * 32.0;
mc->region.position.x = data->crop; mc->region.position.x = (int32_t)data->crop;
mc->region.position.y = data->crop; mc->region.position.y = (int32_t)data->crop;
mc->region.size.width = data->position->video.size.width - data->crop*2; mc->region.size.width = data->position->video.size.width - (int32_t)(data->crop*2);
mc->region.size.height = data->position->video.size.height - data->crop*2; mc->region.size.height = data->position->video.size.height - (int32_t)(data->crop*2);
} }
if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) { if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) {
struct spa_meta_bitmap *mb; struct spa_meta_bitmap *mb;
uint32_t *bitmap, color; uint32_t *bitmap, color;
mcs->id = 1; mcs->id = 1;
mcs->position.x = (sin(data->accumulator) + 1.0) * 160.0 + 80; mcs->position.x = (int32_t)((sin(data->accumulator) + 1.0) * 160.0 + 80);
mcs->position.y = (cos(data->accumulator) + 1.0) * 100.0 + 50; mcs->position.y = (int32_t)((cos(data->accumulator) + 1.0) * 100.0 + 50);
mcs->hotspot.x = 0; mcs->hotspot.x = 0;
mcs->hotspot.y = 0; mcs->hotspot.y = 0;
mcs->bitmap_offset = sizeof(struct spa_meta_cursor); mcs->bitmap_offset = sizeof(struct spa_meta_cursor);
@ -147,7 +147,7 @@ static void on_process(void *userdata)
mb->offset = sizeof(struct spa_meta_bitmap); mb->offset = sizeof(struct spa_meta_bitmap);
bitmap = SPA_PTROFF(mb, mb->offset, uint32_t); bitmap = SPA_PTROFF(mb, mb->offset, uint32_t);
color = (cos(data->accumulator) + 1.0) * (1 << 23); color = (uint32_t)((cos(data->accumulator) + 1.0) * (1 << 23));
color |= 0xff000000; color |= 0xff000000;
draw_elipse(bitmap, mb->size.width, mb->size.height, color); draw_elipse(bitmap, mb->size.width, mb->size.height, color);

8
src/examples/video-play-pull.c
View file

@ -197,10 +197,10 @@ on_process(void *_data)
for (i = 0; i < data->size.height; i++) { for (i = 0; i < data->size.height; i++) {
struct pixel *p = (struct pixel *) src; struct pixel *p = (struct pixel *) src;
for (j = 0; j < data->size.width; j++) { for (j = 0; j < data->size.width; j++) {
dst[j * 4 + 0] = SPA_CLAMP(p[j].r * 255.0f, 0, 255); dst[j * 4 + 0] = SPA_CLAMP((uint8_t)(p[j].r * 255.0f), 0u, 255u);
dst[j * 4 + 1] = SPA_CLAMP(p[j].g * 255.0f, 0, 255); dst[j * 4 + 1] = SPA_CLAMP((uint8_t)(p[j].g * 255.0f), 0u, 255u);
dst[j * 4 + 2] = SPA_CLAMP(p[j].b * 255.0f, 0, 255); dst[j * 4 + 2] = SPA_CLAMP((uint8_t)(p[j].b * 255.0f), 0u, 255u);
dst[j * 4 + 3] = SPA_CLAMP(p[j].a * 255.0f, 0, 255); dst[j * 4 + 3] = SPA_CLAMP((uint8_t)(p[j].a * 255.0f), 0u, 255u);
} }
src += sstride; src += sstride;
dst += dstride; dst += dstride;

8
src/examples/video-play.c
View file

@ -205,10 +205,10 @@ on_process(void *_data)
for (i = 0; i < data->size.height; i++) { for (i = 0; i < data->size.height; i++) {
struct pixel *p = (struct pixel *) src; struct pixel *p = (struct pixel *) src;
for (j = 0; j < data->size.width; j++) { for (j = 0; j < data->size.width; j++) {
dst[j * 4 + 0] = SPA_CLAMP(p[j].r * 255.0f, 0, 255); dst[j * 4 + 0] = SPA_CLAMP((uint8_t)(p[j].r * 255.0f), 0u, 255u);
dst[j * 4 + 1] = SPA_CLAMP(p[j].g * 255.0f, 0, 255); dst[j * 4 + 1] = SPA_CLAMP((uint8_t)(p[j].g * 255.0f), 0u, 255u);
dst[j * 4 + 2] = SPA_CLAMP(p[j].b * 255.0f, 0, 255); dst[j * 4 + 2] = SPA_CLAMP((uint8_t)(p[j].b * 255.0f), 0u, 255u);
dst[j * 4 + 3] = SPA_CLAMP(p[j].a * 255.0f, 0, 255); dst[j * 4 + 3] = SPA_CLAMP((uint8_t)(p[j].a * 255.0f), 0u, 255u);
} }
src += sstride; src += sstride;
dst += dstride; dst += dstride;

14
src/examples/video-src-alloc.c
View file

@ -111,18 +111,18 @@ static void on_process(void *userdata)
} }
if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) { if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) {
data->crop = (sin(data->accumulator) + 1.0) * 32.0; data->crop = (sin(data->accumulator) + 1.0) * 32.0;
mc->region.position.x = data->crop; mc->region.position.x = (int32_t)data->crop;
mc->region.position.y = data->crop; mc->region.position.y = (int32_t)data->crop;
mc->region.size.width = data->format.size.width - data->crop*2; mc->region.size.width = data->format.size.width - (int32_t)(data->crop*2);
mc->region.size.height = data->format.size.height - data->crop*2; mc->region.size.height = data->format.size.height - (int32_t)(data->crop*2);
} }
if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) { if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) {
struct spa_meta_bitmap *mb; struct spa_meta_bitmap *mb;
uint32_t *bitmap, color; uint32_t *bitmap, color;
mcs->id = 1; mcs->id = 1;
mcs->position.x = (sin(data->accumulator) + 1.0) * 160.0 + 80; mcs->position.x = (int32_t)((sin(data->accumulator) + 1.0) * 160.0 + 80);
mcs->position.y = (cos(data->accumulator) + 1.0) * 100.0 + 50; mcs->position.y = (int32_t)((cos(data->accumulator) + 1.0) * 100.0 + 50);
mcs->hotspot.x = 0; mcs->hotspot.x = 0;
mcs->hotspot.y = 0; mcs->hotspot.y = 0;
mcs->bitmap_offset = sizeof(struct spa_meta_cursor); mcs->bitmap_offset = sizeof(struct spa_meta_cursor);
@ -135,7 +135,7 @@ static void on_process(void *userdata)
mb->offset = sizeof(struct spa_meta_bitmap); mb->offset = sizeof(struct spa_meta_bitmap);
bitmap = SPA_PTROFF(mb, mb->offset, uint32_t); bitmap = SPA_PTROFF(mb, mb->offset, uint32_t);
color = (cos(data->accumulator) + 1.0) * (1 << 23); color = (uint32_t)((cos(data->accumulator) + 1.0) * (1 << 23));
color |= 0xff000000; color |= 0xff000000;
draw_elipse(bitmap, mb->size.width, mb->size.height, color); draw_elipse(bitmap, mb->size.width, mb->size.height, color);

14
src/examples/video-src-fixate.c
View file

@ -185,18 +185,18 @@ static void on_process(void *userdata)
} }
if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) { if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) {
data->crop = (sin(data->accumulator) + 1.0) * 32.0; data->crop = (sin(data->accumulator) + 1.0) * 32.0;
mc->region.position.x = data->crop; mc->region.position.x = (int32_t)data->crop;
mc->region.position.y = data->crop; mc->region.position.y = (int32_t)data->crop;
mc->region.size.width = data->format.size.width - data->crop*2; mc->region.size.width = data->format.size.width - (int32_t)(data->crop*2);
mc->region.size.height = data->format.size.height - data->crop*2; mc->region.size.height = data->format.size.height - (int32_t)(data->crop*2);
} }
if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) { if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) {
struct spa_meta_bitmap *mb; struct spa_meta_bitmap *mb;
uint32_t *bitmap, color; uint32_t *bitmap, color;
mcs->id = 1; mcs->id = 1;
mcs->position.x = (sin(data->accumulator) + 1.0) * 160.0 + 80; mcs->position.x = (int32_t)((sin(data->accumulator) + 1.0) * 160.0 + 80);
mcs->position.y = (cos(data->accumulator) + 1.0) * 100.0 + 50; mcs->position.y = (int32_t)((cos(data->accumulator) + 1.0) * 100.0 + 50);
mcs->hotspot.x = 0; mcs->hotspot.x = 0;
mcs->hotspot.y = 0; mcs->hotspot.y = 0;
mcs->bitmap_offset = sizeof(struct spa_meta_cursor); mcs->bitmap_offset = sizeof(struct spa_meta_cursor);
@ -209,7 +209,7 @@ static void on_process(void *userdata)
mb->offset = sizeof(struct spa_meta_bitmap); mb->offset = sizeof(struct spa_meta_bitmap);
bitmap = SPA_PTROFF(mb, mb->offset, uint32_t); bitmap = SPA_PTROFF(mb, mb->offset, uint32_t);
color = (cos(data->accumulator) + 1.0) * (1 << 23); color = (uint32_t)((cos(data->accumulator) + 1.0) * (1 << 23));
color |= 0xff000000; color |= 0xff000000;
draw_elipse(bitmap, mb->size.width, mb->size.height, color); draw_elipse(bitmap, mb->size.width, mb->size.height, color);

14
src/examples/video-src-reneg.c
View file

@ -115,18 +115,18 @@ static void on_process(void *userdata)
} }
if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) { if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) {
data->crop = (sin(data->accumulator) + 1.0) * 32.0; data->crop = (sin(data->accumulator) + 1.0) * 32.0;
mc->region.position.x = data->crop; mc->region.position.x = (int32_t)data->crop;
mc->region.position.y = data->crop; mc->region.position.y = (int32_t)data->crop;
mc->region.size.width = data->format.size.width - data->crop*2; mc->region.size.width = data->format.size.width - (int32_t)(data->crop*2);
mc->region.size.height = data->format.size.height - data->crop*2; mc->region.size.height = data->format.size.height - (int32_t)(data->crop*2);
} }
if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) { if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) {
struct spa_meta_bitmap *mb; struct spa_meta_bitmap *mb;
uint32_t *bitmap, color; uint32_t *bitmap, color;
mcs->id = 1; mcs->id = 1;
mcs->position.x = (sin(data->accumulator) + 1.0) * 160.0 + 80; mcs->position.x = (int32_t)((sin(data->accumulator) + 1.0) * 160.0 + 80);
mcs->position.y = (cos(data->accumulator) + 1.0) * 100.0 + 50; mcs->position.y = (int32_t)((cos(data->accumulator) + 1.0) * 100.0 + 50);
mcs->hotspot.x = 0; mcs->hotspot.x = 0;
mcs->hotspot.y = 0; mcs->hotspot.y = 0;
mcs->bitmap_offset = sizeof(struct spa_meta_cursor); mcs->bitmap_offset = sizeof(struct spa_meta_cursor);
@ -139,7 +139,7 @@ static void on_process(void *userdata)
mb->offset = sizeof(struct spa_meta_bitmap); mb->offset = sizeof(struct spa_meta_bitmap);
bitmap = SPA_PTROFF(mb, mb->offset, uint32_t); bitmap = SPA_PTROFF(mb, mb->offset, uint32_t);
color = (cos(data->accumulator) + 1.0) * (1 << 23); color = (uint32_t)((cos(data->accumulator) + 1.0) * (1 << 23));
color |= 0xff000000; color |= 0xff000000;
draw_elipse(bitmap, mb->size.width, mb->size.height, color); draw_elipse(bitmap, mb->size.width, mb->size.height, color);

14
src/examples/video-src.c
View file

@ -111,18 +111,18 @@ static void on_process(void *userdata)
} }
if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) { if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc)))) {
data->crop = (sin(data->accumulator) + 1.0) * 32.0; data->crop = (sin(data->accumulator) + 1.0) * 32.0;
mc->region.position.x = data->crop; mc->region.position.x = (int32_t)data->crop;
mc->region.position.y = data->crop; mc->region.position.y = (int32_t)data->crop;
mc->region.size.width = data->format.size.width - data->crop*2; mc->region.size.width = data->format.size.width - (int32_t)(data->crop*2);
mc->region.size.height = data->format.size.height - data->crop*2; mc->region.size.height = data->format.size.height - (int32_t)(data->crop*2);
} }
if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) { if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs)))) {
struct spa_meta_bitmap *mb; struct spa_meta_bitmap *mb;
uint32_t *bitmap, color; uint32_t *bitmap, color;
mcs->id = 1; mcs->id = 1;
mcs->position.x = (sin(data->accumulator) + 1.0) * 160.0 + 80; mcs->position.x = (int32_t)((sin(data->accumulator) + 1.0) * 160.0 + 80);
mcs->position.y = (cos(data->accumulator) + 1.0) * 100.0 + 50; mcs->position.y = (int32_t)((cos(data->accumulator) + 1.0) * 100.0 + 50);
mcs->hotspot.x = 0; mcs->hotspot.x = 0;
mcs->hotspot.y = 0; mcs->hotspot.y = 0;
mcs->bitmap_offset = sizeof(struct spa_meta_cursor); mcs->bitmap_offset = sizeof(struct spa_meta_cursor);
@ -135,7 +135,7 @@ static void on_process(void *userdata)
mb->offset = sizeof(struct spa_meta_bitmap); mb->offset = sizeof(struct spa_meta_bitmap);
bitmap = SPA_PTROFF(mb, mb->offset, uint32_t); bitmap = SPA_PTROFF(mb, mb->offset, uint32_t);
color = (cos(data->accumulator) + 1.0) * (1 << 23); color = (uint32_t)((cos(data->accumulator) + 1.0) * (1 << 23));
color |= 0xff000000; color |= 0xff000000;
draw_elipse(bitmap, mb->size.width, mb->size.height, color); draw_elipse(bitmap, mb->size.width, mb->size.height, color);

8
src/modules/module-avb/maap.c
View file

@ -78,10 +78,10 @@ static void maap_message_debug(struct maap *maap, const struct avb_packet_maap *
pw_log_info(" conflict-count: %d", AVB_PACKET_MAAP_GET_CONFLICT_COUNT(p)); pw_log_info(" conflict-count: %d", AVB_PACKET_MAAP_GET_CONFLICT_COUNT(p));
} }
#define PROBE_TIMEOUT(n) ((n) + (MAAP_PROBE_INTERVAL_MS + \ #define PROBE_TIMEOUT(n) (uint64_t)(((n) + (MAAP_PROBE_INTERVAL_MS + \
drand48() * MAAP_PROBE_INTERVAL_VAR_MS) * SPA_NSEC_PER_MSEC) drand48() * MAAP_PROBE_INTERVAL_VAR_MS) * SPA_NSEC_PER_MSEC))
#define ANNOUNCE_TIMEOUT(n) ((n) + (MAAP_ANNOUNCE_INTERVAL_MS + \ #define ANNOUNCE_TIMEOUT(n) (uint64_t)(((n) + (MAAP_ANNOUNCE_INTERVAL_MS + \
drand48() * MAAP_ANNOUNCE_INTERVAL_VAR_MS) * SPA_NSEC_PER_MSEC) drand48() * MAAP_ANNOUNCE_INTERVAL_VAR_MS) * SPA_NSEC_PER_MSEC))
static int make_new_address(struct maap *maap, uint64_t now, int range) static int make_new_address(struct maap *maap, uint64_t now, int range)
{ {

14
src/modules/module-filter-chain.c
View file

@ -1022,12 +1022,12 @@ static struct spa_pod *get_prop_info(struct graph *graph, struct spa_pod_builder
} }
} else if (p->hint & FC_HINT_INTEGER) { } else if (p->hint & FC_HINT_INTEGER) {
if (min == max) { if (min == max) {
spa_pod_builder_int(b, def); spa_pod_builder_int(b, (int32_t)def);
} else { } else {
spa_pod_builder_push_choice(b, &f[1], SPA_CHOICE_Range, 0); spa_pod_builder_push_choice(b, &f[1], SPA_CHOICE_Range, 0);
spa_pod_builder_int(b, def); spa_pod_builder_int(b, (int32_t)def);
spa_pod_builder_int(b, min); spa_pod_builder_int(b, (int32_t)min);
spa_pod_builder_int(b, max); spa_pod_builder_int(b, (int32_t)max);
spa_pod_builder_pop(b, &f[1]); spa_pod_builder_pop(b, &f[1]);
} }
} else { } else {
@ -1073,7 +1073,7 @@ static struct spa_pod *get_props_param(struct graph *graph, struct spa_pod_build
if (p->hint & FC_HINT_BOOLEAN) { if (p->hint & FC_HINT_BOOLEAN) {
spa_pod_builder_bool(b, port->control_data[0] <= 0.0f ? false : true); spa_pod_builder_bool(b, port->control_data[0] <= 0.0f ? false : true);
} else if (p->hint & FC_HINT_INTEGER) { } else if (p->hint & FC_HINT_INTEGER) {
spa_pod_builder_int(b, port->control_data[0]); spa_pod_builder_int(b, (int32_t)port->control_data[0]);
} else { } else {
spa_pod_builder_float(b, port->control_data[0]); spa_pod_builder_float(b, port->control_data[0]);
} }
@ -1140,7 +1140,7 @@ static int parse_params(struct graph *graph, const struct spa_pod *pod)
if (spa_pod_parser_get_float(&prs, &value) >= 0) { if (spa_pod_parser_get_float(&prs, &value) >= 0) {
val = &value; val = &value;
} else if (spa_pod_parser_get_double(&prs, &dbl_val) >= 0) { } else if (spa_pod_parser_get_double(&prs, &dbl_val) >= 0) {
value = dbl_val; value = (float)dbl_val;
val = &value; val = &value;
} else if (spa_pod_parser_get_int(&prs, &int_val) >= 0) { } else if (spa_pod_parser_get_int(&prs, &int_val) >= 0) {
value = int_val; value = int_val;
@ -1217,7 +1217,7 @@ static int sync_volume(struct graph *graph, struct volume *vol)
float v = vol->mute ? 0.0f : vol->volumes[i]; float v = vol->mute ? 0.0f : vol->volumes[i];
switch (vol->scale[n_port]) { switch (vol->scale[n_port]) {
case SCALE_CUBIC: case SCALE_CUBIC:
v = cbrt(v); v = cbrtf(v);
break; break;
} }
v = v * (vol->max[n_port] - vol->min[n_port]) + vol->min[n_port]; v = v * (vol->max[n_port] - vol->min[n_port]) + vol->min[n_port];

10
src/modules/module-filter-chain/biquad.c
View file

@ -19,11 +19,11 @@ static void set_coefficient(struct biquad *bq, double b0, double b1, double b2,
double a0, double a1, double a2) double a0, double a1, double a2)
{ {
double a0_inv = 1 / a0; double a0_inv = 1 / a0;
bq->b0 = b0 * a0_inv; bq->b0 = (float)(b0 * a0_inv);
bq->b1 = b1 * a0_inv; bq->b1 = (float)(b1 * a0_inv);
bq->b2 = b2 * a0_inv; bq->b2 = (float)(b2 * a0_inv);
bq->a1 = a1 * a0_inv; bq->a1 = (float)(a1 * a0_inv);
bq->a2 = a2 * a0_inv; bq->a2 = (float)(a2 * a0_inv);
} }
static void biquad_lowpass(struct biquad *bq, double cutoff, double resonance) static void biquad_lowpass(struct biquad *bq, double cutoff, double resonance)

26
src/modules/module-filter-chain/builtin_plugin.c
View file

@ -752,10 +752,10 @@ static float *create_hilbert(const char *filename, float gain, int delay, int of
if (samples == NULL) if (samples == NULL)
return NULL; return NULL;
gain *= 2 / M_PI; gain *= 2 / M_PIf;
h = length / 2; h = length / 2;
for (i = 1; i < h; i += 2) { for (i = 1; i < h; i += 2) {
v = (gain / i) * (0.43f + 0.57f * cosf(i * M_PI / h)); v = (gain / i) * (0.43f + 0.57f * cosf(i * M_PIf / h));
samples[delay + h + i] = -v; samples[delay + h + i] = -v;
samples[delay + h - i] = v; samples[delay + h - i] = v;
} }
@ -1134,7 +1134,7 @@ static void *delay_instantiate(const struct fc_descriptor * Descriptor,
return NULL; return NULL;
impl->rate = SampleRate; impl->rate = SampleRate;
impl->buffer_samples = max_delay * impl->rate; impl->buffer_samples = (uint32_t)(max_delay * impl->rate);
pw_log_info("max-delay:%f seconds rate:%lu samples:%d", max_delay, impl->rate, impl->buffer_samples); pw_log_info("max-delay:%f seconds rate:%lu samples:%d", max_delay, impl->rate, impl->buffer_samples);
impl->buffer = calloc(impl->buffer_samples, sizeof(float)); impl->buffer = calloc(impl->buffer_samples, sizeof(float));
@ -1163,7 +1163,7 @@ static void delay_run(void * Instance, unsigned long SampleCount)
uint32_t r, w; uint32_t r, w;
if (delay != impl->delay) { if (delay != impl->delay) {
impl->delay_samples = SPA_CLAMP(delay * impl->rate, 0, impl->buffer_samples-1); impl->delay_samples = SPA_CLAMP((uint32_t)(delay * impl->rate), 0u, impl->buffer_samples-1);
impl->delay = delay; impl->delay = delay;
} }
r = impl->ptr; r = impl->ptr;
@ -1453,7 +1453,7 @@ static struct fc_port exp_ports[] = {
{ .index = 4, { .index = 4,
.name = "Base", .name = "Base",
.flags = FC_PORT_INPUT | FC_PORT_CONTROL, .flags = FC_PORT_INPUT | FC_PORT_CONTROL,
.def = M_E, .min = -10.0f, .max = 10.0f .def = M_Ef, .min = -10.0f, .max = 10.0f
}, },
}; };
@ -1510,7 +1510,7 @@ static struct fc_port log_ports[] = {
{ .index = 4, { .index = 4,
.name = "Base", .name = "Base",
.flags = FC_PORT_INPUT | FC_PORT_CONTROL, .flags = FC_PORT_INPUT | FC_PORT_CONTROL,
.def = M_E, .min = 2.0f, .max = 100.0f .def = M_Ef, .min = 2.0f, .max = 100.0f
}, },
{ .index = 5, { .index = 5,
.name = "M1", .name = "M1",
@ -1611,7 +1611,7 @@ static const struct fc_descriptor mult_desc = {
.cleanup = builtin_cleanup, .cleanup = builtin_cleanup,
}; };
#define M_PI_M2 ( M_PI + M_PI ) #define M_PI_M2f ( M_PIf + M_PIf )
/* sine */ /* sine */
static void sine_run(void * Instance, unsigned long SampleCount) static void sine_run(void * Instance, unsigned long SampleCount)
@ -1626,13 +1626,13 @@ static void sine_run(void * Instance, unsigned long SampleCount)
for (n = 0; n < SampleCount; n++) { for (n = 0; n < SampleCount; n++) {
if (out != NULL) if (out != NULL)
out[n] = sin(impl->accum) * ampl + offs; out[n] = sinf(impl->accum) * ampl + offs;
if (notify != NULL && n == 0) if (notify != NULL && n == 0)
notify[0] = sin(impl->accum) * ampl + offs; notify[0] = sinf(impl->accum) * ampl + offs;
impl->accum += M_PI_M2 * freq / impl->rate; impl->accum += M_PI_M2f * freq / impl->rate;
if (impl->accum >= M_PI_M2) if (impl->accum >= M_PI_M2f)
impl->accum -= M_PI_M2; impl->accum -= M_PI_M2f;
} }
} }
@ -1658,7 +1658,7 @@ static struct fc_port sine_ports[] = {
{ .index = 4, { .index = 4,
.name = "Phase", .name = "Phase",
.flags = FC_PORT_INPUT | FC_PORT_CONTROL, .flags = FC_PORT_INPUT | FC_PORT_CONTROL,
.def = 0.0f, .min = -M_PI, .max = M_PI .def = 0.0f, .min = -M_PIf, .max = M_PIf
}, },
{ .index = 5, { .index = 5,
.name = "Offset", .name = "Offset",

28
src/modules/module-filter-chain/pffft.c
View file

@ -1273,7 +1273,7 @@ static void rffti1_ps(int n, float *wa, int *ifac)
int k1, j, ii; int k1, j, ii;
int nf = decompose(n, ifac, ntryh); int nf = decompose(n, ifac, ntryh);
float argh = (2 * M_PI) / n; float argh = (2 * M_PIf) / n;
int is = 0; int is = 0;
int nfm1 = nf - 1; int nfm1 = nf - 1;
int l1 = 1; int l1 = 1;
@ -1291,8 +1291,8 @@ static void rffti1_ps(int n, float *wa, int *ifac)
for (ii = 3; ii <= ido; ii += 2) { for (ii = 3; ii <= ido; ii += 2) {
i += 2; i += 2;
fi += 1; fi += 1;
wa[i - 2] = cos(fi * argld); wa[i - 2] = cosf(fi * argld);
wa[i - 1] = sin(fi * argld); wa[i - 1] = sinf(fi * argld);
} }
is += ido; is += ido;
} }
@ -1306,7 +1306,7 @@ static void cffti1_ps(int n, float *wa, int *ifac)
int k1, j, ii; int k1, j, ii;
int nf = decompose(n, ifac, ntryh); int nf = decompose(n, ifac, ntryh);
float argh = (2 * M_PI) / (float)n; float argh = (2 * M_PIf) / (float)n;
int i = 1; int i = 1;
int l1 = 1; int l1 = 1;
for (k1 = 1; k1 <= nf; k1++) { for (k1 = 1; k1 <= nf; k1++) {
@ -1326,8 +1326,8 @@ static void cffti1_ps(int n, float *wa, int *ifac)
for (ii = 4; ii <= idot; ii += 2) { for (ii = 4; ii <= idot; ii += 2) {
i += 2; i += 2;
fi += 1; fi += 1;
wa[i - 1] = cos(fi * argld); wa[i - 1] = cosf(fi * argld);
wa[i] = sin(fi * argld); wa[i] = sinf(fi * argld);
} }
if (ip > 5) { if (ip > 5) {
wa[i1 - 1] = wa[i - 1]; wa[i1 - 1] = wa[i - 1];
@ -1440,11 +1440,11 @@ static PFFFT_Setup *new_setup_simd(int N, pffft_transform_t transform)
int i = k / SIMD_SZ; int i = k / SIMD_SZ;
int j = k % SIMD_SZ; int j = k % SIMD_SZ;
for (m = 0; m < SIMD_SZ - 1; ++m) { for (m = 0; m < SIMD_SZ - 1; ++m) {
float A = -2 * M_PI * (m + 1) * k / N; float A = -2 * M_PIf * (m + 1) * k / N;
s->e[(2 * (i * 3 + m) + 0) * SIMD_SZ + j] = s->e[(2 * (i * 3 + m) + 0) * SIMD_SZ + j] =
cos(A); cosf(A);
s->e[(2 * (i * 3 + m) + 1) * SIMD_SZ + j] = s->e[(2 * (i * 3 + m) + 1) * SIMD_SZ + j] =
sin(A); sinf(A);
} }
} }
rffti1_ps(N / SIMD_SZ, s->twiddle, s->ifac); rffti1_ps(N / SIMD_SZ, s->twiddle, s->ifac);
@ -1453,11 +1453,11 @@ static PFFFT_Setup *new_setup_simd(int N, pffft_transform_t transform)
int i = k / SIMD_SZ; int i = k / SIMD_SZ;
int j = k % SIMD_SZ; int j = k % SIMD_SZ;
for (m = 0; m < SIMD_SZ - 1; ++m) { for (m = 0; m < SIMD_SZ - 1; ++m) {
float A = -2 * M_PI * (m + 1) * k / N; float A = -2 * M_PIf * (m + 1) * k / N;
s->e[(2 * (i * 3 + m) + 0) * SIMD_SZ + j] = s->e[(2 * (i * 3 + m) + 0) * SIMD_SZ + j] =
cos(A); cosf(A);
s->e[(2 * (i * 3 + m) + 1) * SIMD_SZ + j] = s->e[(2 * (i * 3 + m) + 1) * SIMD_SZ + j] =
sin(A); sinf(A);
} }
} }
cffti1_ps(N / SIMD_SZ, s->twiddle, s->ifac); cffti1_ps(N / SIMD_SZ, s->twiddle, s->ifac);
@ -1765,7 +1765,7 @@ static NEVER_INLINE(void) pffft_real_finalize(int Ncvec, const v4sf * in,
v4sf_union cr, ci, *uout = (v4sf_union *) out; v4sf_union cr, ci, *uout = (v4sf_union *) out;
v4sf save = in[7], zero = VZERO(); v4sf save = in[7], zero = VZERO();
float xr0, xi0, xr1, xi1, xr2, xi2, xr3, xi3; float xr0, xi0, xr1, xi1, xr2, xi2, xr3, xi3;
static const float s = M_SQRT2 / 2; static const float s = M_SQRT2f / 2;
cr.v = in[0]; cr.v = in[0];
ci.v = in[Ncvec * 2 - 1]; ci.v = in[Ncvec * 2 - 1];
@ -1871,7 +1871,7 @@ static NEVER_INLINE(void) pffft_real_preprocess(int Ncvec, const v4sf * in,
v4sf_union Xr, Xi, *uout = (v4sf_union *) out; v4sf_union Xr, Xi, *uout = (v4sf_union *) out;
float cr0, ci0, cr1, ci1, cr2, ci2, cr3, ci3; float cr0, ci0, cr1, ci1, cr2, ci2, cr3, ci3;
static const float s = M_SQRT2; static const float s = M_SQRT2f;
assert(in != out); assert(in != out);
for (k = 0; k < 4; ++k) { for (k = 0; k < 4; ++k) {
Xr.f[k] = ((float *)in)[8 * k]; Xr.f[k] = ((float *)in)[8 * k];

4
src/modules/module-loopback.c
View file

@ -248,7 +248,7 @@ static void capture_destroy(void *d)
static void recalculate_delay(struct impl *impl) static void recalculate_delay(struct impl *impl)
{ {
uint32_t target = impl->rate * impl->target_delay, cdelay, pdelay; uint32_t target = (uint32_t)(impl->rate * impl->target_delay), cdelay, pdelay;
uint32_t delay, w; uint32_t delay, w;
struct pw_time pwt; struct pw_time pwt;
@ -435,7 +435,7 @@ static void param_format_changed(struct impl *impl, const struct spa_pod *param,
static void recalculate_buffer(struct impl *impl) static void recalculate_buffer(struct impl *impl)
{ {
if (impl->target_delay > 0.0f && impl->channels > 0 && impl->rate > 0) { if (impl->target_delay > 0.0f && impl->channels > 0 && impl->rate > 0) {
uint32_t delay = impl->rate * impl->target_delay; uint32_t delay = (uint32_t)(impl->rate * impl->target_delay);
void *data; void *data;
impl->buffer_size = (delay + (1u<<15)) * 4; impl->buffer_size = (delay + (1u<<15)) * 4;

6
src/modules/module-pipe-tunnel.c
View file

@ -199,7 +199,7 @@ struct impl {
struct spa_dll dll; struct spa_dll dll;
float max_error; float max_error;
float corr; double corr;
uint64_t next_time; uint64_t next_time;
unsigned int have_sync:1; unsigned int have_sync:1;
@ -244,7 +244,7 @@ static void on_timeout(void *d, uint64_t expirations)
pw_log_debug("timeout %"PRIu64, duration); pw_log_debug("timeout %"PRIu64, duration);
current_time = impl->next_time; current_time = impl->next_time;
impl->next_time += duration / impl->corr * 1e9 / rate; impl->next_time += (uint64_t)(duration / impl->corr * 1e9 / rate);
avail = spa_ringbuffer_get_read_index(&impl->ring, &index); avail = spa_ringbuffer_get_read_index(&impl->ring, &index);
if (SPA_LIKELY(pos)) { if (SPA_LIKELY(pos)) {
@ -376,7 +376,7 @@ static void update_rate(struct impl *impl, uint32_t filled)
if (!impl->driving) { if (!impl->driving) {
SPA_FLAG_SET(impl->rate_match->flags, SPA_IO_RATE_MATCH_FLAG_ACTIVE); SPA_FLAG_SET(impl->rate_match->flags, SPA_IO_RATE_MATCH_FLAG_ACTIVE);
impl->rate_match->rate = 1.0f / impl->corr; impl->rate_match->rate = 1.0 / impl->corr;
} }
} }

2
src/modules/module-protocol-pulse/format.c
View file

@ -868,7 +868,7 @@ int format_info_to_spec(const struct format_info *info, struct sample_spec *ss,
if (spa_json_is_float(val, len)) { if (spa_json_is_float(val, len)) {
if (spa_json_parse_float(val, len, &f) <= 0) if (spa_json_parse_float(val, len, &f) <= 0)
return -EINVAL; return -EINVAL;
ss->channels = f; ss->channels = (uint8_t)f;
} else if (spa_json_is_array(val, len)) { } else if (spa_json_is_array(val, len)) {
return -ENOTSUP; return -ENOTSUP;
} else if (spa_json_is_object(val, len)) { } else if (spa_json_is_object(val, len)) {

2
src/modules/module-protocol-pulse/message.c
View file

@ -636,7 +636,7 @@ int message_put(struct message *m, ...)
write_dict(m, va_arg(va, struct spa_dict*), true); write_dict(m, va_arg(va, struct spa_dict*), true);
break; break;
case TAG_VOLUME: case TAG_VOLUME:
write_volume(m, va_arg(va, double)); write_volume(m, (float)va_arg(va, double));
break; break;
case TAG_FORMAT_INFO: case TAG_FORMAT_INFO:
write_format_info(m, va_arg(va, struct format_info*)); write_format_info(m, va_arg(va, struct format_info*));

2
src/modules/module-protocol-pulse/pulse-server.c
View file

@ -4559,7 +4559,7 @@ static int do_update_stream_sample_rate(struct client *client, uint32_t command,
stream->rate = rate; stream->rate = rate;
corr = (double)rate/(double)stream->ss.rate; corr = (float)rate/(float)stream->ss.rate;
pw_stream_set_control(stream->stream, SPA_PROP_rate, 1, &corr, NULL); pw_stream_set_control(stream->stream, SPA_PROP_rate, 1, &corr, NULL);
return reply_simple_ack(client, tag); return reply_simple_ack(client, tag);

2
src/modules/module-protocol-pulse/volume.c
View file

@ -79,7 +79,7 @@ int volume_parse_param(const struct spa_pod *param, struct volume_info *info, bo
{ {
float step; float step;
if (spa_pod_get_float(&prop->value, &step) >= 0) if (spa_pod_get_float(&prop->value, &step) >= 0)
info->steps = 0x10000u * step; info->steps = (uint32_t)(0x10000u * step);
break; break;
} }
case SPA_PROP_channelMap: case SPA_PROP_channelMap:

4
src/modules/module-pulse-tunnel.c
View file

@ -339,7 +339,7 @@ static void update_rate(struct impl *impl, uint32_t filled)
error = (float)impl->target_latency - (float)(current_latency); error = (float)impl->target_latency - (float)(current_latency);
error = SPA_CLAMP(error, -impl->max_error, impl->max_error); error = SPA_CLAMP(error, -impl->max_error, impl->max_error);
corr = spa_dll_update(&impl->dll, error); corr = (float)spa_dll_update(&impl->dll, error);
pw_log_debug("error:%f corr:%f current:%u target:%u", pw_log_debug("error:%f corr:%f current:%u target:%u",
error, corr, error, corr,
current_latency, impl->target_latency); current_latency, impl->target_latency);
@ -853,7 +853,7 @@ do_stream_sync_volumes(struct spa_loop *loop,
float soft_vols[SPA_AUDIO_MAX_CHANNELS]; float soft_vols[SPA_AUDIO_MAX_CHANNELS];
for (i = 0; i < impl->volume.channels; i++) { for (i = 0; i < impl->volume.channels; i++) {
vols[i] = pa_sw_volume_to_linear(impl->volume.values[i]); vols[i] = (float)pa_sw_volume_to_linear(impl->volume.values[i]);
soft_vols[i] = 1.0f; soft_vols[i] = 1.0f;
} }

2
src/modules/module-raop-sink.c
View file

@ -1639,7 +1639,7 @@ static void stream_props_changed(struct impl *impl, uint32_t id, const struct sp
soft_vols[i] = 1.0f; soft_vols[i] = 1.0f;
} }
volume /= n_vols; volume /= n_vols;
volume = SPA_CLAMPF(cbrt(volume) * 30 - 30, VOLUME_MIN, VOLUME_MAX); volume = SPA_CLAMPF(cbrtf(volume) * 30 - 30, VOLUME_MIN, VOLUME_MAX);
impl->volume = volume; impl->volume = volume;
rtsp_send_volume(impl); rtsp_send_volume(impl);

4
src/modules/module-rtp/audio.c
View file

@ -66,7 +66,7 @@ static void rtp_audio_process_playback(void *data)
error = (float)target_buffer - (float)avail; error = (float)target_buffer - (float)avail;
error = SPA_CLAMP(error, -impl->max_error, impl->max_error); error = SPA_CLAMP(error, -impl->max_error, impl->max_error);
corr = spa_dll_update(&impl->dll, error); corr = (float)spa_dll_update(&impl->dll, error);
pw_log_trace("avail:%u target:%u error:%f corr:%f", avail, pw_log_trace("avail:%u target:%u error:%f corr:%f", avail,
target_buffer, error, corr); target_buffer, error, corr);
@ -321,7 +321,7 @@ static void rtp_audio_process_capture(void *data)
uint32_t rate = pos->clock.rate.denom; uint32_t rate = pos->clock.rate.denom;
timestamp = pos->clock.position * impl->rate / rate; timestamp = pos->clock.position * impl->rate / rate;
next_nsec = pos->clock.next_nsec; next_nsec = pos->clock.next_nsec;
quantum = pos->clock.duration * SPA_NSEC_PER_SEC / (rate * pos->clock.rate_diff); quantum = (uint64_t)(pos->clock.duration * SPA_NSEC_PER_SEC / (rate * pos->clock.rate_diff));
} else { } else {
timestamp = expected_timestamp; timestamp = expected_timestamp;
next_nsec = 0; next_nsec = 0;

8
src/modules/module-rtp/midi.c
View file

@ -206,10 +206,10 @@ static int rtp_midi_receive_midi(struct impl *impl, uint8_t *packet, uint32_t ti
} }
pw_log_trace("%f %f %f %f", t, estimated, diff, impl->corr); pw_log_trace("%f %f %f %f", t, estimated, diff, impl->corr);
timestamp = t * impl->rate; timestamp = (uint32_t)(t * impl->rate);
impl->last_timestamp = ts; impl->last_timestamp = (float)ts;
impl->last_time = t; impl->last_time = (float)t;
} }
filled = spa_ringbuffer_get_write_index(&impl->ring, &write); filled = spa_ringbuffer_get_write_index(&impl->ring, &write);
@ -248,7 +248,7 @@ static int rtp_midi_receive_midi(struct impl *impl, uint8_t *packet, uint32_t ti
else else
offs += parse_varlen(&packet[offs], end - offs, &delta); offs += parse_varlen(&packet[offs], end - offs, &delta);
timestamp += delta * impl->corr; timestamp += (uint32_t)(delta * impl->corr);
spa_pod_builder_control(&b, timestamp, SPA_CONTROL_Midi); spa_pod_builder_control(&b, timestamp, SPA_CONTROL_Midi);
size = get_midi_size(&packet[offs], end - offs); size = get_midi_size(&packet[offs], end - offs);

2
src/modules/module-rtp/opus.c
View file

@ -71,7 +71,7 @@ static void rtp_opus_process_playback(void *data)
error = (float)target_buffer - (float)avail; error = (float)target_buffer - (float)avail;
error = SPA_CLAMP(error, -impl->max_error, impl->max_error); error = SPA_CLAMP(error, -impl->max_error, impl->max_error);
corr = spa_dll_update(&impl->dll, error); corr = (float)spa_dll_update(&impl->dll, error);
pw_log_trace("avail:%u target:%u error:%f corr:%f", avail, pw_log_trace("avail:%u target:%u error:%f corr:%f", avail,
target_buffer, error, corr); target_buffer, error, corr);

4
src/modules/module-rtp/stream.c
View file

@ -285,7 +285,7 @@ static void parse_audio_info(const struct pw_properties *props, struct spa_audio
static uint32_t msec_to_samples(struct impl *impl, float msec) static uint32_t msec_to_samples(struct impl *impl, float msec)
{ {
return msec * impl->rate / 1000; return (uint32_t)(msec * impl->rate / 1000);
} }
static float samples_to_msec(struct impl *impl, uint32_t samples) static float samples_to_msec(struct impl *impl, uint32_t samples)
{ {
@ -509,7 +509,7 @@ struct rtp_stream *rtp_stream_new(struct pw_core *core,
/* We're not expecting odd ptimes, so this modulo should be 0 */ /* We're not expecting odd ptimes, so this modulo should be 0 */
if (fmodf(impl->target_buffer, ptime != 0)) { if (fmodf(impl->target_buffer, ptime != 0)) {
pw_log_warn("sess.latency.msec should be an integer multiple of rtp.ptime"); pw_log_warn("sess.latency.msec should be an integer multiple of rtp.ptime");
impl->target_buffer = (impl->target_buffer / ptime) * impl->psamples; impl->target_buffer = (uint32_t)((impl->target_buffer / ptime) * impl->psamples);
} }
pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%d", impl->rate); pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%d", impl->rate);

2
src/modules/module-vban/audio.c
View file

@ -57,7 +57,7 @@ static void vban_audio_process_playback(void *data)
error = (float)target_buffer - (float)avail; error = (float)target_buffer - (float)avail;
error = SPA_CLAMP(error, -impl->max_error, impl->max_error); error = SPA_CLAMP(error, -impl->max_error, impl->max_error);
corr = spa_dll_update(&impl->dll, error); corr = (float)spa_dll_update(&impl->dll, error);
pw_log_debug("avail:%u target:%u error:%f corr:%f", avail, pw_log_debug("avail:%u target:%u error:%f corr:%f", avail,
target_buffer, error, corr); target_buffer, error, corr);

6
src/modules/module-vban/stream.c
View file

@ -358,8 +358,8 @@ struct vban_stream *vban_stream_new(struct pw_core *core,
if (!spa_atof(str, &max_ptime)) if (!spa_atof(str, &max_ptime))
max_ptime = DEFAULT_MAX_PTIME; max_ptime = DEFAULT_MAX_PTIME;
min_samples = min_ptime * impl->rate / 1000; min_samples = (uint32_t)(min_ptime * impl->rate / 1000);
max_samples = SPA_MIN(256, max_ptime * impl->rate / 1000); max_samples = SPA_MIN(256u, (uint32_t)(max_ptime * impl->rate / 1000));
float ptime = 0; float ptime = 0;
if ((str = pw_properties_get(props, "vban.ptime")) != NULL) if ((str = pw_properties_get(props, "vban.ptime")) != NULL)
@ -367,7 +367,7 @@ struct vban_stream *vban_stream_new(struct pw_core *core,
ptime = 0.0; ptime = 0.0;
if (ptime) { if (ptime) {
impl->psamples = ptime * impl->rate / 1000; impl->psamples = (uint32_t)(ptime * impl->rate / 1000);
} else { } else {
impl->psamples = impl->mtu / impl->stride; impl->psamples = impl->mtu / impl->stride;
impl->psamples = SPA_CLAMP(impl->psamples, min_samples, max_samples); impl->psamples = SPA_CLAMP(impl->psamples, min_samples, max_samples);

10
src/pipewire/stream.c
View file

@ -1219,11 +1219,11 @@ static int node_event_param(void *object, int seq,
vals = SPA_POD_BODY(pod); vals = SPA_POD_BODY(pod);
else if (spa_pod_is_double(pod)) { else if (spa_pod_is_double(pod)) {
double *v = SPA_POD_BODY(pod); double *v = SPA_POD_BODY(pod);
dbl[0] = v[0]; dbl[0] = (float)v[0];
if (n_vals > 1) if (n_vals > 1)
dbl[1] = v[1]; dbl[1] = (float)v[1];
if (n_vals > 2) if (n_vals > 2)
dbl[2] = v[2]; dbl[2] = (float)v[2];
vals = dbl; vals = dbl;
} }
else if (spa_pod_is_bool(pod) && n_vals > 0) { else if (spa_pod_is_bool(pod) && n_vals > 0) {
@ -1301,7 +1301,7 @@ static int node_event_param(void *object, int seq,
if (spa_pod_get_double(&prop->value, &value_d) < 0) if (spa_pod_get_double(&prop->value, &value_d) < 0)
continue; continue;
n_values = 1; n_values = 1;
value_f = value_d; value_f = (float)value_d;
values = &value_f; values = &value_f;
break; break;
case SPA_TYPE_Bool: case SPA_TYPE_Bool:
@ -2337,7 +2337,7 @@ int pw_stream_get_time_n(struct pw_stream *stream, struct pw_time *time, size_t
else else
time->queued = (int64_t)(impl->queued.incount - time->queued); time->queued = (int64_t)(impl->queued.incount - time->queued);
time->delay += ((impl->latency.min_quantum + impl->latency.max_quantum) / 2) * quantum; time->delay += (int64_t)(((impl->latency.min_quantum + impl->latency.max_quantum) / 2.0f) * quantum);
time->delay += (impl->latency.min_rate + impl->latency.max_rate) / 2; time->delay += (impl->latency.min_rate + impl->latency.max_rate) / 2;
time->delay += ((impl->latency.min_ns + impl->latency.max_ns) / 2) * time->rate.denom / SPA_NSEC_PER_SEC; time->delay += ((impl->latency.min_ns + impl->latency.max_ns) / 2) * time->rate.denom / SPA_NSEC_PER_SEC;

2
src/tests/test-endpoint.c
View file

@ -215,7 +215,7 @@ endpoint_init(struct endpoint * self)
self->info.params = param_info; self->info.params = param_info;
self->info.n_params = SPA_N_ELEMENTS (param_info); self->info.n_params = SPA_N_ELEMENTS (param_info);
self->props.volume = 0.9; self->props.volume = 0.9f;
self->props.mute = false; self->props.mute = false;
} }

2
src/tools/midifile.c
View file

@ -433,7 +433,7 @@ int midi_file_write_event(struct midi_file *mf, const struct midi_event *event)
tr = &mf->tracks[event->track]; tr = &mf->tracks[event->track];
tick = event->sec * (1000000.0 * mf->info.division) / (double)mf->tempo; tick = (uint32_t)(event->sec * (1000000.0 * mf->info.division) / (double)mf->tempo);
CHECK_RES(write_varlen(mf, tr, tick - tr->tick)); CHECK_RES(write_varlen(mf, tr, tick - tr->tick));
tr->tick = tick; tr->tick = tick;

10
src/tools/pw-cat.c
View file

@ -1069,7 +1069,7 @@ static int midi_play(struct data *d, void *src, unsigned int n_frames, bool *nul
return res; return res;
} }
frame = ev.sec * d->position->clock.rate.denom; frame = (uint32_t)(ev.sec * d->position->clock.rate.denom);
if (frame < first_frame) if (frame < first_frame)
frame = 0; frame = 0;
else if (frame < last_frame) else if (frame < last_frame)
@ -1573,13 +1573,13 @@ static int setup_properties(struct data *data)
nom = data->latency_value * data->rate; nom = data->latency_value * data->rate;
break; break;
case unit_msec: case unit_msec:
nom = nearbyint((data->latency_value * data->rate) / 1000.0); nom = (unsigned int)nearbyint((data->latency_value * data->rate) / 1000.0);
break; break;
case unit_usec: case unit_usec:
nom = nearbyint((data->latency_value * data->rate) / 1000000.0); nom = (unsigned int)nearbyint((data->latency_value * data->rate) / 1000000.0);
break; break;
case unit_nsec: case unit_nsec:
nom = nearbyint((data->latency_value * data->rate) / 1000000000.0); nom = (unsigned int)nearbyint((data->latency_value * data->rate) / 1000000000.0);
break; break;
case unit_samples: case unit_samples:
nom = data->latency_value; nom = data->latency_value;
@ -1778,7 +1778,7 @@ int main(int argc, char *argv[])
break; break;
case OPT_VOLUME: case OPT_VOLUME:
data.volume = atof(optarg); data.volume = (float)atof(optarg);
break; break;
default: default:
goto error_usage; goto error_usage;

2
src/tools/pw-dump.c
View file

@ -279,7 +279,7 @@ static void put_double(struct data *d, const char *key, double val)
{ {
char buf[128]; char buf[128];
put_fmt(d, key, "%s%s%s", NUMBER, put_fmt(d, key, "%s%s%s", NUMBER,
spa_json_format_float(buf, sizeof(buf), val), NORMAL); spa_json_format_float(buf, sizeof(buf), (float)val), NORMAL);
} }
static void put_value(struct data *d, const char *key, const char *val) static void put_value(struct data *d, const char *key, const char *val)

2
src/tools/pw-loopback.c
View file

@ -163,7 +163,7 @@ int main(int argc, char *argv[])
data.latency = atoi(optarg) * DEFAULT_RATE / SPA_MSEC_PER_SEC; data.latency = atoi(optarg) * DEFAULT_RATE / SPA_MSEC_PER_SEC;
break; break;
case 'd': case 'd':
data.delay = atof(optarg); data.delay = (float)atof(optarg);
break; break;
case 'C': case 'C':
pw_properties_set(data.capture_props, PW_KEY_TARGET_OBJECT, optarg); pw_properties_set(data.capture_props, PW_KEY_TARGET_OBJECT, optarg);

6
src/tools/pw-profiler.c
View file

@ -182,8 +182,8 @@ static void dump_point(struct data *d, struct point *point)
int64_t d1, d2; int64_t d1, d2;
int64_t delay, period_usecs; int64_t delay, period_usecs;
#define CLOCK_AS_USEC(cl,val) (val * (float)SPA_USEC_PER_SEC / (cl)->rate.denom) #define CLOCK_AS_USEC(cl,val) (int64_t)(val * (float)SPA_USEC_PER_SEC / (cl)->rate.denom)
#define CLOCK_AS_SUSEC(cl,val) (val * (float)SPA_USEC_PER_SEC / ((cl)->rate.denom * (cl)->rate_diff)) #define CLOCK_AS_SUSEC(cl,val) (int64_t)(val * (float)SPA_USEC_PER_SEC / ((cl)->rate.denom * (cl)->rate_diff))
delay = CLOCK_AS_USEC(&point->clock, point->clock.delay); delay = CLOCK_AS_USEC(&point->clock, point->clock.delay);
period_usecs = CLOCK_AS_SUSEC(&point->clock, point->clock.duration); period_usecs = CLOCK_AS_SUSEC(&point->clock, point->clock.duration);
@ -193,7 +193,7 @@ static void dump_point(struct data *d, struct point *point)
if (d1 > period_usecs * 1.3 || if (d1 > period_usecs * 1.3 ||
d2 > period_usecs * 1.3) d2 > period_usecs * 1.3)
d1 = d2 = period_usecs * 1.4; d1 = d2 = (int64_t)(period_usecs * 1.4);
/* 4 columns for the driver */ /* 4 columns for the driver */
fprintf(d->output, "%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t", fprintf(d->output, "%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t",

2
test/test-spa-json.c
View file

@ -307,7 +307,7 @@ PWTEST(json_parse)
/* non-null terminated strings OK */ /* non-null terminated strings OK */
json = "1.234"; json = "1.234";
spa_json_init(&it[0], json, 4); spa_json_init(&it[0], json, 4);
expect_float(&it[0], 1.23); expect_float(&it[0], 1.23f);
expect_end(&it[0]); expect_end(&it[0]);
json = "1234"; json = "1234";

32
test/test-spa-utils.c
View file

@ -636,14 +636,14 @@ PWTEST(utils_strtof)
pwtest_bool_true(spa_atof("0x1", &v)); pwtest_double_eq(v, 1.0f); pwtest_bool_true(spa_atof("0x1", &v)); pwtest_double_eq(v, 1.0f);
v = 0xabcd; v = 0xabcd;
pwtest_bool_false(spa_atof("0,00", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atof("0,00", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atof("fabc", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atof("fabc", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atof("1.bogus", &v));pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atof("1.bogus", &v));pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atof("1.0a", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atof("1.0a", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atof(" ", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atof(" ", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atof(" ", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atof(" ", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atof("", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atof("", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atof(NULL, &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atof(NULL, &v)); pwtest_int_eq((int)v, 0xabcd);
return PWTEST_PASS; return PWTEST_PASS;
} }
@ -659,14 +659,14 @@ PWTEST(utils_strtod)
pwtest_bool_true(spa_atod("0x1", &v)); pwtest_double_eq(v, 1.0); pwtest_bool_true(spa_atod("0x1", &v)); pwtest_double_eq(v, 1.0);
v = 0xabcd; v = 0xabcd;
pwtest_bool_false(spa_atod("0,00", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atod("0,00", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atod("fabc", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atod("fabc", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atod("1.bogus", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atod("1.bogus", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atod("1.0a", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atod("1.0a", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atod(" ", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atod(" ", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atod(" ", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atod(" ", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atod("", &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atod("", &v)); pwtest_int_eq((int)v, 0xabcd);
pwtest_bool_false(spa_atod(NULL, &v)); pwtest_int_eq(v, 0xabcd); pwtest_bool_false(spa_atod(NULL, &v)); pwtest_int_eq((int)v, 0xabcd);
return PWTEST_PASS; return PWTEST_PASS;
} }