From 2980fa7869b534e14947973c9a2cc6dbaaa6d22c Mon Sep 17 00:00:00 2001 From: Sebastian Vater Date: Mon, 12 Dec 2011 01:09:06 +0100 Subject: [PATCH] Fixed tremolo effect in AVSequencer player in order to count back to take care that new values are used only after end of current tremor state as well as nit fixes and constify of mixer API. --- libavsequencer/avsequencer.c | 63 ++++++++------ libavsequencer/avsequencer.h | 66 +++++++++------ libavsequencer/hq_mixer.c | 158 ++++++++++++++++++++++------------ libavsequencer/instr.c | 8 +- libavsequencer/lq_mixer.c | 159 +++++++++++++++++++++++------------ libavsequencer/mixer.h | 61 ++++++++++---- libavsequencer/module.c | 2 +- libavsequencer/null_mixer.c | 128 +++++++++++++++++----------- libavsequencer/player.c | 16 ++-- libavsequencer/player.h | 10 +-- 10 files changed, 423 insertions(+), 248 deletions(-) diff --git a/libavsequencer/avsequencer.c b/libavsequencer/avsequencer.c index 52e6e884a..2c0a72ffb 100644 --- a/libavsequencer/avsequencer.c +++ b/libavsequencer/avsequencer.c @@ -146,7 +146,8 @@ void avsequencer_destroy(AVSequencerContext *avctx) } } -AVMixerData *avseq_mixer_init(AVSequencerContext *avctx, AVMixerContext *mixctx, +AVMixerData *avseq_mixer_init(AVSequencerContext *const avctx, + AVMixerContext *const mixctx, const char *args, void *opaque) { AVMixerData *mixer_data = NULL; @@ -180,7 +181,8 @@ AVMixerData *avseq_mixer_init(AVSequencerContext *avctx, AVMixerContext *mixctx, return mixer_data; } -int avseq_mixer_uninit(AVSequencerContext *avctx, AVMixerData *mixer_data) +int avseq_mixer_uninit(AVSequencerContext *const avctx, + AVMixerData *const mixer_data) { AVMixerContext *mixctx; @@ -239,8 +241,9 @@ int avseq_mixer_uninit(AVSequencerContext *avctx, AVMixerData *mixer_data) return 0; } -uint32_t avseq_mixer_set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, - uint32_t new_channels) +uint32_t avseq_mixer_set_rate(AVMixerData *const mixer_data, + const uint32_t mix_rate, + const uint32_t channels) { AVMixerContext *mixctx; @@ -250,6 +253,9 @@ uint32_t avseq_mixer_set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, mixctx = mixer_data->mixctx; if (mixctx && mixctx->set_rate) { + uint32_t new_mix_rate = mix_rate; + uint32_t new_channels = channels; + if (new_mix_rate < mixctx->frequency_min) new_mix_rate = mixctx->frequency_min; else if (new_mix_rate > mixctx->frequency_max) @@ -264,7 +270,8 @@ uint32_t avseq_mixer_set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, return mixer_data->rate; } -uint32_t avseq_mixer_set_tempo(AVMixerData *mixer_data, uint32_t new_tempo) +uint32_t avseq_mixer_set_tempo(AVMixerData *const mixer_data, + const uint32_t tempo) { AVMixerContext *mixctx; @@ -273,15 +280,17 @@ uint32_t avseq_mixer_set_tempo(AVMixerData *mixer_data, uint32_t new_tempo) mixctx = mixer_data->mixctx; - if (new_tempo && mixctx && mixctx->set_tempo) - return mixctx->set_tempo(mixer_data, new_tempo); + if (tempo && mixctx && mixctx->set_tempo) + return mixctx->set_tempo(mixer_data, tempo); return mixer_data->tempo; } -uint32_t avseq_mixer_set_volume(AVMixerData *mixer_data, uint32_t amplify, - uint32_t left_volume, uint32_t right_volume, - uint32_t channels) +uint32_t avseq_mixer_set_volume(AVMixerData *const mixer_data, + const uint32_t amplify, + const uint32_t left_volume, + const uint32_t right_volume, + const uint32_t channels) { AVMixerContext *mixctx; @@ -296,8 +305,9 @@ uint32_t avseq_mixer_set_volume(AVMixerData *mixer_data, uint32_t amplify, return mixer_data->tempo; } -void avseq_mixer_get_channel(AVMixerData *mixer_data, - AVMixerChannel *mixer_channel, uint32_t channel) +void avseq_mixer_get_channel(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel, + const uint32_t channel) { AVMixerContext *mixctx; @@ -310,8 +320,9 @@ void avseq_mixer_get_channel(AVMixerData *mixer_data, mixctx->get_channel(mixer_data, mixer_channel, channel); } -void avseq_mixer_set_channel(AVMixerData *mixer_data, - AVMixerChannel *mixer_channel, uint32_t channel) +void avseq_mixer_set_channel(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { AVMixerContext *mixctx; @@ -324,7 +335,8 @@ void avseq_mixer_set_channel(AVMixerData *mixer_data, mixctx->set_channel(mixer_data, mixer_channel, channel); } -void avseq_mixer_reset_channel(AVMixerData *mixer_data, uint32_t channel) +void avseq_mixer_reset_channel(AVMixerData *const mixer_data, + const uint32_t channel) { AVMixerContext *mixctx; @@ -337,10 +349,10 @@ void avseq_mixer_reset_channel(AVMixerData *mixer_data, uint32_t channel) mixctx->reset_channel(mixer_data, channel); } -void avseq_mixer_get_both_channels(AVMixerData *mixer_data, - AVMixerChannel *mixer_channel_current, - AVMixerChannel *mixer_channel_next, - uint32_t channel) +void avseq_mixer_get_both_channels(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel_current, + AVMixerChannel *const mixer_channel_next, + const uint32_t channel) { AVMixerContext *mixctx; @@ -353,10 +365,10 @@ void avseq_mixer_get_both_channels(AVMixerData *mixer_data, mixctx->get_both_channels(mixer_data, mixer_channel_current, mixer_channel_next, channel); } -void avseq_mixer_set_both_channels(AVMixerData *mixer_data, - AVMixerChannel *mixer_channel_current, - AVMixerChannel *mixer_channel_next, - uint32_t channel) +void avseq_mixer_set_both_channels(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel_current, + const AVMixerChannel *const mixer_channel_next, + const uint32_t channel) { AVMixerContext *mixctx; @@ -369,7 +381,7 @@ void avseq_mixer_set_both_channels(AVMixerData *mixer_data, mixctx->set_both_channels(mixer_data, mixer_channel_current, mixer_channel_next, channel); } -void avseq_mixer_do_mix(AVMixerData *mixer_data, int32_t *buf) +void avseq_mixer_do_mix(AVMixerData *const mixer_data, int32_t *buf) { AVMixerContext *mixctx; @@ -386,7 +398,8 @@ void avseq_mixer_do_mix(AVMixerData *mixer_data, int32_t *buf) } } -void avseq_mixer_do_mix_parallel(AVMixerData *mixer_data, int32_t *buf, +void avseq_mixer_do_mix_parallel(AVMixerData *const mixer_data, + int32_t *buf, const uint32_t first_channel, const uint32_t last_channel) { diff --git a/libavsequencer/avsequencer.h b/libavsequencer/avsequencer.h index eb9a4315e..69016a147 100644 --- a/libavsequencer/avsequencer.h +++ b/libavsequencer/avsequencer.h @@ -247,8 +247,9 @@ void avsequencer_destroy(AVSequencerContext *avctx); * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -AVMixerData *avseq_mixer_init(AVSequencerContext *avctx, AVMixerContext *mixctx, - const char *args, void *opaque); +AVMixerData *avseq_mixer_init(AVSequencerContext *const avctx, + AVMixerContext *const mixctx, + const char *args, void *opaque); /** * Closes and uninitializes an AVSequencer mixer data container. @@ -260,7 +261,8 @@ AVMixerData *avseq_mixer_init(AVSequencerContext *avctx, AVMixerContext *mixctx, * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -int avseq_mixer_uninit(AVSequencerContext *avctx, AVMixerData *mixer_data); +int avseq_mixer_uninit(AVSequencerContext *const avctx, + AVMixerData *const mixer_data); /** * Sets and transfers a new mixing rate and number of output @@ -268,31 +270,33 @@ int avseq_mixer_uninit(AVSequencerContext *avctx, AVMixerData *mixer_data); * * @param mixer_data the AVMixerData to set the new mixing rate and * number of output channels of - * @param new_mix_rate the new mixing rate in Hz to use for mixing - * @param new_channels the new number of output channels to use for mixing + * @param mix_rate the new mixing rate in Hz to use for mixing + * @param channels the new number of output channels to use for mixing * @return the mixing rate in Hz which actually has been set * * @note This is part of the new sequencer API which is still under construction. * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -uint32_t avseq_mixer_set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, - uint32_t new_channels); +uint32_t avseq_mixer_set_rate(AVMixerData *const mixer_data, + const uint32_t mix_rate, + const uint32_t channels); /** * Sets and transfers a new tempo for the playback handler to the * mixing engine. * * @param mixer_data the AVMixerData to set the new tempo - * @param new_tempo the new tempo in AV_TIME_BASE fractional seconds - * to use for mixing + * @param tempo the new tempo in AV_TIME_BASE fractional seconds to use + * for mixing * @return the tempo in AV_TIME_BASE fractional seconds which actually has been set * * @note This is part of the new sequencer API which is still under construction. * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -uint32_t avseq_mixer_set_tempo(AVMixerData *mixer_data, uint32_t new_tempo); +uint32_t avseq_mixer_set_tempo(AVMixerData *const mixer_data, + const uint32_t tempo); /** * Sets and transfers a new volume boost, left and right volume and @@ -312,9 +316,11 @@ uint32_t avseq_mixer_set_tempo(AVMixerData *mixer_data, uint32_t new_tempo); * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -uint32_t avseq_mixer_set_volume(AVMixerData *mixer_data, uint32_t amplify, - uint32_t left_volume, uint32_t right_volume, - uint32_t channels); +uint32_t avseq_mixer_set_volume(AVMixerData *const mixer_data, + const uint32_t amplify, + const uint32_t left_volume, + const uint32_t right_volume, + const uint32_t channels); /** * Gets and transfers a channel data block from the internal mixing @@ -329,8 +335,9 @@ uint32_t avseq_mixer_set_volume(AVMixerData *mixer_data, uint32_t amplify, * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -void avseq_mixer_get_channel(AVMixerData *mixer_data, - AVMixerChannel *mixer_channel, uint32_t channel); +void avseq_mixer_get_channel(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel, + const uint32_t channel); /** * Sets and transfers a channel data block from the AVSequencer to the @@ -345,8 +352,9 @@ void avseq_mixer_get_channel(AVMixerData *mixer_data, * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -void avseq_mixer_set_channel(AVMixerData *mixer_data, - AVMixerChannel *mixer_channel, uint32_t channel); +void avseq_mixer_set_channel(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel); /** * Resets a channel data block from the AVSequencer by setting the @@ -359,7 +367,8 @@ void avseq_mixer_set_channel(AVMixerData *mixer_data, * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -void avseq_mixer_reset_channel(AVMixerData *mixer_data, uint32_t channel); +void avseq_mixer_reset_channel(AVMixerData *const mixer_data, + const uint32_t channel); /** * Gets and transfers a channel data block from the internal mixing @@ -377,10 +386,10 @@ void avseq_mixer_reset_channel(AVMixerData *mixer_data, uint32_t channel); * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -void avseq_mixer_get_both_channels(AVMixerData *mixer_data, - AVMixerChannel *mixer_channel_current, - AVMixerChannel *mixer_channel_next, - uint32_t channel); +void avseq_mixer_get_both_channels(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel_current, + AVMixerChannel *const mixer_channel_next, + const uint32_t channel); /** * Sets and transfers a channel data block from the AVSequencer to the @@ -399,10 +408,10 @@ void avseq_mixer_get_both_channels(AVMixerData *mixer_data, * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -void avseq_mixer_set_both_channels(AVMixerData *mixer_data, - AVMixerChannel *mixer_channel_current, - AVMixerChannel *mixer_channel_next, - uint32_t channel); +void avseq_mixer_set_both_channels(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel_current, + const AVMixerChannel *const mixer_channel_next, + const uint32_t channel); /** * Fills the output mixing buffer by calculating all the input channel samples. @@ -414,7 +423,7 @@ void avseq_mixer_set_both_channels(AVMixerData *mixer_data, * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -void avseq_mixer_do_mix(AVMixerData *mixer_data, int32_t *buf); +void avseq_mixer_do_mix(AVMixerData *const mixer_data, int32_t *buf); /** * Fills the output mixing buffer by calculating all the input channel samples @@ -432,7 +441,8 @@ void avseq_mixer_do_mix(AVMixerData *mixer_data, int32_t *buf); * Thus do not use this yet. It may change at any time, do not expect * ABI compatibility yet! */ -void avseq_mixer_do_mix_parallel(AVMixerData *mixer_data, int32_t *buf, +void avseq_mixer_do_mix_parallel(AVMixerData *const mixer_data, + int32_t *buf, const uint32_t first_channel, const uint32_t last_channel); diff --git a/libavsequencer/hq_mixer.c b/libavsequencer/hq_mixer.c index c12bf4a82..1a0f49f40 100644 --- a/libavsequencer/hq_mixer.c +++ b/libavsequencer/hq_mixer.c @@ -108,7 +108,11 @@ static const AVClass avseq_high_quality_mixer_class = { LIBAVUTIL_VERSION_INT, }; -static void apply_filter(AV_HQMixerChannelInfo *channel_info, struct ChannelBlock *const channel_block, int32_t **const dest_buf, const int32_t *src_buf, const uint32_t len) +static void apply_filter(AV_HQMixerChannelInfo *channel_info, + struct ChannelBlock *const channel_block, + int32_t **const dest_buf, + const int32_t *src_buf, + const uint32_t len) { int32_t *mix_buf = *dest_buf; uint32_t i = len >> 2; @@ -143,7 +147,8 @@ static void apply_filter(AV_HQMixerChannelInfo *channel_info, struct ChannelBloc channel_info->filter_tmp2 = o1; } -static void mix_sample(AV_HQMixerData *const mixer_data, int32_t *const buf, const uint32_t len) +static void mix_sample(AV_HQMixerData *const mixer_data, + int32_t *const buf, const uint32_t len) { AV_HQMixerChannelInfo *channel_info = mixer_data->channel_info; uint16_t i = mixer_data->channels_in; @@ -387,7 +392,10 @@ static void mix_sample(AV_HQMixerData *const mixer_data, int32_t *const buf, con } while (--i); } -static void mix_sample_parallel(AV_HQMixerData *const mixer_data, int32_t *const buf, const uint32_t len, const uint32_t first_channel, const uint32_t last_channel) +static void mix_sample_parallel(AV_HQMixerData *const mixer_data, + int32_t *const buf, const uint32_t len, + const uint32_t first_channel, + const uint32_t last_channel) { AV_HQMixerChannelInfo *channel_info = mixer_data->channel_info + first_channel; uint16_t i = (last_channel - first_channel) + 1; @@ -5573,7 +5581,8 @@ static const void *mixer_stereo_surround_16_to_8[] = { mix_stereo_backwards_x_to_8_surround }; -static void set_mix_functions(const AV_HQMixerData *const mixer_data, struct ChannelBlock *const channel_block) +static void set_mix_functions(const AV_HQMixerData *const mixer_data, + struct ChannelBlock *const channel_block) { void **mix_func; void (*init_mixer_func)(const AV_HQMixerData *const mixer_data, struct ChannelBlock *channel_block, uint32_t volume, uint32_t panning); @@ -5711,7 +5720,9 @@ static void set_mix_functions(const AV_HQMixerData *const mixer_data, struct Cha init_mixer_func(mixer_data, channel_block, channel_block->volume, panning); } -static void set_sample_mix_rate(const AV_HQMixerData *const mixer_data, struct ChannelBlock *const channel_block, const uint32_t rate) +static void set_sample_mix_rate(const AV_HQMixerData *const mixer_data, + struct ChannelBlock *const channel_block, + const uint32_t rate) { const uint32_t mix_rate = mixer_data->mix_rate; @@ -6502,7 +6513,8 @@ static const int32_t damp_factor_lut[] = { 2140116, 2138673, 2137231, 2135790, 2134349, 2132910, 2131472, 2130034, 2128598, 2127163, 2125728, 2124295, 2122862, 2121430, 2120000, 2118570 }; -static inline void mulu_128(uint64_t *const result, const uint64_t a, const uint64_t b) +static inline void mulu_128(uint64_t *const result, const uint64_t a, + const uint64_t b) { const uint32_t a_hi = a >> 32; const uint32_t a_lo = (uint32_t) a; @@ -6527,7 +6539,8 @@ static inline void neg_128(uint64_t *const result) result[0] += (++result[1] ? 0 : 1); } -static inline void muls_128(int64_t *const result, const int64_t a, const int64_t b) +static inline void muls_128(int64_t *const result, const int64_t a, + const int64_t b) { const int sign = (a ^ b) < 0; @@ -6537,7 +6550,8 @@ static inline void muls_128(int64_t *const result, const int64_t a, const int64_ neg_128(result); } -static inline uint64_t divu_128(const uint64_t *const a, const uint64_t b) +static inline uint64_t divu_128(const uint64_t *const a, + const uint64_t b) { uint64_t a_hi = a[0]; uint64_t a_lo = a[1]; @@ -6584,7 +6598,9 @@ static inline void add_128(int64_t *const a, const int64_t b) a[0] += ((uint64_t) a[1] < (uint64_t) b); } -static void update_sample_filter(const AV_HQMixerData *const mixer_data, AV_HQMixerChannelInfo *const channel_info, struct ChannelBlock *const channel_block) +static void update_sample_filter(const AV_HQMixerData *const mixer_data, + AV_HQMixerChannelInfo *const channel_info, + struct ChannelBlock *const channel_block) { const uint32_t mix_rate = mixer_data->mix_rate; uint64_t tmp_128[2]; @@ -6623,7 +6639,11 @@ static void update_sample_filter(const AV_HQMixerData *const mixer_data, AV_HQMi channel_block->filter_c3 = (((-e) << 24) + tmp_round) / tmp; } -static void set_sample_filter(const AV_HQMixerData *const mixer_data, AV_HQMixerChannelInfo *const channel_info, struct ChannelBlock *const channel_block, uint16_t cutoff, uint16_t damping) +static void set_sample_filter(const AV_HQMixerData *const mixer_data, + AV_HQMixerChannelInfo *const channel_info, + struct ChannelBlock *const channel_block, + uint16_t cutoff, + uint16_t damping) { if (cutoff > 4095) cutoff = 4095; @@ -6640,7 +6660,8 @@ static void set_sample_filter(const AV_HQMixerData *const mixer_data, AV_HQMixer update_sample_filter(mixer_data, channel_info, channel_block); } -static av_cold AVMixerData *init(AVMixerContext *mixctx, const char *args, void *opaque) +static av_cold AVMixerData *init(AVMixerContext *const mixctx, + const char *args, void *opaque) { AV_HQMixerData *hq_mixer_data; AV_HQMixerChannelInfo *channel_info; @@ -6730,7 +6751,7 @@ static av_cold AVMixerData *init(AVMixerContext *mixctx, const char *args, void return (AVMixerData *) hq_mixer_data; } -static av_cold int uninit(AVMixerData *mixer_data) +static av_cold int uninit(AVMixerData *const mixer_data) { AV_HQMixerData *hq_mixer_data = (AV_HQMixerData *) mixer_data; @@ -6746,33 +6767,36 @@ static av_cold int uninit(AVMixerData *mixer_data) return 0; } -static av_cold uint32_t set_tempo(AVMixerData *mixer_data, uint32_t new_tempo) +static av_cold uint32_t set_tempo(AVMixerData *const mixer_data, + const uint32_t tempo) { - AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; - uint32_t channel_rate = hq_mixer_data->mix_rate * 10; + AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *const) mixer_data; + uint32_t channel_rate = hq_mixer_data->mix_rate * 10; uint64_t pass_value; - hq_mixer_data->mixer_data.tempo = new_tempo; + hq_mixer_data->mixer_data.tempo = tempo; pass_value = ((uint64_t) channel_rate << 16) + ((uint64_t) hq_mixer_data->mix_rate_frac >> 16); hq_mixer_data->pass_len = (uint64_t) pass_value / hq_mixer_data->mixer_data.tempo; hq_mixer_data->pass_len_frac = (((uint64_t) pass_value % hq_mixer_data->mixer_data.tempo) << 32) / hq_mixer_data->mixer_data.tempo; - return new_tempo; + return tempo; } -static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, uint32_t new_channels) +static av_cold uint32_t set_rate(AVMixerData *const mixer_data, + const uint32_t mix_rate, + const uint32_t channels) { - AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; - uint32_t buf_size, mix_rate, mix_rate_frac; + AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *const) mixer_data; + uint32_t buf_size, old_mix_rate, mix_rate_frac; - hq_mixer_data->mixer_data.rate = new_mix_rate; + hq_mixer_data->mixer_data.rate = mix_rate; buf_size = hq_mixer_data->mixer_data.mix_buf_size; - hq_mixer_data->mixer_data.channels_out = new_channels; + hq_mixer_data->mixer_data.channels_out = channels; - if ((hq_mixer_data->buf_size * hq_mixer_data->channels_out) != (buf_size * new_channels)) { + if ((hq_mixer_data->buf_size * hq_mixer_data->channels_out) != (buf_size * channels)) { int32_t *buf = hq_mixer_data->mixer_data.mix_buf; int32_t *filter_buf = hq_mixer_data->filter_buf; - const uint32_t mix_buf_mem_size = (buf_size * new_channels) << 2; + const uint32_t mix_buf_mem_size = (buf_size * channels) << 2; if (!(buf = av_realloc(buf, mix_buf_mem_size + FF_INPUT_BUFFER_PADDING_SIZE))) { av_log(hq_mixer_data->mixer_data.mixctx, AV_LOG_ERROR, "Cannot allocate mixer output buffer.\n"); @@ -6791,29 +6815,29 @@ static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, hq_mixer_data->filter_buf = filter_buf; } - hq_mixer_data->channels_out = new_channels; + hq_mixer_data->channels_out = channels; hq_mixer_data->buf = hq_mixer_data->mixer_data.mix_buf; hq_mixer_data->buf_size = hq_mixer_data->mixer_data.mix_buf_size; if (hq_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_MIXING) { - mix_rate = new_mix_rate; // TODO: Add check here if this mix rate is supported by target device + old_mix_rate = mix_rate; // TODO: Add check here if this mix rate is supported by target device mix_rate_frac = 0; - if (hq_mixer_data->mix_rate != mix_rate) { + if (hq_mixer_data->mix_rate != old_mix_rate) { AV_HQMixerChannelInfo *channel_info = hq_mixer_data->channel_info; uint16_t i; - hq_mixer_data->mix_rate = mix_rate; + hq_mixer_data->mix_rate = old_mix_rate; hq_mixer_data->mix_rate_frac = mix_rate_frac; if (hq_mixer_data->mixer_data.tempo) set_tempo((AVMixerData *) mixer_data, hq_mixer_data->mixer_data.tempo); for (i = hq_mixer_data->channels_in; i > 0; i--) { - channel_info->current.advance = channel_info->current.rate / mix_rate; - channel_info->current.advance_frac = (((uint64_t) channel_info->current.rate % mix_rate) << 32) / mix_rate; - channel_info->next.advance = channel_info->next.rate / mix_rate; - channel_info->next.advance_frac = (((uint64_t) channel_info->next.rate % mix_rate) << 32) / mix_rate; + channel_info->current.advance = channel_info->current.rate / old_mix_rate; + channel_info->current.advance_frac = (((uint64_t) channel_info->current.rate % old_mix_rate) << 32) / old_mix_rate; + channel_info->next.advance = channel_info->next.rate / old_mix_rate; + channel_info->next.advance_frac = (((uint64_t) channel_info->next.rate % old_mix_rate) << 32) / old_mix_rate; update_sample_filter(hq_mixer_data, channel_info, &channel_info->current); update_sample_filter(hq_mixer_data, channel_info, &channel_info->next); @@ -6825,12 +6849,16 @@ static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, // TODO: Inform libavfilter that the target mixing rate has been changed. - return new_mix_rate; + return mix_rate; } -static av_cold uint32_t set_volume(AVMixerData *mixer_data, uint32_t amplify, uint32_t left_volume, uint32_t right_volume, uint32_t channels) +static av_cold uint32_t set_volume(AVMixerData *const mixer_data, + const uint32_t amplify, + const uint32_t left_volume, + const uint32_t right_volume, + const uint32_t channels) { - AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *const) mixer_data; AV_HQMixerChannelInfo *channel_info = NULL; AV_HQMixerChannelInfo *const old_channel_info = hq_mixer_data->channel_info; uint32_t old_channels, i; @@ -6899,9 +6927,11 @@ static av_cold uint32_t set_volume(AVMixerData *mixer_data, uint32_t amplify, ui return channels; } -static av_cold void get_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void get_channel(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + const AV_HQMixerData *const hq_mixer_data = (const AV_HQMixerData *const) mixer_data; const AV_HQMixerChannelInfo *const channel_info = hq_mixer_data->channel_info + channel; mixer_channel->pos = channel_info->current.offset; @@ -6920,9 +6950,11 @@ static av_cold void get_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_c mixer_channel->filter_damping = channel_info->current.filter_damping; } -static av_cold void set_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + const AV_HQMixerData *const hq_mixer_data = (const AV_HQMixerData *const) mixer_data; AV_HQMixerChannelInfo *const channel_info = hq_mixer_data->channel_info + channel; struct ChannelBlock *channel_block; uint32_t repeat, repeat_len; @@ -6970,9 +7002,10 @@ static av_cold void set_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_c set_sample_filter(hq_mixer_data, channel_info, channel_block, mixer_channel->filter_cutoff, mixer_channel->filter_damping); } -static av_cold void reset_channel(AVMixerData *mixer_data, uint32_t channel) +static av_cold void reset_channel(AVMixerData *const mixer_data, + const uint32_t channel) { - const AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + const AV_HQMixerData *const hq_mixer_data = (const AV_HQMixerData *const) mixer_data; AV_HQMixerChannelInfo *const channel_info = hq_mixer_data->channel_info + channel; struct ChannelBlock *channel_block = &channel_info->current; uint32_t repeat, repeat_len; @@ -7025,9 +7058,12 @@ static av_cold void reset_channel(AVMixerData *mixer_data, uint32_t channel) set_sample_filter(hq_mixer_data, channel_info, channel_block, 4095, 0); } -static av_cold void get_both_channels(AVMixerData *mixer_data, AVMixerChannel *mixer_channel_current, AVMixerChannel *mixer_channel_next, uint32_t channel) +static av_cold void get_both_channels(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel_current, + AVMixerChannel *const mixer_channel_next, + const uint32_t channel) { - const AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + const AV_HQMixerData *const hq_mixer_data = (const AV_HQMixerData *const) mixer_data; const AV_HQMixerChannelInfo *const channel_info = hq_mixer_data->channel_info + channel; mixer_channel_current->pos = channel_info->current.offset; @@ -7061,9 +7097,12 @@ static av_cold void get_both_channels(AVMixerData *mixer_data, AVMixerChannel *m mixer_channel_next->filter_damping = channel_info->next.filter_damping; } -static av_cold void set_both_channels(AVMixerData *mixer_data, AVMixerChannel *mixer_channel_current, AVMixerChannel *mixer_channel_next, uint32_t channel) +static av_cold void set_both_channels(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel_current, + const AVMixerChannel *const mixer_channel_next, + const uint32_t channel) { - const AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + const AV_HQMixerData *const hq_mixer_data = (const AV_HQMixerData *const) mixer_data; AV_HQMixerChannelInfo *const channel_info = hq_mixer_data->channel_info + channel; struct ChannelBlock *channel_block = &channel_info->current; uint32_t repeat, repeat_len; @@ -7148,9 +7187,11 @@ static av_cold void set_both_channels(AVMixerData *mixer_data, AVMixerChannel *m set_sample_filter(hq_mixer_data, channel_info, channel_block, mixer_channel_next->filter_cutoff, mixer_channel_next->filter_damping); } -static av_cold void set_channel_volume_panning_pitch(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_volume_panning_pitch(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + const AV_HQMixerData *const hq_mixer_data = (const AV_HQMixerData *const) mixer_data; AV_HQMixerChannelInfo *const channel_info = hq_mixer_data->channel_info + channel; if ((channel_info->current.volume == mixer_channel->volume) && (channel_info->current.panning == mixer_channel->panning)) { @@ -7189,9 +7230,11 @@ static av_cold void set_channel_volume_panning_pitch(AVMixerData *mixer_data, AV } } -static av_cold void set_channel_position_repeat_flags(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_position_repeat_flags(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + const AV_HQMixerData *const hq_mixer_data = (const AV_HQMixerData *const) mixer_data; AV_HQMixerChannelInfo *const channel_info = hq_mixer_data->channel_info + channel; if (channel_info->current.flags == mixer_channel->flags) { @@ -7264,16 +7307,18 @@ static av_cold void set_channel_position_repeat_flags(AVMixerData *mixer_data, A } } -static av_cold void set_channel_filter(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_filter(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; + const AV_HQMixerData *const hq_mixer_data = (const AV_HQMixerData *const) mixer_data; AV_HQMixerChannelInfo *const channel_info = hq_mixer_data->channel_info + channel; set_sample_filter(hq_mixer_data, channel_info, &channel_info->current, mixer_channel->filter_cutoff, mixer_channel->filter_damping); } -static av_cold void mix(AVMixerData *mixer_data, int32_t *buf) { - AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; +static av_cold void mix(AVMixerData *const mixer_data, int32_t *buf) { + AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *const) mixer_data; uint32_t mix_rate, current_left, current_left_frac, buf_size; if (!(hq_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_FROZEN)) { @@ -7319,8 +7364,11 @@ static av_cold void mix(AVMixerData *mixer_data, int32_t *buf) { // TODO: Execute post-processing step in libavfilter and pass the PCM data. } -static av_cold void mix_parallel(AVMixerData *mixer_data, int32_t *buf, const uint32_t first_channel, const uint32_t last_channel) { - AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *) mixer_data; +static av_cold void mix_parallel(AVMixerData *const mixer_data, + int32_t *buf, + const uint32_t first_channel, + const uint32_t last_channel) { + AV_HQMixerData *const hq_mixer_data = (AV_HQMixerData *const) mixer_data; uint32_t mix_rate, current_left, current_left_frac, buf_size; if (!(hq_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_FROZEN)) { diff --git a/libavsequencer/instr.c b/libavsequencer/instr.c index 2a5e0a73d..9824493c8 100644 --- a/libavsequencer/instr.c +++ b/libavsequencer/instr.c @@ -462,9 +462,7 @@ CREATE_ENVELOPE(sine) value = -value; pos += sine_div; - value *= (int32_t) scale; - value /= 32767; - value += y_offset; + value = (((value * (int32_t) scale) + 16383) / 32767) + y_offset; count += sine_mod; if (count >= points) { @@ -494,9 +492,7 @@ CREATE_ENVELOPE(cosine) if ((pos -= sine_div) < 0) pos += 360; - value *= (int32_t) scale; - value /= 32767; - value += y_offset; + value = (((value * (int32_t) scale) + 16383) / 32767) + y_offset; count += sine_mod; if (count >= points) { diff --git a/libavsequencer/lq_mixer.c b/libavsequencer/lq_mixer.c index 6633c35f8..c23badaa0 100644 --- a/libavsequencer/lq_mixer.c +++ b/libavsequencer/lq_mixer.c @@ -101,7 +101,11 @@ static const AVClass avseq_low_quality_mixer_class = { LIBAVUTIL_VERSION_INT, }; -static void apply_filter(AV_LQMixerChannelInfo *const channel_info, struct ChannelBlock *const channel_block, int32_t **const dest_buf, const int32_t *src_buf, const uint32_t len) +static void apply_filter(AV_LQMixerChannelInfo *const channel_info, + struct ChannelBlock *const channel_block, + int32_t **const dest_buf, + const int32_t *src_buf, + const uint32_t len) { int32_t *mix_buf = *dest_buf; uint32_t i = len >> 2; @@ -136,7 +140,8 @@ static void apply_filter(AV_LQMixerChannelInfo *const channel_info, struct Chann channel_info->filter_tmp2 = o1; } -static void mix_sample(AV_LQMixerData *const mixer_data, int32_t *const buf, const uint32_t len) +static void mix_sample(AV_LQMixerData *const mixer_data, + int32_t *const buf, const uint32_t len) { AV_LQMixerChannelInfo *channel_info = mixer_data->channel_info; uint16_t i = mixer_data->channels_in; @@ -380,7 +385,11 @@ static void mix_sample(AV_LQMixerData *const mixer_data, int32_t *const buf, con } while (--i); } -static void mix_sample_parallel(AV_LQMixerData *const mixer_data, int32_t *const buf, const uint32_t len, const uint32_t first_channel, const uint32_t last_channel) +static void mix_sample_parallel(AV_LQMixerData *const mixer_data, + int32_t *const buf, + const uint32_t len, + const uint32_t first_channel, + const uint32_t last_channel) { AV_LQMixerChannelInfo *channel_info = mixer_data->channel_info + first_channel; uint16_t i = (last_channel - first_channel) + 1; @@ -3919,7 +3928,8 @@ static const void *mixer_stereo_surround_16_to_8[] = { mix_stereo_backwards_x_to_8_surround }; -static void set_mix_functions(const AV_LQMixerData *const mixer_data, struct ChannelBlock *const channel_block) +static void set_mix_functions(const AV_LQMixerData *const mixer_data, + struct ChannelBlock *const channel_block) { void **mix_func; void (*init_mixer_func)(const AV_LQMixerData *const mixer_data, struct ChannelBlock *channel_block, uint32_t volume, uint32_t panning); @@ -4057,7 +4067,9 @@ static void set_mix_functions(const AV_LQMixerData *const mixer_data, struct Cha init_mixer_func(mixer_data, channel_block, channel_block->volume, panning); } -static void set_sample_mix_rate(const AV_LQMixerData *const mixer_data, struct ChannelBlock *const channel_block, const uint32_t rate) +static void set_sample_mix_rate(const AV_LQMixerData *const mixer_data, + struct ChannelBlock *const channel_block, + const uint32_t rate) { const uint32_t mix_rate = mixer_data->mix_rate; @@ -4848,7 +4860,8 @@ static const int32_t damp_factor_lut[] = { 2140116, 2138673, 2137231, 2135790, 2134349, 2132910, 2131472, 2130034, 2128598, 2127163, 2125728, 2124295, 2122862, 2121430, 2120000, 2118570 }; -static inline void mulu_128(uint64_t *const result, const uint64_t a, const uint64_t b) +static inline void mulu_128(uint64_t *const result, const uint64_t a, + const uint64_t b) { const uint32_t a_hi = a >> 32; const uint32_t a_lo = (uint32_t) a; @@ -4873,7 +4886,8 @@ static inline void neg_128(uint64_t *const result) result[0] += (++result[1] ? 0 : 1); } -static inline void muls_128(int64_t *const result, const int64_t a, const int64_t b) +static inline void muls_128(int64_t *const result, const int64_t a, + const int64_t b) { const int sign = (a ^ b) < 0; @@ -4883,7 +4897,8 @@ static inline void muls_128(int64_t *const result, const int64_t a, const int64_ neg_128(result); } -static inline uint64_t divu_128(const uint64_t *const a, const uint64_t b) +static inline uint64_t divu_128(const uint64_t *const a, + const uint64_t b) { uint64_t a_hi = a[0]; uint64_t a_lo = a[1]; @@ -4930,7 +4945,9 @@ static inline void add_128(int64_t *const a, const int64_t b) a[0] += ((uint64_t) a[1] < (uint64_t) b); } -static void update_sample_filter(const AV_LQMixerData *const mixer_data, AV_LQMixerChannelInfo *const channel_info, struct ChannelBlock *const channel_block) +static void update_sample_filter(const AV_LQMixerData *const mixer_data, + AV_LQMixerChannelInfo *const channel_info, + struct ChannelBlock *const channel_block) { const uint32_t mix_rate = mixer_data->mix_rate; uint64_t tmp_128[2]; @@ -4969,7 +4986,11 @@ static void update_sample_filter(const AV_LQMixerData *const mixer_data, AV_LQMi channel_block->filter_c3 = (((-e) << 24) + tmp_round) / tmp; } -static void set_sample_filter(const AV_LQMixerData *const mixer_data, AV_LQMixerChannelInfo *const channel_info, struct ChannelBlock *const channel_block, uint16_t cutoff, uint16_t damping) +static void set_sample_filter(const AV_LQMixerData *const mixer_data, + AV_LQMixerChannelInfo *const channel_info, + struct ChannelBlock *const channel_block, + uint16_t cutoff, + uint16_t damping) { if (cutoff > 4095) cutoff = 4095; @@ -4986,7 +5007,8 @@ static void set_sample_filter(const AV_LQMixerData *const mixer_data, AV_LQMixer update_sample_filter(mixer_data, channel_info, channel_block); } -static av_cold AVMixerData *init(AVMixerContext *mixctx, const char *args, void *opaque) +static av_cold AVMixerData *init(AVMixerContext *const mixctx, + const char *args, void *opaque) { AV_LQMixerData *lq_mixer_data; AV_LQMixerChannelInfo *channel_info; @@ -5082,7 +5104,7 @@ static av_cold AVMixerData *init(AVMixerContext *mixctx, const char *args, void return (AVMixerData *) lq_mixer_data; } -static av_cold int uninit(AVMixerData *mixer_data) +static av_cold int uninit(AVMixerData *const mixer_data) { AV_LQMixerData *lq_mixer_data = (AV_LQMixerData *) mixer_data; @@ -5098,33 +5120,36 @@ static av_cold int uninit(AVMixerData *mixer_data) return 0; } -static av_cold uint32_t set_tempo(AVMixerData *mixer_data, uint32_t new_tempo) +static av_cold uint32_t set_tempo(AVMixerData *const mixer_data, + const uint32_t tempo) { - AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; - uint32_t channel_rate = lq_mixer_data->mix_rate * 10; + AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *const) mixer_data; + uint32_t channel_rate = lq_mixer_data->mix_rate * 10; uint64_t pass_value; - lq_mixer_data->mixer_data.tempo = new_tempo; + lq_mixer_data->mixer_data.tempo = tempo; pass_value = ((uint64_t) channel_rate << 16) + ((uint64_t) lq_mixer_data->mix_rate_frac >> 16); lq_mixer_data->pass_len = (uint64_t) pass_value / lq_mixer_data->mixer_data.tempo; lq_mixer_data->pass_len_frac = (((uint64_t) pass_value % lq_mixer_data->mixer_data.tempo) << 32) / lq_mixer_data->mixer_data.tempo; - return new_tempo; + return tempo; } -static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, uint32_t new_channels) +static av_cold uint32_t set_rate(AVMixerData *const mixer_data, + const uint32_t mix_rate, + const uint32_t channels) { - AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; - uint32_t buf_size, mix_rate, mix_rate_frac; + AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *const) mixer_data; + uint32_t buf_size, old_mix_rate, mix_rate_frac; - lq_mixer_data->mixer_data.rate = new_mix_rate; + lq_mixer_data->mixer_data.rate = mix_rate; buf_size = lq_mixer_data->mixer_data.mix_buf_size; - lq_mixer_data->mixer_data.channels_out = new_channels; + lq_mixer_data->mixer_data.channels_out = channels; - if ((lq_mixer_data->buf_size * lq_mixer_data->channels_out) != (buf_size * new_channels)) { + if ((lq_mixer_data->buf_size * lq_mixer_data->channels_out) != (buf_size * channels)) { int32_t *buf = lq_mixer_data->mixer_data.mix_buf; int32_t *filter_buf = lq_mixer_data->filter_buf; - const uint32_t mix_buf_mem_size = (buf_size * new_channels) << 2; + const uint32_t mix_buf_mem_size = (buf_size * channels) << 2; if (!(buf = av_realloc(buf, mix_buf_mem_size + FF_INPUT_BUFFER_PADDING_SIZE))) { av_log(lq_mixer_data->mixer_data.mixctx, AV_LOG_ERROR, "Cannot allocate mixer output buffer.\n"); @@ -5143,29 +5168,29 @@ static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, lq_mixer_data->filter_buf = filter_buf; } - lq_mixer_data->channels_out = new_channels; + lq_mixer_data->channels_out = channels; lq_mixer_data->buf = lq_mixer_data->mixer_data.mix_buf; lq_mixer_data->buf_size = lq_mixer_data->mixer_data.mix_buf_size; if (lq_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_MIXING) { - mix_rate = new_mix_rate; // TODO: Add check here if this mix rate is supported by target device + old_mix_rate = mix_rate; // TODO: Add check here if this mix rate is supported by target device mix_rate_frac = 0; - if (lq_mixer_data->mix_rate != mix_rate) { + if (lq_mixer_data->mix_rate != old_mix_rate) { AV_LQMixerChannelInfo *channel_info = lq_mixer_data->channel_info; uint16_t i; - lq_mixer_data->mix_rate = mix_rate; + lq_mixer_data->mix_rate = old_mix_rate; lq_mixer_data->mix_rate_frac = mix_rate_frac; if (lq_mixer_data->mixer_data.tempo) set_tempo((AVMixerData *) mixer_data, lq_mixer_data->mixer_data.tempo); for (i = lq_mixer_data->channels_in; i > 0; i--) { - channel_info->current.advance = channel_info->current.rate / mix_rate; - channel_info->current.advance_frac = (((uint64_t) channel_info->current.rate % mix_rate) << 32) / mix_rate; - channel_info->next.advance = channel_info->next.rate / mix_rate; - channel_info->next.advance_frac = (((uint64_t) channel_info->next.rate % mix_rate) << 32) / mix_rate; + channel_info->current.advance = channel_info->current.rate / old_mix_rate; + channel_info->current.advance_frac = (((uint64_t) channel_info->current.rate % old_mix_rate) << 32) / old_mix_rate; + channel_info->next.advance = channel_info->next.rate / old_mix_rate; + channel_info->next.advance_frac = (((uint64_t) channel_info->next.rate % old_mix_rate) << 32) / old_mix_rate; update_sample_filter(lq_mixer_data, channel_info, &channel_info->current); update_sample_filter(lq_mixer_data, channel_info, &channel_info->next); @@ -5177,12 +5202,16 @@ static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, // TODO: Inform libavfilter that the target mixing rate has been changed. - return new_mix_rate; + return mix_rate; } -static av_cold uint32_t set_volume(AVMixerData *mixer_data, uint32_t amplify, uint32_t left_volume, uint32_t right_volume, uint32_t channels) +static av_cold uint32_t set_volume(AVMixerData *const mixer_data, + const uint32_t amplify, + const uint32_t left_volume, + const uint32_t right_volume, + const uint32_t channels) { - AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *const) mixer_data; AV_LQMixerChannelInfo *channel_info = NULL; AV_LQMixerChannelInfo *const old_channel_info = lq_mixer_data->channel_info; uint32_t old_channels, i; @@ -5251,9 +5280,11 @@ static av_cold uint32_t set_volume(AVMixerData *mixer_data, uint32_t amplify, ui return channels; } -static av_cold void get_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void get_channel(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + const AV_LQMixerData *const lq_mixer_data = (const AV_LQMixerData *const) mixer_data; const AV_LQMixerChannelInfo *const channel_info = lq_mixer_data->channel_info + channel; mixer_channel->pos = channel_info->current.offset; @@ -5272,9 +5303,11 @@ static av_cold void get_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_c mixer_channel->filter_damping = channel_info->current.filter_damping; } -static av_cold void set_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + const AV_LQMixerData *const lq_mixer_data = (const AV_LQMixerData *const) mixer_data; AV_LQMixerChannelInfo *const channel_info = lq_mixer_data->channel_info + channel; struct ChannelBlock *channel_block; uint32_t repeat, repeat_len; @@ -5322,9 +5355,10 @@ static av_cold void set_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_c set_sample_filter(lq_mixer_data, channel_info, channel_block, mixer_channel->filter_cutoff, mixer_channel->filter_damping); } -static av_cold void reset_channel(AVMixerData *mixer_data, uint32_t channel) +static av_cold void reset_channel(AVMixerData *const mixer_data, + const uint32_t channel) { - const AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + const AV_LQMixerData *const lq_mixer_data = (const AV_LQMixerData *const) mixer_data; AV_LQMixerChannelInfo *const channel_info = lq_mixer_data->channel_info + channel; struct ChannelBlock *channel_block = &channel_info->current; uint32_t repeat, repeat_len; @@ -5371,9 +5405,12 @@ static av_cold void reset_channel(AVMixerData *mixer_data, uint32_t channel) set_sample_filter(lq_mixer_data, channel_info, channel_block, 4095, 0); } -static av_cold void get_both_channels(AVMixerData *mixer_data, AVMixerChannel *mixer_channel_current, AVMixerChannel *mixer_channel_next, uint32_t channel) +static av_cold void get_both_channels(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel_current, + AVMixerChannel *const mixer_channel_next, + const uint32_t channel) { - const AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + const AV_LQMixerData *const lq_mixer_data = (const AV_LQMixerData *const) mixer_data; const AV_LQMixerChannelInfo *const channel_info = lq_mixer_data->channel_info + channel; mixer_channel_current->pos = channel_info->current.offset; @@ -5407,9 +5444,12 @@ static av_cold void get_both_channels(AVMixerData *mixer_data, AVMixerChannel *m mixer_channel_next->filter_damping = channel_info->next.filter_damping; } -static av_cold void set_both_channels(AVMixerData *mixer_data, AVMixerChannel *mixer_channel_current, AVMixerChannel *mixer_channel_next, uint32_t channel) +static av_cold void set_both_channels(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel_current, + const AVMixerChannel *const mixer_channel_next, + const uint32_t channel) { - const AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + const AV_LQMixerData *const lq_mixer_data = (const AV_LQMixerData *const) mixer_data; AV_LQMixerChannelInfo *const channel_info = lq_mixer_data->channel_info + channel; struct ChannelBlock *channel_block = &channel_info->current; uint32_t repeat, repeat_len; @@ -5488,9 +5528,11 @@ static av_cold void set_both_channels(AVMixerData *mixer_data, AVMixerChannel *m set_sample_filter(lq_mixer_data, channel_info, channel_block, mixer_channel_next->filter_cutoff, mixer_channel_next->filter_damping); } -static av_cold void set_channel_volume_panning_pitch(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_volume_panning_pitch(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + const AV_LQMixerData *const lq_mixer_data = (const AV_LQMixerData *const) mixer_data; AV_LQMixerChannelInfo *const channel_info = lq_mixer_data->channel_info + channel; if ((channel_info->current.volume == mixer_channel->volume) && (channel_info->current.panning == mixer_channel->panning)) { @@ -5529,9 +5571,11 @@ static av_cold void set_channel_volume_panning_pitch(AVMixerData *mixer_data, AV } } -static av_cold void set_channel_position_repeat_flags(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_position_repeat_flags(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + const AV_LQMixerData *const lq_mixer_data = (const AV_LQMixerData *const) mixer_data; AV_LQMixerChannelInfo *const channel_info = lq_mixer_data->channel_info + channel; if (channel_info->current.flags == mixer_channel->flags) { @@ -5604,16 +5648,18 @@ static av_cold void set_channel_position_repeat_flags(AVMixerData *mixer_data, A } } -static av_cold void set_channel_filter(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_filter(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; + const AV_LQMixerData *const lq_mixer_data = (const AV_LQMixerData *const) mixer_data; AV_LQMixerChannelInfo *const channel_info = lq_mixer_data->channel_info + channel; set_sample_filter(lq_mixer_data, channel_info, &channel_info->current, mixer_channel->filter_cutoff, mixer_channel->filter_damping); } -static av_cold void mix(AVMixerData *mixer_data, int32_t *buf) { - AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; +static av_cold void mix(AVMixerData *const mixer_data, int32_t *buf) { + AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *const) mixer_data; uint32_t mix_rate, current_left, current_left_frac, buf_size; if (!(lq_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_FROZEN)) { @@ -5659,8 +5705,11 @@ static av_cold void mix(AVMixerData *mixer_data, int32_t *buf) { // TODO: Execute post-processing step in libavfilter and pass the PCM data. } -static av_cold void mix_parallel(AVMixerData *mixer_data, int32_t *buf, const uint32_t first_channel, const uint32_t last_channel) { - AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *) mixer_data; +static av_cold void mix_parallel(AVMixerData *const mixer_data, + int32_t *buf, + const uint32_t first_channel, + const uint32_t last_channel) { + AV_LQMixerData *const lq_mixer_data = (AV_LQMixerData *const) mixer_data; uint32_t mix_rate, current_left, current_left_frac, buf_size; if (!(lq_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_FROZEN)) { diff --git a/libavsequencer/mixer.h b/libavsequencer/mixer.h index 191c927fe..b4632b572 100644 --- a/libavsequencer/mixer.h +++ b/libavsequencer/mixer.h @@ -274,68 +274,93 @@ typedef struct AVMixerContext { uint8_t flags; /** The initialization function to call for the mixer. */ - AVMixerData * (*init)(struct AVMixerContext *mixctx, const char *args, void *opaque); + AVMixerData * (*init)(struct AVMixerContext *const mixctx, + const char *args, void *opaque); /** The destruction function to call for the mixer. */ - int (*uninit)(AVMixerData *mixer_data); + int (*uninit)(AVMixerData *const mixer_data); /** Transfers a new mixing rate in Hz and number of output channels from the AVSequencer to the internal mixer data. */ - uint32_t (*set_rate)(AVMixerData *mixer_data, uint32_t new_mix_rate, - uint32_t new_channels); + uint32_t (*set_rate)(AVMixerData *const mixer_data, + const uint32_t mix_rate, + const uint32_t channels); /** Transfers the new time interval for calling the playback handler to the interal mixer, in AV_TIME_BASE fractional seconds. */ - uint32_t (*set_tempo)(AVMixerData *mixer_data, uint32_t new_tempo); + uint32_t (*set_tempo)(AVMixerData *const mixer_data, + const uint32_t tempo); /** Transfers the new volume boost, the new left position volume, the new right position volume and new number of maximum channels from the AVSequencer to the internal mixer data. */ - uint32_t (*set_volume)(AVMixerData *mixer_data, uint32_t amplify, - uint32_t left_volume, uint32_t right_volume, - uint32_t channels); + uint32_t (*set_volume)(AVMixerData *const mixer_data, + const uint32_t amplify, + const uint32_t left_volume, + const uint32_t right_volume, + const uint32_t channels); /** Transfers the current internal mixer channel data to the AVSequencer. */ - void (*get_channel)(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel); + void (*get_channel)(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel, + const uint32_t channel); /** Transfers the current AVSequencer channel data to the internal mixer channel data. */ - void (*set_channel)(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel); + void (*set_channel)(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel); /** Resets the AVSequencer channel data to the mixer internal default values. */ - void (*reset_channel)(AVMixerData *mixer_data, uint32_t channel); + void (*reset_channel)(AVMixerData *const mixer_data, + const uint32_t channel); /** Transfers both (current and next) internal mixer channel data to the AVSequencer. */ - void (*get_both_channels)(AVMixerData *mixer_data, AVMixerChannel *mixer_channel_current, AVMixerChannel *mixer_channel_next, uint32_t channel); + void (*get_both_channels)(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel_current, + AVMixerChannel *const mixer_channel_next, + const uint32_t channel); /** Transfers both (current and next) AVSequencer channel data to the internal mixer channel data. */ - void (*set_both_channels)(AVMixerData *mixer_data, AVMixerChannel *mixer_channel_current, AVMixerChannel *mixer_channel_next, uint32_t channel); + void (*set_both_channels)(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel_current, + const AVMixerChannel *const mixer_channel_next, + const uint32_t channel); /** Signals a volume, panning or pitch change from AVSequencer to the internal mixer. */ - void (*set_channel_volume_panning_pitch)(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel); + void (*set_channel_volume_panning_pitch)(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel); /** Signals a set sample position, set repeat and flags change from AVSequencer to the internal mixer. */ - void (*set_channel_position_repeat_flags)(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel); + void (*set_channel_position_repeat_flags)(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel); /** Signals a set (resonance) filter from AVSequencer to the internal mixer. */ - void (*set_channel_filter)(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel); + void (*set_channel_filter)(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel); /** Run the actual mixing engine by filling the buffer, i.e. the player data is converted to SAMPLE_FMT_S32. */ - void (*mix)(AVMixerData *mixer_data, int32_t *buf); + void (*mix)(AVMixerData *const mixer_data, int32_t *buf); /** Run the actual mixing engine by filling the buffer by specifying a channel range suitable for parallelziation, i.e. the player data is converted to SAMPLE_FMT_S32. */ - void (*mix_parallel)(AVMixerData *mixer_data, int32_t *buf, const uint32_t first_channel, const uint32_t last_channel); + void (*mix_parallel)(AVMixerData *const mixer_data, + int32_t *buf, + const uint32_t first_channel, + const uint32_t last_channel); } AVMixerContext; #endif /* AVSEQUENCER_MIXER_H */ diff --git a/libavsequencer/module.c b/libavsequencer/module.c index 74421b92a..a7b0abc87 100644 --- a/libavsequencer/module.c +++ b/libavsequencer/module.c @@ -365,7 +365,7 @@ int avseq_module_play(AVSequencerContext *avctx, AVMixerContext *mixctx, player_globals->relative_pitch = player_globals->relative_speed; tempo = avseq_song_calc_speed(avctx, song); - volume_boost = ((uint64_t) module->channels * (65536*125/1000)) + (65536*75/100); + volume_boost = ((uint32_t) module->channels * (65536*125/1000)) + (65536*75/100); mixer_data->flags |= AVSEQ_MIXER_DATA_FLAG_MIXING; if (mixctx) diff --git a/libavsequencer/null_mixer.c b/libavsequencer/null_mixer.c index 119a89ee9..dc2edde1d 100644 --- a/libavsequencer/null_mixer.c +++ b/libavsequencer/null_mixer.c @@ -122,7 +122,8 @@ MIX(skip_backwards) *fraction = curr_frac; } -static void mix_sample(AV_NULLMixerData *const mixer_data, const uint32_t len) +static void mix_sample(AV_NULLMixerData *const mixer_data, + const uint32_t len) { AV_NULLMixerChannelInfo *channel_info = mixer_data->channel_info; uint16_t i = mixer_data->channels_in; @@ -302,7 +303,10 @@ static void mix_sample(AV_NULLMixerData *const mixer_data, const uint32_t len) } while (--i); } -static void mix_sample_parallel(AV_NULLMixerData *const mixer_data, const uint32_t len, const uint32_t first_channel, const uint32_t last_channel) +static void mix_sample_parallel(AV_NULLMixerData *const mixer_data, + const uint32_t len, + const uint32_t first_channel, + const uint32_t last_channel) { AV_NULLMixerChannelInfo *channel_info = mixer_data->channel_info + first_channel; uint16_t i = (last_channel - first_channel) + 1; @@ -482,7 +486,9 @@ static void mix_sample_parallel(AV_NULLMixerData *const mixer_data, const uint32 } while (--i); } -static void set_sample_mix_rate(const AV_NULLMixerData *const mixer_data, struct ChannelBlock *const channel_block, const uint32_t rate) +static void set_sample_mix_rate(const AV_NULLMixerData *const mixer_data, + struct ChannelBlock *const channel_block, + const uint32_t rate) { const uint32_t mix_rate = mixer_data->mix_rate; @@ -491,7 +497,8 @@ static void set_sample_mix_rate(const AV_NULLMixerData *const mixer_data, struct channel_block->advance_frac = (((uint64_t) rate % mix_rate) << 32) / mix_rate; } -static av_cold AVMixerData *init(AVMixerContext *mixctx, const char *args, void *opaque) +static av_cold AVMixerData *init(AVMixerContext *const mixctx, + const char *args, void *opaque) { AV_NULLMixerData *null_mixer_data = NULL; AV_NULLMixerChannelInfo *channel_info; @@ -553,7 +560,7 @@ static av_cold AVMixerData *init(AVMixerContext *mixctx, const char *args, void return (AVMixerData *) null_mixer_data; } -static av_cold int uninit(AVMixerData *mixer_data) +static av_cold int uninit(AVMixerData *const mixer_data) { AV_NULLMixerData *null_mixer_data = (AV_NULLMixerData *) mixer_data; @@ -567,32 +574,35 @@ static av_cold int uninit(AVMixerData *mixer_data) return 0; } -static av_cold uint32_t set_tempo(AVMixerData *mixer_data, uint32_t new_tempo) +static av_cold uint32_t set_tempo(AVMixerData *const mixer_data, + const uint32_t tempo) { - AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *const) mixer_data; const uint32_t channel_rate = null_mixer_data->mix_rate * 10; uint64_t pass_value; - null_mixer_data->mixer_data.tempo = new_tempo; + null_mixer_data->mixer_data.tempo = tempo; pass_value = ((uint64_t) channel_rate << 16) + ((uint64_t) null_mixer_data->mix_rate_frac >> 16); null_mixer_data->pass_len = (uint64_t) pass_value / null_mixer_data->mixer_data.tempo; null_mixer_data->pass_len_frac = (((uint64_t) pass_value % null_mixer_data->mixer_data.tempo) << 32) / null_mixer_data->mixer_data.tempo; - return new_tempo; + return tempo; } -static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, uint32_t new_channels) +static av_cold uint32_t set_rate(AVMixerData *const mixer_data, + const uint32_t mix_rate, + const uint32_t channels) { - AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; - uint32_t buf_size, mix_rate, mix_rate_frac; + AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *const) mixer_data; + uint32_t buf_size, old_mix_rate, mix_rate_frac; buf_size = null_mixer_data->mixer_data.mix_buf_size; - null_mixer_data->mixer_data.rate = new_mix_rate; - null_mixer_data->mixer_data.channels_out = new_channels; + null_mixer_data->mixer_data.rate = mix_rate; + null_mixer_data->mixer_data.channels_out = channels; - if ((null_mixer_data->mixer_data.mix_buf_size * null_mixer_data->channels_out) != (buf_size * new_channels)) { + if ((null_mixer_data->mixer_data.mix_buf_size * null_mixer_data->channels_out) != (buf_size * channels)) { int32_t *buf = null_mixer_data->mixer_data.mix_buf; - const uint32_t mix_buf_mem_size = (buf_size * new_channels) << 2; + const uint32_t mix_buf_mem_size = (buf_size * channels) << 2; if (!(buf = av_realloc(buf, mix_buf_mem_size + FF_INPUT_BUFFER_PADDING_SIZE))) { av_log(null_mixer_data->mixer_data.mixctx, AV_LOG_ERROR, "Cannot allocate mixer output channel data.\n"); @@ -606,27 +616,27 @@ static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, null_mixer_data->mixer_data.mix_buf_size = buf_size; } - null_mixer_data->channels_out = new_channels; + null_mixer_data->channels_out = channels; if (null_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_MIXING) { - mix_rate = new_mix_rate; // TODO: Add check here if this mix rate is supported by target device + old_mix_rate = mix_rate; // TODO: Add check here if this mix rate is supported by target device mix_rate_frac = 0; - if (null_mixer_data->mix_rate != mix_rate) { + if (null_mixer_data->mix_rate != old_mix_rate) { AV_NULLMixerChannelInfo *channel_info = null_mixer_data->channel_info; uint16_t i; - null_mixer_data->mix_rate = mix_rate; + null_mixer_data->mix_rate = old_mix_rate; null_mixer_data->mix_rate_frac = mix_rate_frac; if (null_mixer_data->mixer_data.tempo) set_tempo((AVMixerData *) mixer_data, null_mixer_data->mixer_data.tempo); for (i = null_mixer_data->channels_in; i > 0; i--) { - channel_info->current.advance = channel_info->current.rate / mix_rate; - channel_info->current.advance_frac = (((uint64_t) channel_info->current.rate % mix_rate) << 32) / mix_rate; - channel_info->next.advance = channel_info->next.rate / mix_rate; - channel_info->next.advance_frac = (((uint64_t) channel_info->next.rate % mix_rate) << 32) / mix_rate; + channel_info->current.advance = channel_info->current.rate / old_mix_rate; + channel_info->current.advance_frac = (((uint64_t) channel_info->current.rate % old_mix_rate) << 32) / old_mix_rate; + channel_info->next.advance = channel_info->next.rate / old_mix_rate; + channel_info->next.advance_frac = (((uint64_t) channel_info->next.rate % old_mix_rate) << 32) / old_mix_rate; channel_info++; } @@ -635,12 +645,16 @@ static av_cold uint32_t set_rate(AVMixerData *mixer_data, uint32_t new_mix_rate, // TODO: Inform libavfilter that the target mixing rate has been changed. - return new_mix_rate; + return mix_rate; } -static av_cold uint32_t set_volume(AVMixerData *mixer_data, uint32_t amplify, uint32_t left_volume, uint32_t right_volume, uint32_t channels) +static av_cold uint32_t set_volume(AVMixerData *const mixer_data, + const uint32_t amplify, + const uint32_t left_volume, + const uint32_t right_volume, + const uint32_t channels) { - AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *const) mixer_data; AV_NULLMixerChannelInfo *channel_info = NULL; AV_NULLMixerChannelInfo *const old_channel_info = null_mixer_data->channel_info; uint32_t old_channels, i; @@ -691,9 +705,11 @@ static av_cold uint32_t set_volume(AVMixerData *mixer_data, uint32_t amplify, ui return channels; } -static av_cold void get_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void get_channel(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + const AV_NULLMixerData *const null_mixer_data = (const AV_NULLMixerData *const) mixer_data; const AV_NULLMixerChannelInfo *const channel_info = null_mixer_data->channel_info + channel; mixer_channel->pos = channel_info->current.offset; @@ -712,9 +728,11 @@ static av_cold void get_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_c mixer_channel->filter_damping = channel_info->current.filter_damping; } -static av_cold void set_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + const AV_NULLMixerData *const null_mixer_data = (const AV_NULLMixerData *const) mixer_data; AV_NULLMixerChannelInfo *const channel_info = null_mixer_data->channel_info + channel; struct ChannelBlock *channel_block; uint32_t repeat, repeat_len; @@ -767,9 +785,10 @@ static av_cold void set_channel(AVMixerData *mixer_data, AVMixerChannel *mixer_c set_sample_mix_rate(null_mixer_data, channel_block, mixer_channel->rate); } -static av_cold void reset_channel(AVMixerData *mixer_data, uint32_t channel) +static av_cold void reset_channel(AVMixerData *const mixer_data, + const uint32_t channel) { - const AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + const AV_NULLMixerData *const null_mixer_data = (const AV_NULLMixerData *const) mixer_data; AV_NULLMixerChannelInfo *const channel_info = null_mixer_data->channel_info + channel; struct ChannelBlock *channel_block = &channel_info->current; uint32_t repeat, repeat_len; @@ -814,9 +833,12 @@ static av_cold void reset_channel(AVMixerData *mixer_data, uint32_t channel) channel_block->filter_damping = 0; } -static av_cold void get_both_channels(AVMixerData *mixer_data, AVMixerChannel *mixer_channel_current, AVMixerChannel *mixer_channel_next, uint32_t channel) +static av_cold void get_both_channels(const AVMixerData *const mixer_data, + AVMixerChannel *const mixer_channel_current, + AVMixerChannel *const mixer_channel_next, + const uint32_t channel) { - const AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + const AV_NULLMixerData *const null_mixer_data = (const AV_NULLMixerData *const) mixer_data; const AV_NULLMixerChannelInfo *const channel_info = null_mixer_data->channel_info + channel; mixer_channel_current->pos = channel_info->current.offset; @@ -850,9 +872,12 @@ static av_cold void get_both_channels(AVMixerData *mixer_data, AVMixerChannel *m mixer_channel_next->filter_damping = channel_info->next.filter_damping; } -static av_cold void set_both_channels(AVMixerData *mixer_data, AVMixerChannel *mixer_channel_current, AVMixerChannel *mixer_channel_next, uint32_t channel) +static av_cold void set_both_channels(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel_current, + const AVMixerChannel *const mixer_channel_next, + const uint32_t channel) { - const AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + const AV_NULLMixerData *const null_mixer_data = (const AV_NULLMixerData *const) mixer_data; AV_NULLMixerChannelInfo *const channel_info = null_mixer_data->channel_info + channel; struct ChannelBlock *channel_block = &channel_info->current; uint32_t repeat, repeat_len; @@ -939,9 +964,11 @@ static av_cold void set_both_channels(AVMixerData *mixer_data, AVMixerChannel *m set_sample_mix_rate(null_mixer_data, channel_block, mixer_channel_next->rate); } -static av_cold void set_channel_volume_panning_pitch(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_volume_panning_pitch(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + const AV_NULLMixerData *const null_mixer_data = (const AV_NULLMixerData *const) mixer_data; AV_NULLMixerChannelInfo *const channel_info = null_mixer_data->channel_info + channel; if ((channel_info->current.volume == mixer_channel->volume) && (channel_info->current.panning == mixer_channel->panning)) { @@ -977,9 +1004,11 @@ static av_cold void set_channel_volume_panning_pitch(AVMixerData *mixer_data, AV } } -static av_cold void set_channel_position_repeat_flags(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_position_repeat_flags(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + const AV_NULLMixerData *const null_mixer_data = (const AV_NULLMixerData *const) mixer_data; AV_NULLMixerChannelInfo *const channel_info = null_mixer_data->channel_info + channel; if (channel_info->current.flags == mixer_channel->flags) { @@ -1050,9 +1079,11 @@ static av_cold void set_channel_position_repeat_flags(AVMixerData *mixer_data, A } } -static av_cold void set_channel_filter(AVMixerData *mixer_data, AVMixerChannel *mixer_channel, uint32_t channel) +static av_cold void set_channel_filter(AVMixerData *const mixer_data, + const AVMixerChannel *const mixer_channel, + const uint32_t channel) { - const AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + const AV_NULLMixerData *const null_mixer_data = (const AV_NULLMixerData *const) mixer_data; AV_NULLMixerChannelInfo *const channel_info = null_mixer_data->channel_info + channel; if ((channel_info->current.filter_cutoff = mixer_channel->filter_cutoff) > 4095) @@ -1062,9 +1093,9 @@ static av_cold void set_channel_filter(AVMixerData *mixer_data, AVMixerChannel * channel_info->current.filter_damping = 4095; } -static av_cold void mix(AVMixerData *mixer_data, int32_t *buf) +static av_cold void mix(AVMixerData *const mixer_data, int32_t *buf) { - AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *const) mixer_data; uint32_t mix_rate, current_left, current_left_frac, buf_size; if (!(null_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_FROZEN)) { @@ -1104,9 +1135,12 @@ static av_cold void mix(AVMixerData *mixer_data, int32_t *buf) } } -static av_cold void mix_parallel(AVMixerData *mixer_data, int32_t *buf, const uint32_t first_channel, const uint32_t last_channel) +static av_cold void mix_parallel(AVMixerData *const mixer_data, + int32_t *buf, + const uint32_t first_channel, + const uint32_t last_channel) { - AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *) mixer_data; + AV_NULLMixerData *const null_mixer_data = (AV_NULLMixerData *const) mixer_data; uint32_t mix_rate, current_left, current_left_frac, buf_size; if (!(null_mixer_data->mixer_data.flags & AVSEQ_MIXER_DATA_FLAG_FROZEN)) { diff --git a/libavsequencer/player.c b/libavsequencer/player.c index 6c958ad39..96a7b8624 100644 --- a/libavsequencer/player.c +++ b/libavsequencer/player.c @@ -2990,15 +2990,15 @@ EXECUTE_EFFECT(tremor) { player_host_channel->tremor_on_ticks = tremor_on; - if (!(player_host_channel->flags & AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_OFF)) - tremor_off = tremor_on; + if (player_channel->mixer.flags & AVSEQ_MIXER_CHANNEL_FLAG_PLAY) { + if (!(player_host_channel->flags & AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_ON)) + tremor_off = tremor_on; - if (tremor_off <= player_host_channel->tremor_count) { - player_host_channel->flags ^= AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_OFF; - player_host_channel->tremor_count = 0; + if (player_host_channel->tremor_count-- <= 1) { + player_host_channel->flags ^= AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_ON; + player_host_channel->tremor_count = tremor_off; + } } - - player_host_channel->tremor_count++; } EXECUTE_EFFECT(note_retrigger) @@ -10665,7 +10665,7 @@ int avseq_playback_handler(AVMixerData *mixer_data) player_host_channel->virtual_channels++; virtual_channel++; - if (!(player_channel->flags & AVSEQ_PLAYER_CHANNEL_FLAG_BACKGROUND) && (player_host_channel->virtual_channel == channel) && (player_host_channel->flags & AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_EXEC) && (player_host_channel->flags & AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_OFF)) + if (!(player_channel->flags & AVSEQ_PLAYER_CHANNEL_FLAG_BACKGROUND) && (player_host_channel->virtual_channel == channel) && (player_host_channel->flags & AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_EXEC) && (!(player_host_channel->flags & AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_ON))) host_volume = 0; host_volume *= (uint16_t) player_host_channel->track_volume * (uint16_t) player_channel->instr_volume; diff --git a/libavsequencer/player.h b/libavsequencer/player.h index 1ec4e84c5..d9ed30ff1 100644 --- a/libavsequencer/player.h +++ b/libavsequencer/player.h @@ -469,7 +469,7 @@ enum AVSequencerPlayerHostChannelFlags { AVSEQ_PLAYER_HOST_CHANNEL_FLAG_SET_TRANSPOSE = 0x00000200, ///< Set transpose effect invoked AVSEQ_PLAYER_HOST_CHANNEL_FLAG_SUB_SLIDE_RETRIG = 0x00000400, ///< Allow sub-slides in multi retrigger note AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_EXEC = 0x00000800, ///< Tremor effect in hold, i.e. invoked - AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_OFF = 0x00001000, ///< Tremor effect is currently turning off volume + AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOR_ON = 0x00001000, ///< Tremor effect is currently turning on volume AVSEQ_PLAYER_HOST_CHANNEL_FLAG_RETRIG_NOTE = 0x00002000, ///< Note retrigger effect invoked AVSEQ_PLAYER_HOST_CHANNEL_FLAG_VIBRATO = 0x00004000, ///< Vibrato effect in hold, i.e. invoked AVSEQ_PLAYER_HOST_CHANNEL_FLAG_TREMOLO = 0x00008000, ///< Tremolo effect in hold, i.e. invoked @@ -932,10 +932,10 @@ typedef struct AVSequencerPlayerHostChannel { used yet during playback. */ uint8_t tremor_off_ticks; - /** Current number of tick for tremor command. This will allow - the player to determine if we are currently in a tremor on - or tremor off phase and can also be 0 if the tremor effect - was not used yet during playback. */ + /** Current remaining number of ticks for tremor command before + the effect switches from off to on state (and vice versa). + This also can be 0 in case the tremor effect was not used + yet during playback or has been initialized with zero. */ uint8_t tremor_count; /** Current mask of sub-slide bits or 0 if the set target