vars_process_operators.h

Go to the documentation of this file.

// WARNING: Automated generated files, do not edit
#pragma once
 
#if __cplusplus > 201703L
    #include <array>
    #define STD_TO_ARRAY std::to_array
#else
    #include <experimental/array>
    #define STD_TO_ARRAY std::experimental::to_array
#endif
 
//  =============================
//  ========= operators  ========
//  =============================
//  =============================
//  ========== structs  =========
//  =============================
// === struct peakhold ===
static inline bool operator==(const json_peakhold &a, const json_peakhold &b) {
  return true
      && (a.hold == b.hold)
      && (a.pk == b.pk)
      ;
}
static inline bool operator!=(const json_peakhold &a, const json_peakhold &b) {
      return !(a==b);
}
 
// === struct peakhold_stereo ===
static inline bool operator==(const json_peakhold_stereo &a, const json_peakhold_stereo &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_peakhold_stereo &a, const json_peakhold_stereo &b) {
      return !(a==b);
}
 
// === struct vupeakhold_stereo ===
static inline bool operator==(const json_vupeakhold_stereo &a, const json_vupeakhold_stereo &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      && (STD_TO_ARRAY(a.vu) == STD_TO_ARRAY(b.vu))
      ;
}
static inline bool operator!=(const json_vupeakhold_stereo &a, const json_vupeakhold_stereo &b) {
      return !(a==b);
}
 
// === struct peak_percent ===
static inline bool operator==(const json_peak_percent &a, const json_peak_percent &b) {
  return true
      && (a.hold == b.hold)
      && (a.pk == b.pk)
      ;
}
static inline bool operator!=(const json_peak_percent &a, const json_peak_percent &b) {
      return !(a==b);
}
 
// === struct agc_peakhold ===
static inline bool operator==(const json_agc_peakhold &a, const json_agc_peakhold &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_agc_peakhold &a, const json_agc_peakhold &b) {
      return !(a==b);
}
 
// === struct agc_stereo_peakhold ===
static inline bool operator==(const json_agc_stereo_peakhold &a, const json_agc_stereo_peakhold &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_agc_stereo_peakhold &a, const json_agc_stereo_peakhold &b) {
      return !(a==b);
}
 
// === struct band_peakhold ===
static inline bool operator==(const json_band_peakhold &a, const json_band_peakhold &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_band_peakhold &a, const json_band_peakhold &b) {
      return !(a==b);
}
 
// === struct band_stereo_peakhold ===
static inline bool operator==(const json_band_stereo_peakhold &a, const json_band_stereo_peakhold &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_band_stereo_peakhold &a, const json_band_stereo_peakhold &b) {
      return !(a==b);
}
 
// === struct band_peak_percent ===
static inline bool operator==(const json_band_peak_percent &a, const json_band_peak_percent &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_band_peak_percent &a, const json_band_peak_percent &b) {
      return !(a==b);
}
 
// === struct bandlim_peakhold ===
static inline bool operator==(const json_bandlim_peakhold &a, const json_bandlim_peakhold &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_bandlim_peakhold &a, const json_bandlim_peakhold &b) {
      return !(a==b);
}
 
// === struct bandlim_stereo_peakhold ===
static inline bool operator==(const json_bandlim_stereo_peakhold &a, const json_bandlim_stereo_peakhold &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_bandlim_stereo_peakhold &a, const json_bandlim_stereo_peakhold &b) {
      return !(a==b);
}
 
// === struct bandlim_peak_percent ===
static inline bool operator==(const json_bandlim_peak_percent &a, const json_bandlim_peak_percent &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_bandlim_peak_percent &a, const json_bandlim_peak_percent &b) {
      return !(a==b);
}
 
 
//  =============================
//  ========== objects  =========
//  =============================
// === object preset_setup Preset ===
static inline bool operator==(const json_preset_setup &a, const json_preset_setup &b) {
  return true
      && (a.gate_on == b.gate_on)
      && (a.gate == b.gate)
      && (a.hp_on == b.hp_on)
      && (a.hp_freq == b.hp_freq)
      && (a.stereo_link == b.stereo_link)
      && (a.agc_matricing == b.agc_matricing)
      && (a.band_matricing == b.band_matricing)
      && (a.agc_usewide == b.agc_usewide)
      && (a.changespeed == b.changespeed)
      && (a.smoothagc_on == b.smoothagc_on)
      && (a.smoothband_on == b.smoothband_on)
      && (a.preset_mode == b.preset_mode)
      && (a.display_agc == b.display_agc)
      && (a.display_tonefx == b.display_tonefx)
      && (a.display_stereofx == b.display_stereofx)
      && (a.display_bandexp == b.display_bandexp)
      && (a.display_bandprocess == b.display_bandprocess)
      && (a.display_bandlook == b.display_bandlook)
      && (a.display_bandlim == b.display_bandlim)
      && (a.display_bassclip == b.display_bassclip)
      && (a.display_agcattack == b.display_agcattack)
      && (a.display_bassfx == b.display_bassfx)
      && (a.display_treblefx == b.display_treblefx)
      && (a.display_bandimpact == b.display_bandimpact)
      && (a.display_bandattack == b.display_bandattack)
      && (a.display_bandratio == b.display_bandratio)
      && (a.display_bandthickness == b.display_bandthickness)
      ;
}
static inline bool operator!=(const json_preset_setup &a, const json_preset_setup &b) {
      return !(a==b);
}
 
// === object preset_setup VU ===
static inline bool operator==(const jsonvu_preset_setup &a, const jsonvu_preset_setup &b) {
  return true
      && (a.has_tonefx == b.has_tonefx)
      && (a.has_bandexp == b.has_bandexp)
      && (a.has_bandlook == b.has_bandlook)
      && (a.has_bandlim == b.has_bandlim)
      && (a.has_bassclip == b.has_bassclip)
      && (a.show_stereolink == b.show_stereolink)
      && (a.show_2bagc == b.show_2bagc)
      && (a.show_agcwide == b.show_agcwide)
      ;
}
static inline bool operator!=(const jsonvu_preset_setup &a, const jsonvu_preset_setup &b) {
      return !(a==b);
}
 
// === object input Preset ===
static inline bool operator==(const json_input &a, const json_input &b) {
  return true
      ;
}
static inline bool operator!=(const json_input &a, const json_input &b) {
      return !(a==b);
}
 
// === object input VU ===
static inline bool operator==(const jsonvu_input &a, const jsonvu_input &b) {
  return true
      && (a.vu == b.vu)
      && (a.standby == b.standby)
      && (a.vuout == b.vuout)
      && (a.bs_moment == b.bs_moment)
      && (a.bs_short == b.bs_short)
      && (a.bs_long == b.bs_long)
      && (a.bs_user == b.bs_user)
      && (a.bs_psr == b.bs_psr)
      && (a.bs_plr == b.bs_plr)
      ;
}
static inline bool operator!=(const jsonvu_input &a, const jsonvu_input &b) {
      return !(a==b);
}
 
// === object agc Preset ===
static inline bool operator==(const json_agc &a, const json_agc &b) {
  return true
      && (a.on == b.on)
      && (a.freq == b.freq)
      && (a.hp_on == b.hp_on)
      && (a.hp_freq == b.hp_freq)
      && (a.gate_on == b.gate_on)
      && (STD_TO_ARRAY(a.gate) == STD_TO_ARRAY(b.gate))
      && (a.drive_on == b.drive_on)
      && (STD_TO_ARRAY(a.drive) == STD_TO_ARRAY(b.drive))
      && (STD_TO_ARRAY(a.threshold) == STD_TO_ARRAY(b.threshold))
      && (STD_TO_ARRAY(a.postgain) == STD_TO_ARRAY(b.postgain))
      && (STD_TO_ARRAY(a.ratio) == STD_TO_ARRAY(b.ratio))
      && (STD_TO_ARRAY(a.attack) == STD_TO_ARRAY(b.attack))
      && (STD_TO_ARRAY(a.release) == STD_TO_ARRAY(b.release))
      && (STD_TO_ARRAY(a.sustain) == STD_TO_ARRAY(b.sustain))
      && (a.autoatt_mode == b.autoatt_mode)
      && (STD_TO_ARRAY(a.autoatt_max) == STD_TO_ARRAY(b.autoatt_max))
      && (STD_TO_ARRAY(a.autoatt_start) == STD_TO_ARRAY(b.autoatt_start))
      && (STD_TO_ARRAY(a.autoatt_stop) == STD_TO_ARRAY(b.autoatt_stop))
      && (a.autoatt_sym == b.autoatt_sym)
      && (a.nbperiod == b.nbperiod)
      && (a.smooth_agc == b.smooth_agc)
      && (STD_TO_ARRAY(a.impact) == STD_TO_ARRAY(b.impact))
      && (STD_TO_ARRAY(a.avg_speed_gain) == STD_TO_ARRAY(b.avg_speed_gain))
      && (STD_TO_ARRAY(a.avg_speed_in) == STD_TO_ARRAY(b.avg_speed_in))
      && (STD_TO_ARRAY(a.ref_speed_in) == STD_TO_ARRAY(b.ref_speed_in))
      && (a.fidelity_on == b.fidelity_on)
      && (a.fidelity_speed == b.fidelity_speed)
      && (STD_TO_ARRAY(a.fidelity) == STD_TO_ARRAY(b.fidelity))
      && (a.attack_min == b.attack_min)
      && (a.attack_max == b.attack_max)
      && (STD_TO_ARRAY(a.voicethres) == STD_TO_ARRAY(b.voicethres))
      && (a.peak_mode == b.peak_mode)
      ;
}
static inline bool operator!=(const json_agc &a, const json_agc &b) {
      return !(a==b);
}
 
// === object agc VU ===
static inline bool operator==(const jsonvu_agc &a, const jsonvu_agc &b) {
  return true
      && (a.in == b.in)
      && (STD_TO_ARRAY(a.gated) == STD_TO_ARRAY(b.gated))
      && (a.fidel == b.fidel)
      && (a.mes_in == b.mes_in)
      && (a.in_avg == b.in_avg)
      && (a.gain == b.gain)
      && (a.out == b.out)
      && (a.gain_avg == b.gain_avg)
      && (a.attack_vu == b.attack_vu)
      && (a.attack_min_vu == b.attack_min_vu)
      && (a.attack_max_vu == b.attack_max_vu)
      && (a.vu_on == b.vu_on)
      && (a.vu_freq == b.vu_freq)
      ;
}
static inline bool operator!=(const jsonvu_agc &a, const jsonvu_agc &b) {
      return !(a==b);
}
 
// === object agcwide Preset ===
static inline bool operator==(const json_agcwide &a, const json_agcwide &b) {
  return true
      && (a.on == b.on)
      && (a.hp_on == b.hp_on)
      && (a.hp_freq == b.hp_freq)
      && (a.gate_on == b.gate_on)
      && (a.gate == b.gate)
      && (a.drive_on == b.drive_on)
      && (a.drive == b.drive)
      && (a.threshold == b.threshold)
      && (a.postgain == b.postgain)
      && (a.ratio == b.ratio)
      && (a.attack == b.attack)
      && (a.release == b.release)
      && (a.sustain == b.sustain)
      && (a.autoatt_mode == b.autoatt_mode)
      && (a.autoatt_max == b.autoatt_max)
      && (a.autoatt_start == b.autoatt_start)
      && (a.autoatt_stop == b.autoatt_stop)
      && (a.autoatt_sym == b.autoatt_sym)
      && (a.nbperiod == b.nbperiod)
      && (a.smooth_agc == b.smooth_agc)
      && (a.impact == b.impact)
      && (a.avg_speed_gain == b.avg_speed_gain)
      && (a.avg_speed_in == b.avg_speed_in)
      && (a.ref_speed_in == b.ref_speed_in)
      && (a.attack_min == b.attack_min)
      && (a.attack_max == b.attack_max)
      && (a.voicethres == b.voicethres)
      && (a.peak_mode == b.peak_mode)
      ;
}
static inline bool operator!=(const json_agcwide &a, const json_agcwide &b) {
      return !(a==b);
}
 
// === object agcwide VU ===
static inline bool operator==(const jsonvu_agcwide &a, const jsonvu_agcwide &b) {
  return true
      && (a.in == b.in)
      && (a.gated == b.gated)
      && (a.mes_in == b.mes_in)
      && (a.in_avg == b.in_avg)
      && (a.gain == b.gain)
      && (a.out == b.out)
      && (a.gain_avg == b.gain_avg)
      && (a.attack_vu == b.attack_vu)
      && (a.attack_min_vu == b.attack_min_vu)
      && (a.attack_max_vu == b.attack_max_vu)
      && (a.vu_on == b.vu_on)
      ;
}
static inline bool operator!=(const jsonvu_agcwide &a, const jsonvu_agcwide &b) {
      return !(a==b);
}
 
// === object tonefx Preset ===
static inline bool operator==(const json_tonefx &a, const json_tonefx &b) {
  return true
      && (a.on == b.on)
      && (STD_TO_ARRAY(a.eq_on) == STD_TO_ARRAY(b.eq_on))
      && (STD_TO_ARRAY(a.eq_freq) == STD_TO_ARRAY(b.eq_freq))
      && (STD_TO_ARRAY(a.eq_Q) == STD_TO_ARRAY(b.eq_Q))
      && (STD_TO_ARRAY(a.eq_gain) == STD_TO_ARRAY(b.eq_gain))
      && (a.bass_on == b.bass_on)
      && (a.bass_gain == b.bass_gain)
      && (a.bass_gain_max == b.bass_gain_max)
      && (a.bass_freq == b.bass_freq)
      && (a.bass_fix_mode == b.bass_fix_mode)
      && (a.bass_efficiency == b.bass_efficiency)
      && (a.bass_threshold == b.bass_threshold)
      && (a.bass_attack == b.bass_attack)
      && (a.bass_release == b.bass_release)
      && (a.treble_on == b.treble_on)
      && (a.treble_value == b.treble_value)
      && (a.treble_value_max == b.treble_value_max)
      && (a.treble_range == b.treble_range)
      ;
}
static inline bool operator!=(const json_tonefx &a, const json_tonefx &b) {
      return !(a==b);
}
 
// === object tonefx VU ===
static inline bool operator==(const jsonvu_tonefx &a, const jsonvu_tonefx &b) {
  return true
      && (a.bass_vu == b.bass_vu)
      && (a.bass_gain_max_vu == b.bass_gain_max_vu)
      && (a.treble_value_max_vu == b.treble_value_max_vu)
      ;
}
static inline bool operator!=(const jsonvu_tonefx &a, const jsonvu_tonefx &b) {
      return !(a==b);
}
 
// === object stereofx Preset ===
static inline bool operator==(const json_stereofx &a, const json_stereofx &b) {
  return true
      && (a.on == b.on)
      && (a.enh_on == b.enh_on)
      && (a.enh_width == b.enh_width)
      && (a.enh_attack == b.enh_attack)
      && (a.enh_release == b.enh_release)
      && (a.enh_threshold == b.enh_threshold)
      && (a.enh_thresLR == b.enh_thresLR)
      && (a.lim_on == b.lim_on)
      && (STD_TO_ARRAY(a.lim_threshold) == STD_TO_ARRAY(b.lim_threshold))
      && (STD_TO_ARRAY(a.lim_attack) == STD_TO_ARRAY(b.lim_attack))
      && (STD_TO_ARRAY(a.lim_release) == STD_TO_ARRAY(b.lim_release))
      && (a.clean_on == b.clean_on)
      && (STD_TO_ARRAY(a.clean_threshold) == STD_TO_ARRAY(b.clean_threshold))
      && (STD_TO_ARRAY(a.clean_release) == STD_TO_ARRAY(b.clean_release))
      ;
}
static inline bool operator!=(const json_stereofx &a, const json_stereofx &b) {
      return !(a==b);
}
 
// === object stereofx VU ===
static inline bool operator==(const jsonvu_stereofx &a, const jsonvu_stereofx &b) {
  return true
      && (a.enh_vu == b.enh_vu)
      && (a.lim_bdvu == b.lim_bdvu)
      && (a.lim_vu == b.lim_vu)
      && (a.clean_bdvu == b.clean_bdvu)
      && (a.clean_vu == b.clean_vu)
      ;
}
static inline bool operator!=(const jsonvu_stereofx &a, const jsonvu_stereofx &b) {
      return !(a==b);
}
 
// === object bandexp Preset ===
static inline bool operator==(const json_bandexp &a, const json_bandexp &b) {
  return true
      && (a.on == b.on)
      && (a.down_on == b.down_on)
      && (a.matrix_on == b.matrix_on)
      && (a.stereo_link == b.stereo_link)
      && (a.up_on == b.up_on)
      && (a.drive_on == b.drive_on)
      && (STD_TO_ARRAY(a.drive) == STD_TO_ARRAY(b.drive))
      && (STD_TO_ARRAY(a.postgain) == STD_TO_ARRAY(b.postgain))
      && (STD_TO_ARRAY(a.down_thres) == STD_TO_ARRAY(b.down_thres))
      && (STD_TO_ARRAY(a.down_ratio) == STD_TO_ARRAY(b.down_ratio))
      && (STD_TO_ARRAY(a.down_attack) == STD_TO_ARRAY(b.down_attack))
      && (STD_TO_ARRAY(a.down_release) == STD_TO_ARRAY(b.down_release))
      && (a.down_sustain_on == b.down_sustain_on)
      && (STD_TO_ARRAY(a.down_sustain) == STD_TO_ARRAY(b.down_sustain))
      && (STD_TO_ARRAY(a.down_min) == STD_TO_ARRAY(b.down_min))
      && (STD_TO_ARRAY(a.up_thres) == STD_TO_ARRAY(b.up_thres))
      && (STD_TO_ARRAY(a.up_ratio) == STD_TO_ARRAY(b.up_ratio))
      && (STD_TO_ARRAY(a.up_attack) == STD_TO_ARRAY(b.up_attack))
      && (STD_TO_ARRAY(a.up_release) == STD_TO_ARRAY(b.up_release))
      && (a.up_sustain_on == b.up_sustain_on)
      && (STD_TO_ARRAY(a.up_sustain) == STD_TO_ARRAY(b.up_sustain))
      && (STD_TO_ARRAY(a.up_max) == STD_TO_ARRAY(b.up_max))
      ;
}
static inline bool operator!=(const json_bandexp &a, const json_bandexp &b) {
      return !(a==b);
}
 
// === object bandexp VU ===
static inline bool operator==(const jsonvu_bandexp &a, const jsonvu_bandexp &b) {
  return true
      && (a.down == b.down)
      && (a.up == b.up)
      && (a.mes_in == b.mes_in)
      ;
}
static inline bool operator!=(const jsonvu_bandexp &a, const jsonvu_bandexp &b) {
      return !(a==b);
}
 
// === object bandprocess Preset ===
static inline bool operator==(const json_bandprocess &a, const json_bandprocess &b) {
  return true
      && (a.on == b.on)
      && (STD_TO_ARRAY(a.freq) == STD_TO_ARRAY(b.freq))
      && (a.gate_on == b.gate_on)
      && (a.gate_to_avg == b.gate_to_avg)
      && (STD_TO_ARRAY(a.gate) == STD_TO_ARRAY(b.gate))
      && (a.fidelity_on == b.fidelity_on)
      && (a.fidelity_speed == b.fidelity_speed)
      && (STD_TO_ARRAY(a.fidelity) == STD_TO_ARRAY(b.fidelity))
      && (a.peak_mode == b.peak_mode)
      && (a.drive_on == b.drive_on)
      && (STD_TO_ARRAY(a.drive) == STD_TO_ARRAY(b.drive))
      && (a.threshold_on == b.threshold_on)
      && (STD_TO_ARRAY(a.threshold) == STD_TO_ARRAY(b.threshold))
      && (STD_TO_ARRAY(a.base_thres) == STD_TO_ARRAY(b.base_thres))
      && (STD_TO_ARRAY(a.postgain) == STD_TO_ARRAY(b.postgain))
      && (STD_TO_ARRAY(a.ratio) == STD_TO_ARRAY(b.ratio))
      && (STD_TO_ARRAY(a.attack) == STD_TO_ARRAY(b.attack))
      && (STD_TO_ARRAY(a.release) == STD_TO_ARRAY(b.release))
      && (STD_TO_ARRAY(a.releasesustain) == STD_TO_ARRAY(b.releasesustain))
      && (a.sustain_on == b.sustain_on)
      && (STD_TO_ARRAY(a.sustain) == STD_TO_ARRAY(b.sustain))
      && (a.nbperiod == b.nbperiod)
      && (a.smooth_band == b.smooth_band)
      && (a.impact_on == b.impact_on)
      && (STD_TO_ARRAY(a.impact) == STD_TO_ARRAY(b.impact))
      && (a.mix_on == b.mix_on)
      && (STD_TO_ARRAY(a.mix) == STD_TO_ARRAY(b.mix))
      && (STD_TO_ARRAY(a.avg_speed_gain) == STD_TO_ARRAY(b.avg_speed_gain))
      && (STD_TO_ARRAY(a.voicethres) == STD_TO_ARRAY(b.voicethres))
      && (a.voiceattack_on == b.voiceattack_on)
      && (STD_TO_ARRAY(a.voiceattack) == STD_TO_ARRAY(b.voiceattack))
      && (STD_TO_ARRAY(a.voicemix) == STD_TO_ARRAY(b.voicemix))
      && (a.attack_min == b.attack_min)
      && (a.attack_max == b.attack_max)
      && (a.release_min == b.release_min)
      && (a.release_max == b.release_max)
      && (a.listen == b.listen)
      ;
}
static inline bool operator!=(const json_bandprocess &a, const json_bandprocess &b) {
      return !(a==b);
}
 
// === object bandprocess VU ===
static inline bool operator==(const jsonvu_bandprocess &a, const jsonvu_bandprocess &b) {
  return true
      && (a.splitin == b.splitin)
      && (a.fidel == b.fidel)
      && (a.splitout == b.splitout)
      && (STD_TO_ARRAY(a.gated) == STD_TO_ARRAY(b.gated))
      && (a.in == b.in)
      && (a.gain_avg == b.gain_avg)
      && (a.gain == b.gain)
      && (a.attack_min_vu == b.attack_min_vu)
      && (a.attack_max_vu == b.attack_max_vu)
      && (a.release_min_vu == b.release_min_vu)
      && (a.release_max_vu == b.release_max_vu)
      && (a.vu_on == b.vu_on)
      && (STD_TO_ARRAY(a.vu_freq) == STD_TO_ARRAY(b.vu_freq))
      ;
}
static inline bool operator!=(const jsonvu_bandprocess &a, const jsonvu_bandprocess &b) {
      return !(a==b);
}
 
// === object bandlook Preset ===
static inline bool operator==(const json_bandlook &a, const json_bandlook &b) {
  return true
      && (a.on == b.on)
      && (STD_TO_ARRAY(a.drive) == STD_TO_ARRAY(b.drive))
      && (STD_TO_ARRAY(a.base_drive) == STD_TO_ARRAY(b.base_drive))
      && (STD_TO_ARRAY(a.threshold) == STD_TO_ARRAY(b.threshold))
      && (STD_TO_ARRAY(a.base_thres) == STD_TO_ARRAY(b.base_thres))
      && (a.latency == b.latency)
      && (STD_TO_ARRAY(a.attack) == STD_TO_ARRAY(b.attack))
      && (STD_TO_ARRAY(a.release) == STD_TO_ARRAY(b.release))
      && (STD_TO_ARRAY(a.mix) == STD_TO_ARRAY(b.mix))
      && (a.factor == b.factor)
      && (a.fidelity_on == b.fidelity_on)
      && (STD_TO_ARRAY(a.fidelity) == STD_TO_ARRAY(b.fidelity))
      && (a.attack_min == b.attack_min)
      && (a.attack_max == b.attack_max)
      && (a.release_min == b.release_min)
      && (a.release_max == b.release_max)
      ;
}
static inline bool operator!=(const json_bandlook &a, const json_bandlook &b) {
      return !(a==b);
}
 
// === object bandlook VU ===
static inline bool operator==(const jsonvu_bandlook &a, const jsonvu_bandlook &b) {
  return true
      && (a.gain == b.gain)
      && (a.fidel == b.fidel)
      && (a.attack_min_vu == b.attack_min_vu)
      && (a.attack_max_vu == b.attack_max_vu)
      && (a.release_min_vu == b.release_min_vu)
      && (a.release_max_vu == b.release_max_vu)
      ;
}
static inline bool operator!=(const jsonvu_bandlook &a, const jsonvu_bandlook &b) {
      return !(a==b);
}
 
// === object bandlim Preset ===
static inline bool operator==(const json_bandlim &a, const json_bandlim &b) {
  return true
      && (a.on == b.on)
      && (STD_TO_ARRAY(a.freq) == STD_TO_ARRAY(b.freq))
      && (a.drive_on == b.drive_on)
      && (STD_TO_ARRAY(a.drive) == STD_TO_ARRAY(b.drive))
      && (a.threshold_on == b.threshold_on)
      && (STD_TO_ARRAY(a.threshold) == STD_TO_ARRAY(b.threshold))
      && (STD_TO_ARRAY(a.base_thres) == STD_TO_ARRAY(b.base_thres))
      && (STD_TO_ARRAY(a.postgain) == STD_TO_ARRAY(b.postgain))
      && (a.mix_on == b.mix_on)
      && (STD_TO_ARRAY(a.mix) == STD_TO_ARRAY(b.mix))
      && (a.fidelity_on == b.fidelity_on)
      && (a.fidelity_speed == b.fidelity_speed)
      && (STD_TO_ARRAY(a.fidelity) == STD_TO_ARRAY(b.fidelity))
      && (a.listen == b.listen)
      ;
}
static inline bool operator!=(const json_bandlim &a, const json_bandlim &b) {
      return !(a==b);
}
 
// === object bandlim VU ===
static inline bool operator==(const jsonvu_bandlim &a, const jsonvu_bandlim &b) {
  return true
      && (a.splitin == b.splitin)
      && (a.splitout == b.splitout)
      && (a.in == b.in)
      && (a.fidel == b.fidel)
      && (a.gain == b.gain)
      ;
}
static inline bool operator!=(const jsonvu_bandlim &a, const jsonvu_bandlim &b) {
      return !(a==b);
}
 
// === object parameq Preset ===
static inline bool operator==(const json_parameq &a, const json_parameq &b) {
  return true
      && (a.on == b.on)
      && (STD_TO_ARRAY(a.eq_on) == STD_TO_ARRAY(b.eq_on))
      && (STD_TO_ARRAY(a.eq_freq) == STD_TO_ARRAY(b.eq_freq))
      && (STD_TO_ARRAY(a.eq_Q) == STD_TO_ARRAY(b.eq_Q))
      && (STD_TO_ARRAY(a.eq_gain) == STD_TO_ARRAY(b.eq_gain))
      ;
}
static inline bool operator!=(const json_parameq &a, const json_parameq &b) {
      return !(a==b);
}
 
// === object parameq VU ===
static inline bool operator==(const jsonvu_parameq &a, const jsonvu_parameq &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_parameq &a, const jsonvu_parameq &b) {
      return !(a==b);
}
 
// === object bassclip Preset ===
static inline bool operator==(const json_bassclip &a, const json_bassclip &b) {
  return true
      && (a.on == b.on)
      && (a.freq == b.freq)
      && (a.drive == b.drive)
      && (a.base_drive == b.base_drive)
      && (a.threshold == b.threshold)
      && (a.base_thres == b.base_thres)
      && (a.postgain == b.postgain)
      ;
}
static inline bool operator!=(const json_bassclip &a, const json_bassclip &b) {
      return !(a==b);
}
 
// === object bassclip VU ===
static inline bool operator==(const jsonvu_bassclip &a, const jsonvu_bassclip &b) {
  return true
      && (a.gain == b.gain)
      ;
}
static inline bool operator!=(const jsonvu_bassclip &a, const jsonvu_bassclip &b) {
      return !(a==b);
}
 
// === object limiter Preset ===
static inline bool operator==(const json_limiter &a, const json_limiter &b) {
  return true
      && (a.drive_on == b.drive_on)
      && (a.drive == b.drive)
      && (a.base_drive == b.base_drive)
      && (a.threshold == b.threshold)
      && (a.base_thres == b.base_thres)
      && (a.latency == b.latency)
      && (a.attack == b.attack)
      && (a.release == b.release)
      && (a.overdrive_on == b.overdrive_on)
      && (a.overdrive == b.overdrive)
      && (a.factor == b.factor)
      && (STD_TO_ARRAY(a.rel_tab) == STD_TO_ARRAY(b.rel_tab))
      && (a.driveless_on == b.driveless_on)
      && (a.driveless == b.driveless)
      && (a.post_on == b.post_on)
      && (a.post_thres == b.post_thres)
      && (a.post_filter == b.post_filter)
      && (a.post_window == b.post_window)
      && (a.post_param_s == b.post_param_s)
      && (a.post_param_k == b.post_param_k)
      && (a.clip_on == b.clip_on)
      && (a.cliplow_on == b.cliplow_on)
      ;
}
static inline bool operator!=(const json_limiter &a, const json_limiter &b) {
      return !(a==b);
}
 
// === object limiter VU ===
static inline bool operator==(const jsonvu_limiter &a, const jsonvu_limiter &b) {
  return true
      && (a.gain == b.gain)
      && (a.lkatt == b.lkatt)
      && (a.post == b.post)
      && (a.over == b.over)
      ;
}
static inline bool operator!=(const jsonvu_limiter &a, const jsonvu_limiter &b) {
      return !(a==b);
}
 
// === object output Preset ===
static inline bool operator==(const json_output &a, const json_output &b) {
  return true
      ;
}
static inline bool operator!=(const json_output &a, const json_output &b) {
      return !(a==b);
}
 
// === object output VU ===
static inline bool operator==(const jsonvu_output &a, const jsonvu_output &b) {
  return true
      && (a.vu == b.vu)
      ;
}
static inline bool operator!=(const jsonvu_output &a, const jsonvu_output &b) {
      return !(a==b);
}
 
// === object r128 Preset ===
static inline bool operator==(const json_r128 &a, const json_r128 &b) {
  return true
      && (a.on == b.on)
      && (a.target == b.target)
      && (a.attack == b.attack)
      && (a.release == b.release)
      ;
}
static inline bool operator!=(const json_r128 &a, const json_r128 &b) {
      return !(a==b);
}
 
// === object r128 VU ===
static inline bool operator==(const jsonvu_r128 &a, const jsonvu_r128 &b) {
  return true
      && (a.vu_on == b.vu_on)
      && (a.vu_target == b.vu_target)
      && (a.bs_moment == b.bs_moment)
      && (a.bs_short == b.bs_short)
      && (a.bs_long == b.bs_long)
      && (a.bs_user == b.bs_user)
      && (a.gain == b.gain)
      && (a.bs_psr == b.bs_psr)
      && (a.bs_plr == b.bs_plr)
      && (a.bs_moment_pk == b.bs_moment_pk)
      && (a.bs_short_pk == b.bs_short_pk)
      && (a.bs_long_pk == b.bs_long_pk)
      && (a.bs_user_pk == b.bs_user_pk)
      ;
}
static inline bool operator!=(const jsonvu_r128 &a, const jsonvu_r128 &b) {
      return !(a==b);
}
 
// === object settings_gain Preset ===
static inline bool operator==(const json_settings_gain &a, const json_settings_gain &b) {
  return true
      && (a.in == b.in)
      && (a.out == b.out)
      ;
}
static inline bool operator!=(const json_settings_gain &a, const json_settings_gain &b) {
      return !(a==b);
}
 
// === object settings_gain VU ===
static inline bool operator==(const jsonvu_settings_gain &a, const jsonvu_settings_gain &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_settings_gain &a, const jsonvu_settings_gain &b) {
      return !(a==b);
}
 
// === object monodetect Preset ===
static inline bool operator==(const json_monodetect &a, const json_monodetect &b) {
  return true
      && (a.avgpan_max == b.avgpan_max)
      && (a.count == b.count)
      && (a.panmax == b.panmax)
      && (a.threshold_m == b.threshold_m)
      && (a.threshold_s == b.threshold_s)
      && (a.forcemono == b.forcemono)
      ;
}
static inline bool operator!=(const json_monodetect &a, const json_monodetect &b) {
      return !(a==b);
}
 
// === object monodetect VU ===
static inline bool operator==(const jsonvu_monodetect &a, const jsonvu_monodetect &b) {
  return true
      && (a.active == b.active)
      && (a.avgpan == b.avgpan)
      && (a.vucount == b.vucount)
      && (a.pan == b.pan)
      && (a.dev == b.dev)
      ;
}
static inline bool operator!=(const jsonvu_monodetect &a, const jsonvu_monodetect &b) {
      return !(a==b);
}
 
// === object r128_settings Preset ===
static inline bool operator==(const json_r128_settings &a, const json_r128_settings &b) {
  return true
      && (a.longterm_time == b.longterm_time)
      && (a.vutype == b.vutype)
      && (a.on == b.on)
      && (a.truepeak_protect == b.truepeak_protect)
      && (a.target == b.target)
      ;
}
static inline bool operator!=(const json_r128_settings &a, const json_r128_settings &b) {
      return !(a==b);
}
 
// === object r128_settings VU ===
static inline bool operator==(const jsonvu_r128_settings &a, const jsonvu_r128_settings &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_r128_settings &a, const jsonvu_r128_settings &b) {
      return !(a==b);
}
 
// === object settings_general Preset ===
static inline bool operator==(const json_settings_general &a, const json_settings_general &b) {
  return true
      && (a.operate == b.operate)
      && (a.history_unit == b.history_unit)
      ;
}
static inline bool operator!=(const json_settings_general &a, const json_settings_general &b) {
      return !(a==b);
}
 
// === object settings_general VU ===
static inline bool operator==(const jsonvu_settings_general &a, const jsonvu_settings_general &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_settings_general &a, const jsonvu_settings_general &b) {
      return !(a==b);
}
 
 
//  =============================
//  ========== settings =========
//  =============================
static inline bool operator==(const json_settings &a, const json_settings &b) {
  return true
      && (a.general == b.general)
      && (a.gain == b.gain)
      && (a.monodetect == b.monodetect)
      && (a.r128 == b.r128)
      ;
}
static inline bool operator!=(const json_settings &a, const json_settings &b) {
      return !(a==b);
}
 
//  =============================
//  ======== settings VU ========
//  =============================
static inline bool operator==(const jsonvu_settings &a, const jsonvu_settings &b) {
  return true
      && (a.general == b.general)
      && (a.gain == b.gain)
      && (a.monodetect == b.monodetect)
      && (a.r128 == b.r128)
      ;
}
static inline bool operator!=(const jsonvu_settings &a, const jsonvu_settings &b) {
      return !(a==b);
}
 
//  =============================
//  ========== preset ===========
//  =============================
static inline bool operator==(const json_preset &a, const json_preset &b) {
  return true
      && (a.setup == b.setup)
      && (a.in == b.in)
      && (a.agc == b.agc)
      && (a.agcwide == b.agcwide)
      && (a.tonefx == b.tonefx)
      && (a.stereofx == b.stereofx)
      && (a.bandexp == b.bandexp)
      && (a.bandprocess == b.bandprocess)
      && (a.bandlook == b.bandlook)
      && (a.bandlim == b.bandlim)
      && (a.parameq == b.parameq)
      && (a.bassclip == b.bassclip)
      && (a.limiter == b.limiter)
      && (a.out == b.out)
      && (a.r128 == b.r128)
      ;
}
static inline bool operator!=(const json_preset &a, const json_preset &b) {
      return !(a==b);
}
 
//  =============================
//  ========== preset VU ========
//  =============================
static inline bool operator==(const json_vu &a, const json_vu &b) {
  return true
      && (a.setup == b.setup)
      && (a.in == b.in)
      && (a.agc == b.agc)
      && (a.agcwide == b.agcwide)
      && (a.tonefx == b.tonefx)
      && (a.stereofx == b.stereofx)
      && (a.bandexp == b.bandexp)
      && (a.bandprocess == b.bandprocess)
      && (a.bandlook == b.bandlook)
      && (a.bandlim == b.bandlim)
      && (a.parameq == b.parameq)
      && (a.bassclip == b.bassclip)
      && (a.limiter == b.limiter)
      && (a.out == b.out)
      && (a.r128 == b.r128)
      && (a.settings == b.settings)
      ;
}
static inline bool operator!=(const json_vu &a, const json_vu &b) {
      return !(a==b);
}