From 4f0b4c8859033756b9b6c60fdc64e3deb0c60d9b Mon Sep 17 00:00:00 2001 From: Jingbo Hou Date: Fri, 18 Sep 2026 11:05:31 +0800 Subject: [PATCH] Fix MSVC build conflict caused by warning log macro - Remove warning() macro alias from clog.h which clashes with __pragma(warning(...)) expansion in MSVC UCRT headers (C4068) - Replace all warning() call sites with the identical warn() alias across renderer, limiter, and oar sources Signed-off-by: Jingbo Hou --- src/common/clog.h | 1 - src/limiter/audio_effect_peak_limiter.c | 16 +++++++-------- src/limiter/oar_limiter.c | 6 +++--- src/oar.c | 20 +++++++++---------- src/renderer/audio_element_renderer.c | 24 +++++++++++------------ src/renderer/audio_elements_renderer.c | 26 ++++++++++++------------- src/renderer/audio_renderer_base.c | 24 +++++++++++------------ src/renderer/obr/obr.c | 21 ++++++++++---------- src/renderer/olr/olr.c | 12 ++++++------ 9 files changed, 73 insertions(+), 77 deletions(-) diff --git a/src/common/clog.h b/src/common/clog.h index 3706199..becde95 100644 --- a/src/common/clog.h +++ b/src/common/clog.h @@ -45,7 +45,6 @@ void set_log_level(log_level_t level); #define fatal(fmt, ...) def_log(ck_log_level_fatal, fmt, ##__VA_ARGS__) #define error(fmt, ...) def_log(ck_log_level_error, fmt, ##__VA_ARGS__) #define warn(fmt, ...) def_log(ck_log_level_warn, fmt, ##__VA_ARGS__) -#define warning(fmt, ...) def_log(ck_log_level_warn, fmt, ##__VA_ARGS__) #define info(fmt, ...) def_log(ck_log_level_info, fmt, ##__VA_ARGS__) #define debug(fmt, ...) def_log(ck_log_level_debug, fmt, ##__VA_ARGS__) #define trace(fmt, ...) def_log(ck_log_level_trace, fmt, ##__VA_ARGS__) diff --git a/src/limiter/audio_effect_peak_limiter.c b/src/limiter/audio_effect_peak_limiter.c index afb8acf..40b5715 100644 --- a/src/limiter/audio_effect_peak_limiter.c +++ b/src/limiter/audio_effect_peak_limiter.c @@ -116,11 +116,11 @@ static inline float hard_limit(float sample, float threshold) { */ static inline float clampf(float val, float min, float max, const char* name) { if (val < min) { - warning("%s %.4f < min %.4f, clamped", name, val, min); + warn("%s %.4f < min %.4f, clamped", name, val, min); return min; } if (val > max) { - warning("%s %.4f > max %.4f, clamped", name, val, max); + warn("%s %.4f > max %.4f, clamped", name, val, max); return max; } return val; @@ -368,15 +368,15 @@ audio_effect_peak_limiter_t* audio_effect_peak_limiter_create( int min_delay = (int)(def_delay_sec_min * sample_rate); int max_delay = (int)(def_delay_sec_max * sample_rate); if (delay_size < min_delay) { - warning("delay_size %d < min %d (0.1ms), clamped", delay_size, min_delay); + warn("delay_size %d < min %d (0.1ms), clamped", delay_size, min_delay); delay_size = min_delay; } if (delay_size > max_delay) { - warning("delay_size %d > max %d (20ms), clamped", delay_size, max_delay); + warn("delay_size %d > max %d (20ms), clamped", delay_size, max_delay); delay_size = max_delay; } } else if (delay_size < 0) { - warning("delay_size %d < 0, set to 0 (no-delay mode)", delay_size); + warn("delay_size %d < 0, set to 0 (no-delay mode)", delay_size); delay_size = 0; } @@ -384,7 +384,7 @@ audio_effect_peak_limiter_t* audio_effect_peak_limiter_create( if (delay_size > 0) { float look_ahead_sec = (float)delay_size / sample_rate; if (atk_sec > look_ahead_sec) { - warning( + warn( "attack %.4fs > look-ahead %.4fs, hard-limit will trigger frequently", atk_sec, look_ahead_sec); } @@ -406,14 +406,14 @@ audio_effect_peak_limiter_t* audio_effect_peak_limiter_create( if (delay_size > 0) { ths->delay_data = def_mallocz(float, num_channels * ths->delay_size); if (!ths->delay_data) { - warning("Failed to allocate delay_data"); + warn("Failed to allocate delay_data"); audio_effect_peak_limiter_destroy(ths); return NULL; } ths->peak_data = def_mallocz(float, ths->delay_size); if (!ths->peak_data) { - warning("Failed to allocate peak_data"); + warn("Failed to allocate peak_data"); audio_effect_peak_limiter_destroy(ths); return NULL; } diff --git a/src/limiter/oar_limiter.c b/src/limiter/oar_limiter.c index 31d936a..6138fc5 100644 --- a/src/limiter/oar_limiter.c +++ b/src/limiter/oar_limiter.c @@ -50,7 +50,7 @@ oar_limiter_t *oar_limiter_create(const oar_limiter_config_t *config) { config->attack_sec, config->release_sec, (config->look_ahead_sec * config->sample_rate)); if (!lim->peak_limiter) { - warning("Failed to create peak limiter"); + warn("Failed to create peak limiter"); def_free(lim); return NULL; } @@ -61,7 +61,7 @@ oar_limiter_t *oar_limiter_create(const oar_limiter_config_t *config) { int out_buf_capacity = def_max(config->samples_per_channel, lim->delay_size); lim->out_buf = def_mallocz(float, (config->num_channels * out_buf_capacity)); if (!lim->out_buf) { - warning("Failed to allocate limiter output buffer"); + warn("Failed to allocate limiter output buffer"); audio_effect_peak_limiter_destroy(lim->peak_limiter); def_free(lim); return NULL; @@ -102,7 +102,7 @@ int oar_limiter_process(oar_limiter_t *lim, oar_audio_block_t *output) { lim->peak_limiter, output->data, lim->out_buf, samples); if (returned < 0) { - warning("Limiter process error: %d", returned); + warn("Limiter process error: %d", returned); return ck_oar_error_inval; } diff --git a/src/oar.c b/src/oar.c index b31a64e..e73764a 100644 --- a/src/oar.c +++ b/src/oar.c @@ -165,7 +165,7 @@ oar_t *oar_create(const oar_config_t *config) { }; oar->limiter = oar_limiter_create(&limiter_config); if (!oar->limiter) { - warning("Failed to create limiter"); + warn("Failed to create limiter"); /* Continue without limiter - don't fail OAR creation */ } @@ -180,7 +180,7 @@ oar_t *oar_create(const oar_config_t *config) { oar->mixed = wav_writer_open(ck_tag_mixed, 0, oar->config.sampling_rate, layout_channels_count(oar->config.target_layout)); - if (!oar->mixed) warning("Failed to open WAV file for output"); + if (!oar->mixed) warn("Failed to open WAV file for output"); #endif return oar; @@ -272,7 +272,7 @@ int oar_add_audio_element(oar_t *oar, uint32_t gid, uint32_t id, if (vector_find(oar->groups, def_value_wrap_instance_u32(gid), _find_group_id, &v) < 0) { - warning("Audio group %u does not exist.", gid); + warn("Audio group %u does not exist.", gid); return ck_oar_error_inval; } group = def_value_wrap_type_ptr(audio_group_t, &v); @@ -281,7 +281,7 @@ int oar_add_audio_element(oar_t *oar, uint32_t gid, uint32_t id, audio_group_t *_group = def_value_wrap_ptr(vector_at(oar->groups, i)); if (vector_find(_group->renderers, def_value_wrap_instance_u32(id), _find_element_id, &v) >= 0) { - warning("Audio element %u already exists in another group.", id); + warn("Audio element %u already exists in another group.", id); return ck_oar_error_busy; } } @@ -308,8 +308,8 @@ int oar_add_audio_element(oar_t *oar, uint32_t gid, uint32_t id, renderer = binaural_renderer; break; } else { - warning("Failed to add element %u to binaural renderer. Error: %d", - id, ret); + warn("Failed to add element %u to binaural renderer. Error: %d", id, + ret); } } } @@ -437,15 +437,13 @@ int oar_set_metadata_unit_to_process(oar_t *oar, oar_metadata_type_t type, if (!oar) return ck_oar_error_inval; if (type != ck_metadata_object_positions) { - warning( - "Only object positions are supported for setting samples to process."); + warn("Only object positions are supported for setting samples to process."); return ck_oar_error_notsup; } if (samples == 0 || oar->config.samples_per_channel < samples) { - warning( - "metadata unit samples (%u) is invalid for samples_per_channel (%u).", - samples, oar->config.samples_per_channel); + warn("metadata unit samples (%u) is invalid for samples_per_channel (%u).", + samples, oar->config.samples_per_channel); return ck_oar_error_inval; } diff --git a/src/renderer/audio_element_renderer.c b/src/renderer/audio_element_renderer.c index 73087ae..4957250 100644 --- a/src/renderer/audio_element_renderer.c +++ b/src/renderer/audio_element_renderer.c @@ -182,7 +182,7 @@ audio_element_renderer_t *audio_element_renderer_new( ctx->in = audio_element_config_to_ri_id(config); if (ctx->in == ck_rid_none) { - warning("Unsupported input self."); + warn("Unsupported input self."); audio_element_renderer_delete(&self->base); return 0; } @@ -200,7 +200,7 @@ audio_element_renderer_t *audio_element_renderer_new( self->base.lib = renderer_library_manager_find_library(manager, ctx); if (!self->base.lib) { - warning("Failed to find self library for stream %u", id); + warn("Failed to find self library for stream %u", id); audio_element_renderer_delete(&self->base); return 0; } @@ -237,7 +237,7 @@ audio_element_renderer_t *audio_element_renderer_new( : ck_binaural_filter_profile_default; if (self->base.lib->set_attribute(ctx, ck_attribute_add_element, &set) != ck_oar_ok) { - warning("Failed to set binaural filter profile for stream %u", id); + warn("Failed to set binaural filter profile for stream %u", id); audio_element_renderer_delete(&self->base); return 0; } @@ -256,7 +256,7 @@ audio_element_renderer_t *audio_element_renderer_new( wav_writer_open(ck_tag_rendered, id, ctx->sample_rate, layout_channels_count(oar_config->target_layout)); if (!self->rendered) - warning("Failed to open WAV file for rendered stream %u", id); + warn("Failed to open WAV file for rendered stream %u", id); #endif return self; @@ -283,8 +283,8 @@ static int audio_element_renderer_update_metadata( if (!self) return ck_oar_error_inval; if (self->element.eid != element_id) { - warning("Element ID mismatch: expected %u, got %u", self->element.eid, - element_id); + warn("Element ID mismatch: expected %u, got %u", self->element.eid, + element_id); return ck_oar_error_inval; } @@ -307,20 +307,20 @@ int audio_element_renderer_update_data(audio_renderer_base_t *base, uint32_t id, if (!self) return ck_oar_error_inval; if (self->element.eid != id) { - warning("Element ID mismatch: expected %u, got %u", self->element.eid, id); + warn("Element ID mismatch: expected %u, got %u", self->element.eid, id); return ck_oar_error_inval; } if (!block || !block->data) return ck_oar_error_inval; if (block->channels != self->base.block.channels) { - warning("Input block channels (%u) don't match self channels (%u)", - block->channels, self->base.block.channels); + warn("Input block channels (%u) don't match self channels (%u)", + block->channels, self->base.block.channels); return ck_oar_error_inval; } if (block->samples_per_channel != self->base.block.samples_per_channel) { - warning( + warn( "Input block samples per channel (%u) don't match self samples per " "channel (%u)", block->samples_per_channel, self->base.block.samples_per_channel); @@ -421,8 +421,8 @@ int audio_element_renderer_set_element_head_locked(audio_renderer_base_t *base, if (!self) return ck_oar_error_inval; if (self->element.eid != element_id) { - warning("Element ID mismatch: expected %u, got %u", self->element.eid, - element_id); + warn("Element ID mismatch: expected %u, got %u", self->element.eid, + element_id); return ck_oar_error_inval; } diff --git a/src/renderer/audio_elements_renderer.c b/src/renderer/audio_elements_renderer.c index 9213465..ebcda4b 100644 --- a/src/renderer/audio_elements_renderer.c +++ b/src/renderer/audio_elements_renderer.c @@ -117,7 +117,7 @@ audio_elements_renderer_t *audio_elements_renderer_new( self->base.lib = renderer_library_manager_find_library(manager, ctx); if (!self->base.lib) { - warning("Failed to find renderer library for stream %u", id); + warn("Failed to find renderer library for stream %u", id); def_free(self); return 0; } @@ -145,7 +145,7 @@ audio_elements_renderer_t *audio_elements_renderer_new( wav_writer_open(ck_tag_rendered, id, oar_config->sampling_rate, layout_channels_count(oar_config->target_layout)); if (!self->rendered) - warning("Failed to open WAV file for rendered stream %u", id); + warn("Failed to open WAV file for rendered stream %u", id); #endif return self; @@ -178,7 +178,7 @@ int audio_elements_renderer_add_element( if (!self || !config) return ck_oar_error_inval; if (hash_map_get(self->element_map, element_id)) { - warning("Element %u already exists", element_id); + warn("Element %u already exists", element_id); return ck_oar_error_busy; } @@ -205,7 +205,7 @@ int audio_elements_renderer_add_element( &self->base.ctx, ck_attribute_head_tracking, &self->base.head_tracking_enabled); if (err != ck_oar_ok) - warning("Failed to propagate head tracking state: %d", err); + warn("Failed to propagate head tracking state: %d", err); } } @@ -242,7 +242,7 @@ int audio_elements_renderer_remove_element(audio_renderer_base_t *base, audio_element_context_t *ctx = def_value_wrap_optional_type_ptr( audio_element_context_t, hash_map_get(self->element_map, element_id)); if (!ctx) { - warning("Element %u not found for removal", element_id); + warn("Element %u not found for removal", element_id); return ck_oar_error_inval; } @@ -251,7 +251,7 @@ int audio_elements_renderer_remove_element(audio_renderer_base_t *base, int ret = self->base.lib->set_attribute( &self->base.ctx, ck_attribute_remove_element, &lib_index); if (ret != ck_oar_ok) { - warning( + warn( "Cannot remove element %u from renderer library (error %d). " "Removal aborted; element remains active.", element_id, ret); @@ -316,7 +316,7 @@ int audio_elements_renderer_update_element_metadata( (audio_element_context_t *)def_value_wrap_optional_ptr( hash_map_get(self->element_map, element_id)); if (!ctx) { - warning("Element %u not found", element_id); + warn("Element %u not found", element_id); return ck_oar_error_inval; } @@ -343,21 +343,21 @@ int audio_elements_renderer_add_data(audio_renderer_base_t *base, (audio_element_context_t *)def_value_wrap_optional_ptr( hash_map_get(self->element_map, element_id)); if (!ctx) { - warning("Element %u not found", element_id); + warn("Element %u not found", element_id); return ck_oar_error_inval; } // Validate block dimensions match config to prevent OBR buffer size mismatch // crash and heap overflow from inconsistent stride/length in memcpy. if (block->samples_per_channel != self->base.ctx.samples_per_frame) { - warning("Input block samples per channel (%u) don't match config (%u)", - block->samples_per_channel, self->base.ctx.samples_per_frame); + warn("Input block samples per channel (%u) don't match config (%u)", + block->samples_per_channel, self->base.ctx.samples_per_frame); return ck_oar_error_inval; } if (block->channels != (uint32_t)rid_channels_count(ctx->rid)) { - warning("Input block channels (%u) don't match element channels (%u)", - block->channels, rid_channels_count(ctx->rid)); + warn("Input block channels (%u) don't match element channels (%u)", + block->channels, rid_channels_count(ctx->rid)); return ck_oar_error_inval; } @@ -483,7 +483,7 @@ int audio_elements_renderer_set_element_head_locked(audio_renderer_base_t *base, (audio_element_context_t *)def_value_wrap_optional_ptr( hash_map_get(self->element_map, element_id)); if (!ctx) { - warning("Element %u not found", element_id); + warn("Element %u not found", element_id); return ck_oar_error_inval; } diff --git a/src/renderer/audio_renderer_base.c b/src/renderer/audio_renderer_base.c index e8cd862..aa866bd 100644 --- a/src/renderer/audio_renderer_base.c +++ b/src/renderer/audio_renderer_base.c @@ -79,7 +79,7 @@ int audio_element_context_init(audio_element_context_t *ctx, uint32_t id, #ifdef __as_dbg__ ctx->original = wav_writer_open(ck_tag_original, id, sample_rate, rid_channels_count(ctx->rid)); - if (!ctx->original) warning("Failed to open WAV file for stream %u", id); + if (!ctx->original) warn("Failed to open WAV file for stream %u", id); #endif return ck_oar_ok; @@ -183,7 +183,7 @@ void metadata_item_elapse(metadata_item_t *item, uint32_t samples_per_channel) { } if (item->start > item->duration) { - warning( + warn( "Metadata item %d has negative duration (%d vs %d). reset metadata " "item.", item->id, item->start, item->duration); @@ -244,8 +244,8 @@ int audio_block_sub_frames_apply_gain(oar_audio_block_t *block, gain_value = db_to_linear_float32(metadata->gain.gain_array[relative_pos]); } else { - warning("Gain array out of bounds for metadata id %u", - metadata->gain.id); + warn("Gain array out of bounds for metadata id %u", + metadata->gain.id); } } else if (metadata->gain.param_type == ck_param_animated) { /* Default to 0 dB (unity) if no animation type matches */ @@ -278,9 +278,9 @@ int audio_block_sub_frames_apply_gain(oar_audio_block_t *block, 0.5f, metadata->duration, relative_pos)); } else { - warning("Unknown animation type %d for gain metadata id %u", - metadata->gain.animated_gains.animation_type, - metadata->gain.id); + warn("Unknown animation type %d for gain metadata id %u", + metadata->gain.animated_gains.animation_type, + metadata->gain.id); } /* Interpolate in dB domain, then convert to linear */ gain_value = db_to_linear_float32(gain_value); @@ -367,9 +367,9 @@ oar_metadata_t *metadata_constant_polar_positions_create( distance_anim->end), bezier_linear_factor_get(metadata->duration, relative_pos)); } else { - warning("Unsupported animation type (%u) for polar object positions.", - metadata->object_positions.animated_polar_positions[obj_idx] - .animation_type); + warn("Unsupported animation type (%u) for polar object positions.", + metadata->object_positions.animated_polar_positions[obj_idx] + .animation_type); } } else { @@ -422,7 +422,7 @@ oar_metadata_t *metadata_constant_polar_positions_create( cartesian_pos.x = 0.0f; cartesian_pos.y = 0.0f; cartesian_pos.z = 0.0f; - warning( + warn( "Unsupported animation type (%u) for cartesian object positions.", metadata->object_positions.animated_cartesian_positions[obj_idx] .animation_type); @@ -463,7 +463,7 @@ int audio_renderer_enable_head_tracking(audio_renderer_base_t *base, ret = base->lib->set_attribute(&base->ctx, ck_attribute_head_tracking, &enable); if (ret != ck_oar_ok) { - warning("Failed to set head tracking for renderer %s", base->lib->id); + warn("Failed to set head tracking for renderer %s", base->lib->id); } } diff --git a/src/renderer/obr/obr.c b/src/renderer/obr/obr.c index 0d9f70d..45ce882 100644 --- a/src/renderer/obr/obr.c +++ b/src/renderer/obr/obr.c @@ -154,12 +154,12 @@ static int _set_attribute(renderer_library_context_t *ctx, _get_binaural_filter_profile(params->profile); if (element_type == kObrInvalidType) { - warning("Unsupported element rendering id 0x%x", params->id); + warn("Unsupported element rendering id 0x%x", params->id); return ck_oar_error_inval; } if (obr_add_audio_element(obr->api, element_type, profile) < 0) { - warning("Failed to add element rendering id %d", params->id); + warn("Failed to add element rendering id %d", params->id); return ck_oar_error_inval; } @@ -175,7 +175,7 @@ static int _set_attribute(renderer_library_context_t *ctx, if (num_elements == 0) return ck_oar_error_inval; if (index != (uint32_t)(num_elements - 1)) return ck_oar_error_notsup; if (obr_remove_last_audio_element(obr->api) < 0) { - warning("Failed to remove audio element at index %u", index); + warn("Failed to remove audio element at index %u", index); return ck_oar_error_inval; } } break; @@ -183,14 +183,14 @@ static int _set_attribute(renderer_library_context_t *ctx, element_head_locked_t *params = (element_head_locked_t *)value; int num_elements = obr_get_number_of_audio_elements(obr->api); if (params->index >= num_elements) { - warning("Invalid element index %d, element count %d", params->index, - num_elements); + warn("Invalid element index %d, element count %d", params->index, + num_elements); return ck_oar_error_inval; } if (obr_set_element_head_locked(obr->api, params->index, !!params->locked) < 0) { - warning("Failed to set head locked state %u for element index %d", - !!params->locked, params->index); + warn("Failed to set head locked state %u for element index %d", + !!params->locked, params->index); return ck_oar_error_inval; } } break; @@ -209,13 +209,12 @@ static int _metadata_update(renderer_library_context_t *ctx, uint32_t index, int num_elements = obr_get_number_of_audio_elements(obr->api); if (metadata->object_positions.param_type != ck_param_constant || metadata->object_positions.position_type != ck_polar) { - warning("only support constant object positions with polar."); + warn("only support constant object positions with polar."); return ck_oar_error_notsup; } if (index >= num_elements) { - warning("Invalid element index %d, element count %d", index, - num_elements); + warn("Invalid element index %d, element count %d", index, num_elements); return ck_oar_error_inval; } @@ -232,7 +231,7 @@ static int _metadata_update(renderer_library_context_t *ctx, uint32_t index, if (obr_set_head_rotation( obr->api, metadata->head_rotation.w, metadata->head_rotation.x, metadata->head_rotation.y, metadata->head_rotation.z) < 0) { - warning("Failed to set head rotation for element index %d", index); + warn("Failed to set head rotation for element index %d", index); return ck_oar_error_inval; } break; diff --git a/src/renderer/olr/olr.c b/src/renderer/olr/olr.c index 47367c9..05233ad 100644 --- a/src/renderer/olr/olr.c +++ b/src/renderer/olr/olr.c @@ -123,7 +123,7 @@ static int _open(renderer_library_context_t *ctx) { // of _open but as a fallback: olr->num_objects = 1; // Default to 1 if somehow an unsupported type gets through - warning( + warn( "OLR: Unexpected input type %d in num_objects determination, " "defaulting to 1 object.", ctx->in); @@ -149,7 +149,7 @@ static int _set_attribute(renderer_library_context_t *ctx, rendering_attribute_t attr, const void *value) { switch (attr) { case ck_attribute_head_tracking: - warning( + warn( "OLR: Head tracking attribute not directly supported by " "object_audio_renderer."); break; @@ -168,12 +168,12 @@ static int _metadata_update(renderer_library_context_t *ctx, uint32_t index, case ck_metadata_object_positions: { if (metadata->object_positions.param_type != ck_param_constant || metadata->object_positions.position_type != ck_polar) { - warning("only support constant object positions with polar."); + warn("only support constant object positions with polar."); return ck_oar_error_notsup; } uint32_t n = olr->num_objects; if (n < metadata->object_positions.num_objects) { - warning( + warn( "OLR: Number of objects in metadata (%d) exceeds renderer's " "capacity (%d). Clipping.", metadata->object_positions.num_objects, n); @@ -198,7 +198,7 @@ static int _metadata_update(renderer_library_context_t *ctx, uint32_t index, object_audio_renderer_add_metadatas(olr->api, olr->metadata_blocks, n); } break; case ck_metadata_head_rotation: - warning( + warn( "OLR: Head rotation metadata not directly supported by " "object_audio_renderer."); break; @@ -215,7 +215,7 @@ static int _render(renderer_library_context_t *ctx, const oar_audio_block_t *in, olr->api, (float *)in->data, in->samples_per_channel, olr->num_objects, olr->offset, (float *)out->data); olr->offset += in->samples_per_channel; - if (ret != ck_oar_ok) warning("OLR: Rendering failed with errno %d.", ret); + if (ret != ck_oar_ok) warn("OLR: Rendering failed with errno %d.", ret); return ret; }