add vst3

data_datadef/vst2/1129066801.datadef

@@ -1,110 +0,0 @@
-#The CS Cloud
-
-area_struct | main
-
-part | float | filter_env_a
-part | float | filter_env_d
-part | float | filter_env_r
-part | float | filter_env_s
-
-part | float | main_env_a
-part | float | main_env_d
-part | float | main_env_r
-part | float | main_env_s
-
-part | float | amorph1_depth
-part | float | amorph1_speed
-part | float | amorph1_shape
-part | float | amorph2_depth
-part | float | amorph2_speed
-part | float | amorph2_shape
-part | float | amorph3_depth
-part | float | amorph3_speed
-part | float | amorph3_shape
-
-part | float | delay_on
-part | float | delay_feed
-part | float | delay_mix
-part | float | delay_time
-
-part | float | lfo1_depth
-part | float | lfo1_speed
-part | float | lfo1_shape
-part | float | lfo2_depth
-part | float | lfo2_speed
-part | float | lfo2_shape
-part | float | lfo3_depth
-part | float | lfo3_speed
-part | float | lfo3_shape
-part | float | lfo3_depth
-part | float | lfo3_speed
-part | float | lfo3_shape
-
-part | float | amorph1_dest
-part | float | amorph2_dest
-part | float | amorph3_dest
-
-part | float | filter_cutoff
-part | float | filter_shape
-part | float | filter_res
-part | float | filter_trk
-part | float | filter_amt
-
-part | float | porta
-part | float | glide
-
-part | float | lfo1_dest
-part | float | lfo2_dest
-part | float | lfo3_dest
-part | float | lfo4_dest
-
-part | float | volume
-
-part | float | osc1_on
-part | float | osc1_on_bits
-part | float | osc1_bits
-part | float | osc1_crush
-part | float | osc1_det
-part | float | osc1_oct
-part | float | osc1_cut
-part | float | osc1_res
-part | float | osc2_cut
-part | float | osc2_res
-part | float | osc3_cut
-part | float | osc3_res
-part | float | osc1_vol
-part | float | osc2_on
-part | float | osc2_on_bits
-part | float | osc2_bits
-part | float | osc2_crush
-part | float | osc2_det
-part | float | osc2_oct
-part | float | osc2_vol
-part | float | osc3_on
-part | float | osc3_on_bits
-part | float | osc3_bits
-part | float | osc3_crush
-part | float | osc3_det
-part | float | osc3_oct
-part | float | osc3_vol
-
-part | float | osc1_morphx
-part | float | osc1_morphy
-part | float | osc2_morphx
-part | float | osc2_morphy
-part | float | osc3_morphx
-part | float | osc3_morphy
-
-part | float | reverb_damp
-part | float | reverb_mix
-part | float | reverb_on
-part | float | reverb_room
-part | float | reverb_width
-
-part | float | stereo_enhance
-part | float | voices
-
-part | string.32 | preset_name
-area_end
-
-

data_datadef/vst2/1145450801.datadef

@@ -1,104 +0,0 @@
-#The CS Drafter
-
-area_struct | main
-
-part | float | filter1_env_a
-part | float | filter1_env_d
-part | float | filter1_env_r
-part | float | filter1_env_s
-
-part | float | main_env_a
-part | float | main_env_d
-part | float | main_env_r
-part | float | main_env_s
-
-part | float | delay_on
-part | float | delay_mix
-part | float | delay_feed
-part | float | delay_time
-
-part | float | lfo1_depth
-part | float | lfo1_speed
-part | float | lfo1_shape
-
-part | float | lfo2_depth
-part | float | lfo2_speed
-part | float | lfo2_shape
-
-part | float | lfo3_depth
-part | float | lfo3_speed
-part | float | lfo3_shape
-
-part | float | lfo3_depth
-part | float | lfo3_speed
-part | float | lfo3_shape
-
-part | float | filter2_env_a
-part | float | filter2_env_d
-part | float | filter2_env_r
-part | float | filter2_env_s
-part | float | filter2_on
-
-part | float | filter1_cutoff
-part | float | filter1_shape
-part | float | filter1_res
-part | float | filter1_trk
-
-part | float | filter2_cutoff
-part | float | filter2_shape
-part | float | filter2_res
-part | float | filter2_trk
-
-part | float | filter2_amt
-part | float | filter1_amt
-
-part | float | porta
-part | float | glide
-
-part | float | lfo1_dest
-part | float | lfo2_dest
-part | float | lfo3_dest
-part | float | lfo4_dest
-
-part | float | volume
-
-part | float | osc1_vol
-part | float | osc1_cut
-
-part | list.256 / float | osc1_wave
-
-part | float | osc1_dec
-part | float | osc1_oct
-part | float | osc2_vol
-part | float | osc2_cut
-
-part | list.256 / float | osc2_wave
-
-part | float | osc2_dec
-part | float | osc2_oct
-part | float | osc3_vol
-part | float | osc3_cut
-
-part | list.256 / float | osc3_wave
-
-part | float | osc3_dec
-part | float | osc3_oct
-
-part | float | rdx_bits
-part | float | rdx_crush
-part | float | rdx_on
-
-part | float | reverb_damp
-part | float | reverb_mix
-part | float | reverb_on
-part | float | reverb_room
-part | float | reverb_width
-
-part | float | stereo_enhance
-part | float | dyamic
-part | float | voices
-
-part | string.32 | preset_name
-area_end
-
-

data_datadef/vst2/1179398449.datadef

@@ -1,99 +0,0 @@
-#The CS Feeling
-
-area_struct | main
-
-part | float | filter1_env_a
-part | float | filter1_env_d
-part | float | filter1_env_r
-part | float | filter1_env_s
-
-part | float | main_env_a
-part | float | main_env_d
-part | float | main_env_r
-part | float | main_env_s
-
-part | float | delay2_on
-part | float | delay2_feed
-part | float | delay2_mix
-part | float | delay2_time
-part | float | delay2_on
-part | float | delay2_feed
-part | float | delay2_mix
-part | float | delay2_time
-
-part | float | distortion
-
-part | float | lfo1_depth
-part | float | lfo1_speed
-part | float | lfo1_shape
-part | float | lfo2_depth
-part | float | lfo2_speed
-part | float | lfo2_shape
-
-part | float | filter2_env_a
-part | float | filter2_env_d
-part | float | filter2_env_r
-part | float | filter2_env_s
-
-part | float | doublechorus_on
-part | float | filter2_on
-
-part | float | filter1_cutoff
-part | float | filter1_shape
-part | float | filter1_res
-part | float | filter1_trk
-
-part | float | filter2_cutoff
-part | float | filter2_shape
-part | float | filter2_res
-part | float | filter2_trk
-
-part | float | filter2_amt
-part | float | filter1_amt
-
-part | float | porta
-part | float | glide
-part | float | doublechorus_1
-part | float | doublechorus_2
-part | float | lfo1_dest
-part | float | lfo2_dest
-part | float | volume
-
-part | float | osc1_vol
-part | float | osc1_c3
-part | float | osc1_c4
-part | float | osc1_c1
-part | float | osc1_c2
-part | float | osc1_sat
-part | list.128 / float | osc1_harm
-part | float | osc1_det
-part | float | osc1_oct
-
-part | float | osc2_vol
-part | float | osc2_c3
-part | float | osc2_c4
-part | float | osc2_c1
-part | float | osc2_c2
-part | float | osc2_sat
-part | list.128 / float | osc2_harm
-part | float | osc2_det
-part | float | osc2_oct
-
-part | float | osc2_vol
-part | float | osc3_c3
-part | float | osc3_c4
-part | float | osc3_c1
-part | float | osc3_c2
-part | float | osc3_sat
-part | list.128 / float | osc3_harm
-part | float | osc3_det
-part | float | osc3_oct
-
-part | float | doublechorus_3
-part | float | doublechorus_4
-part | float | voices
-
-part | string.32 | preset_name
-area_end
-
-

data_datadef/vst2/1395863857.datadef

@@ -1,120 +0,0 @@
-#The CS Serio3
-
-area_struct | main
-
-part | float | filter_env_a
-part | float | filter_env_d
-part | float | filter_env_r
-part | float | filter_env_s
-
-part | float | main_env_a
-part | float | main_env_d
-part | float | main_env_r
-part | float | main_env_s
-
-part | float | chorus_on
-part | float | chorus_depth
-part | float | chorus_mix
-part | float | chorus_predl
-part | float | chorus_rate
-
-part | float | delay_on
-part | float | delay_feed
-part | float | delay_mix
-part | float | delay_time
-
-part | float | lfo1_depth
-part | float | lfo1_speed
-part | float | lfo1_shape
-
-part | float | lfo2_depth
-part | float | lfo2_speed
-part | float | lfo2_shape
-
-part | float | filter2_cut
-part | float | filter2_res
-part | float | filter2_on
-part | float | filter1_cutoff
-part | float | ----unknown28
-part | float | filter1_type
-
-part | float | filter1_res
-part | float | filter1_trk
-part | float | filter1_env
-part | float | porta
-part | float | glide
-part | float | lfo1_dest
-part | float | lfo2_dest
-part | float | volume
-part | float | ----unknown38
-part | float | osc1_det
-part | float | osc1_dist
-
-part | float | osc1_env_a
-part | float | osc1_env_d
-part | float | osc1_env_r
-part | float | osc1_env_s
-
-part | float | osc1_oct
-part | float | osc2_det
-part | float | osc2_dist
-
-part | float | osc2_env_a
-part | float | osc2_env_d
-part | float | osc2_env_r
-part | float | osc2_env_s
-
-part | float | osc2_oct
-part | float | osc3_det
-part | float | osc3_dist
-
-part | float | osc3_env_a
-part | float | osc3_env_d
-part | float | osc3_env_r
-part | float | osc3_env_s
-
-part | float | osc3_oct
-part | float | ----unknown60
-part | float | osc1_sub_shape
-part | float | osc1_sub_lvl
-part | float | ----unknown63
-part | float | osc2_sub_shape
-part | float | osc2_sub_lvl
-part | float | ----unknown66
-part | float | osc3_sub_shape
-part | float | osc3_sub_lvl
-part | float | osc1_vol
-
-part | float | osc2_vol
-part | float | osc3_vol
-part | float | osc1_ringmod_depth
-part | float | osc1_gain
-part | float | osc1_pitch
-part | float | osc1_ringmod_speed
-part | float | osc1_wf
-part | float | ----unknown77
-part | float | osc2_ringmod_depth
-part | float | osc2_gain
-part | float | osc2_pitch
-part | float | osc2_ringmod_speed
-part | float | osc2_wf
-part | float | ----unknown83
-part | float | osc3_ringmod_depth
-part | float | osc3_gain
-part | float | osc3_pitch
-part | float | osc3_ringmod_speed
-part | float | osc3_wf
-part | float | reverb_damp
-
-part | float | reverb_mix
-part | float | reverb_on
-part | float | reverb_room
-part | float | reverb_width
-part | float | stereo_enhance
-part | float | dynamic
-part | float | voices
-
-part | string_n.32 | preset_name
-area_end
-
-

data_datadef/vst2/1936747315.datadef

@@ -1,17 +0,0 @@
-#VST Speek
-
-area_struct | main
-header | raw.4 | 73706b33
-part | byte | pitch
-part | byte | speed
-part | byte | mouth
-part | byte | throat
-part | byte | sing_mode
-part | byte | filter_on
-part | byte | phonetic_mode
-part | byte | 
-part | string_l / varint | preset_name
-part | string_l / varint | speech_txt
-area_end
-
-

data_ddef/fl_studio.ddef

@@ -0,0 +1,814 @@
+
+# area_struct|effector
+# part|int|version
+# part|float|effect
+# part|float|bypass
+# part|float|wet
+# part|float|x_param
+# part|float|y_param
+# part|float|mod_rate
+# part|float|tempo
+# part|float|x_mod
+# part|float|y_mod
+# part|float|mod_shape
+# part|float|input_level
+# part|float|output_gain
+
+area_struct|__part__fruity_delay_bank
+part|s_int|pan
+part|s_int|vol
+part|s_int|filter_cutoff
+part|s_int|filter_res
+part|s_int|filter_gain
+part|s_int|feedback_pan
+part|s_int|feedback_vol
+part|s_int|feedback_sep
+part|s_int|feedback_time
+part|s_int|feedback_ofs
+part|s_int|fbfilter_cut
+part|s_int|fbfilter_res
+part|s_int|fbfilter_gain
+part|s_int|out_pan
+part|s_int|out_vol
+part|s_int|out_next
+
+area_struct|__part__fruity_delay_bank_extra
+part|s_int|filter_type
+part|s_int|filter_mode
+part|s_int|fbfilter_type
+part|s_int|fbfilter_mode
+part|byte|filter_post
+part|byte|feedback_mode
+part|byte|
+part|byte|
+part|s_int|grain_div
+part|byte|
+part|s_int|grain_sh
+part|byte|enabled
+part|byte|feedback_leave_first_echo
+part|byte|feedback_tempo
+
+area_struct|fruity_delay_bank
+part|s_int|version
+part|s_int|dry
+part|s_int|wet
+part|s_int|in
+part|s_int|fb
+part|struct.__part__fruity_delay_bank|bank_1_v
+part|struct.__part__fruity_delay_bank|bank_2_v
+part|struct.__part__fruity_delay_bank|bank_3_v
+part|struct.__part__fruity_delay_bank|bank_4_v
+part|struct.__part__fruity_delay_bank|bank_5_v
+part|struct.__part__fruity_delay_bank|bank_6_v
+part|struct.__part__fruity_delay_bank|bank_7_v
+part|struct.__part__fruity_delay_bank|bank_8_v
+part|s_int|2x_oversampling
+part|struct.__part__fruity_delay_bank_extra|bank_1_e
+part|struct.__part__fruity_delay_bank_extra|bank_2_e
+part|struct.__part__fruity_delay_bank_extra|bank_3_e
+part|struct.__part__fruity_delay_bank_extra|bank_4_e
+part|struct.__part__fruity_delay_bank_extra|bank_5_e
+part|struct.__part__fruity_delay_bank_extra|bank_6_e
+part|struct.__part__fruity_delay_bank_extra|bank_7_e
+part|struct.__part__fruity_delay_bank_extra|bank_8_e
+
+
+
+area_struct|vintage_chorus
+part|int|version
+part|int|mode
+part|int|
+part|int|mod_speed
+part|int|mod_shape_sine
+part|int|mod_phase_lr
+part|int|delay_time1
+part|int|delay_time2
+part|int|wet
+part|int|mono_input
+part|int|invert_wet
+part|int|delay_feedback
+part|int|delay_hp
+part|int|noise_gain
+part|int|noise
+part|int|noise_gate
+part|int|mod_tempo_sync
+part|int|mod_phase_start
+
+area_struct|vintage_phaser
+part|int|version
+part|int|phaser_min
+part|int|phaser_max
+part|int|phaser_feedback
+part|int|phaser_manual
+part|int|phaser_freq
+part|int|phaser_hq
+part|int|mod_speed
+part|int|mod_tempo
+part|int|mod_shape_sine
+part|int|mod_tension
+part|int|mod_phase_start
+part|int|mod_phase_lr
+part|int|delay_on
+part|int|delay_keeppitch
+part|int|delay_mix
+part|int|delay_stereo
+part|int|delay_time
+part|int|delay_tempo
+part|int|delay_feedback
+part|int|delay_lp
+part|int|delay_hp
+part|int|levels_mix
+part|int|levels_mono
+part|int|levels_noise
+part|int|levels_noise_gate
+part|int|color_gain
+part|int|color_freq
+part|int|input_hp
+part|int|feedback_hp
+part|int|rate_freq1
+part|int|rate_freq2
+part|int|lfo_scale
+part|int|lfo_pull
+
+area_struct|fruity_multiband_compressor
+part|int|version
+part|int|gain
+part|int|limiter
+part|int|filter_type
+part|int|hi_state
+part|int|hi_freq
+part|int|hi_gain
+part|int|hi_thres
+part|int|hi_ratio
+part|int|hi_att
+part|int|hi_rel
+part|int|hi_knee
+part|int|mid_state
+part|int|mid_freq_l
+part|int|mid_freq_h
+part|int|mid_gain
+part|int|mid_thres
+part|int|mid_ratio
+part|int|mid_att
+part|int|mid_rel
+part|int|mid_knee
+part|int|low_state
+part|int|low_freq
+part|int|low_gain
+part|int|low_thres
+part|int|low_ratio
+part|int|low_att
+part|int|low_rel
+part|int|low_knee
+part|int|__unknown
+part|int|visual_speed
+
+area_struct|frequency_shifter
+part|int|version
+part|int|mix
+part|int|type
+part|int|frequency
+part|int|lr_phase
+part|int|shape_left
+part|int|shape_right
+part|int|feedback
+part|int|stereo
+part|int|freqtype
+part|int|start_phase
+part|int|mixer_track
+
+area_struct|fruit_kick
+part|int|version
+part|int|max_freq
+part|int|min_freq
+part|int|decay_freq
+part|int|decay_vol
+part|int|osc_click
+part|int|osc_dist
+
+area_struct|fruity_7_band_eq
+part|s_int|band_1
+part|s_int|band_2
+part|s_int|band_3
+part|s_int|band_4
+part|s_int|band_5
+part|s_int|band_6
+part|s_int|band_7
+
+area_struct|fruity_balance
+part|s_int|pan
+part|int|vol
+
+area_struct|fruity_bass_boost
+part|int|version
+part|int|freq
+part|int|amount
+
+area_struct|fruity_big_clock
+part|byte|version
+part|byte|beats
+part|byte|color
+
+area_struct|fruity_blood_overdrive
+part|s_int|version
+part|s_int|preband
+part|s_int|color
+part|s_int|preamp
+part|s_int|x100
+part|s_int|postfilter
+part|s_int|postgain
+part|s_int|unknown_1
+part|s_int|unknown_2
+
+area_struct|fruity_center
+part|s_int|version
+part|s_int|on
+
+area_struct|fruity_chorus
+part|s_int|version
+part|s_int|delay
+part|s_int|depth
+part|s_int|stereo
+part|s_int|lfo1_freq
+part|s_int|lfo2_freq
+part|s_int|lfo3_freq
+part|s_int|lfo1_wave
+part|s_int|lfo2_wave
+part|s_int|lfo3_wave
+part|s_int|crosstype
+part|s_int|crosscutoff
+part|s_int|wetonly
+
+area_struct|fruity_delay_2
+part|s_int|input_pan
+part|int|input_vol
+part|int|dry
+part|int|fb_vol
+part|int|time
+part|s_int|time_stereo_offset
+part|int|fb_mode
+part|int|fb_cut
+
+area_struct|fruity_delay_3
+part|int|version
+part|int|wet
+part|int|delay_type
+part|int|tempo_sync
+part|int|keep_pitch
+part|int|delay_time
+part|int|offset
+part|int|smoothing
+part|int|stereo
+part|int|mod_rate
+part|int|mod_time
+part|int|mod_cutoff
+part|int|diffusion_level
+part|int|diffusion_spread
+part|int|feedbackdist_type
+part|int|feedback_level
+part|int|unknown_1
+part|int|feedback_cutoff
+part|int|feedback_reso
+part|int|feedbackdist_level
+part|int|feedbackdist_knee
+part|int|feedbackdist_symmetry
+part|int|feedback_sample_rate
+part|int|feedback_bits
+part|int|wet
+part|int|tone
+part|int|dry
+
+area_struct|fruity_delay
+part|int|version
+part|int|input
+part|int|fb
+part|int|cutoff
+part|int|tempo
+part|int|steps
+part|int|mode
+
+area_struct|fruity_dx10
+part|int|version
+part|int|amp_att
+part|int|amp_dec
+part|int|amp_rel
+part|int|mod_course
+part|int|mod_fine
+part|int|mod_init
+part|int|mod_time
+part|int|mod_sus
+part|int|mod_rel
+part|int|mod_velsen
+part|int|vibrato
+part|int|waveform
+part|int|mod_thru
+part|int|lforate
+part|int|mod2_course
+part|int|mod2_fine
+part|int|mod2_init
+part|int|mod2_time
+part|int|mod2_sus
+part|int|mod2_rel
+part|int|mod2_velsen
+part|s_int|octave
+
+area_struct|fruity_fast_dist
+part|int|pre
+part|int|threshold
+part|int|type
+part|int|mix
+part|int|post
+
+area_struct|fruity_fast_lp
+part|int|version
+part|s_int|cutoff
+part|s_int|reso
+
+area_struct|fruity_filter
+part|int|version
+part|s_int|cutoff
+part|s_int|reso
+part|s_int|lowpass
+part|s_int|bandpass
+part|s_int|hipass
+part|s_int|x2
+part|byte|center
+
+area_struct|fruity_flanger
+part|int|version
+part|s_int|delay
+part|s_int|depth
+part|s_int|rate
+part|s_int|phase
+part|s_int|damp
+part|s_int|shape
+part|s_int|feed
+part|s_int|inv_feedback
+part|s_int|inv_wet
+part|s_int|dry
+part|s_int|wet
+part|s_int|cross
+
+area_struct|fruity_flangus
+part|int|ord
+part|int|depth
+part|int|speed
+part|int|delay
+part|int|spread
+part|s_int|cross
+part|s_int|dry
+part|s_int|wet
+
+area_struct|fruity_free_filter
+part|s_int|type
+part|s_int|freq
+part|s_int|q
+part|s_int|gain
+part|s_int|center
+
+area_struct|fruity_limiter
+part|int|
+part|int|gain
+part|int|sat
+part|int|limiter_ceil
+part|int|limiter_att
+part|int|limiter_att_curve
+part|int|limiter_rel
+part|int|limiter_rel_curve
+part|int|limiter_sus
+part|int|comp_thres
+part|int|comp_knee
+part|int|comp_ratio
+part|int|comp_att
+part|int|comp_rel
+part|int|comp_att_curve
+part|int|comp_sus
+part|int|noise_gain
+part|int|noise_thres
+part|int|noise_rel
+part|skip.18|
+part|skip.18|
+part|skip.18|
+part|skip.18|
+part|int|unknown_0
+part|byte|unknown_1
+part|byte|unknown_2
+part|byte|unknown_3
+part|byte|unknown_4
+part|byte|unknown_5
+part|byte|unknown_6
+part|byte|unknown_7
+part|byte|unknown_8
+part|byte|unknown_9
+part|byte|unknown_10
+part|byte|unknown_11
+part|byte|unknown_12
+part|byte|unknown_13
+part|byte|unknown_14
+part|byte|unknown_15
+part|byte|unknown_16
+part|byte|sidechain_number
+part|byte|unknown_18
+part|byte|unknown_19
+part|byte|unknown_20
+part|byte|unknown_21
+
+area_struct|fruity_mute_2
+part|s_int|mute
+part|s_int|channel
+part|s_int|unknown_1
+
+area_struct|fruity_panomatic
+part|s_int|pan
+part|s_int|vol
+part|s_int|lfo_shape
+part|s_int|lfo_target
+part|s_int|lfo_amount
+part|s_int|lfo_speed
+
+area_struct|fruity_parametric_eq_2
+part|int|version
+part|s_int|1_gain
+part|s_int|2_gain
+part|s_int|3_gain
+part|s_int|4_gain
+part|s_int|5_gain
+part|s_int|6_gain
+part|s_int|7_gain
+part|int|1_freq
+part|int|2_freq
+part|int|3_freq
+part|int|4_freq
+part|int|5_freq
+part|int|6_freq
+part|int|7_freq
+part|int|1_width
+part|int|2_width
+part|int|3_width
+part|int|4_width
+part|int|5_width
+part|int|6_width
+part|int|7_width
+part|int|1_type
+part|int|2_type
+part|int|3_type
+part|int|4_type
+part|int|5_type
+part|int|6_type
+part|int|7_type
+part|s_int|1_order
+part|s_int|2_order
+part|s_int|3_order
+part|s_int|4_order
+part|s_int|5_order
+part|s_int|6_order
+part|s_int|7_order
+part|s_int|main_lvl
+
+area_struct|fruity_parametric_eq
+part|s_int|1_q
+part|s_int|2_q
+part|s_int|3_q
+part|s_int|4_q
+part|s_int|5_q
+part|s_int|6_q
+part|s_int|7_q
+part|int|1_freq
+part|int|2_freq
+part|int|3_freq
+part|int|4_freq
+part|int|5_freq
+part|int|6_freq
+part|int|7_freq
+part|int|1_width
+part|int|2_width
+part|int|3_width
+part|int|4_width
+part|int|5_width
+part|int|6_width
+part|int|7_width
+part|int|1_type
+part|int|2_type
+part|int|3_type
+part|int|4_type
+part|int|5_type
+part|int|6_type
+part|int|7_type
+part|s_int|main_lvl
+
+area_struct|fruity_phase_inverter
+part|int|version
+part|int|state
+
+area_struct|fruity_phaser
+part|int|version
+part|int|sweep_freq
+part|int|depth_min
+part|int|depth_max
+part|int|freq_range
+part|int|stereo
+part|int|num_stages
+part|int|feedback
+part|int|drywet
+part|int|gain
+
+area_struct|fruity_reeverb_2
+part|int|version
+part|int|lowcut
+part|int|highcut
+part|int|predelay
+part|int|room_size
+part|int|diffusion
+part|int|decay
+part|int|hidamping
+part|int|bass
+part|int|cross
+part|int|stereo
+part|int|dry
+part|int|er
+part|int|wet
+part|int|mod_speed
+part|int|mod
+part|byte|tempo_predelay
+part|byte|mid_side
+
+area_struct|fruity_reeverb
+part|int|version
+part|int|lowcut
+part|int|highcut
+part|int|predelay
+part|int|room_size
+part|int|diffusion
+part|int|color
+part|int|decay
+part|int|hidamping
+part|int|dry
+part|int|reverb
+
+area_struct|fruity_soft_clipper
+part|int|threshold
+part|int|postgain
+
+area_struct|fruity_spectroman
+part|byte|unknown_1
+part|float|outputmode
+part|float|amp
+part|float|scale
+part|byte|windowing
+part|byte|show_peaks
+part|byte|stereo
+
+area_struct|fruity_stereo_enhancer
+part|s_int|pan
+part|s_int|vol
+part|s_int|stereo
+part|s_int|phase_offs
+part|s_int|prepost
+part|s_int|phaseinvert
+
+area_struct|fruity_stereo_shaper
+part|int|
+part|s_int|r2l
+part|s_int|l2l
+part|s_int|r2r
+part|s_int|l2r
+part|s_int|delay
+part|s_int|dephase
+part|s_int|iodiff
+part|s_int|prepost
+
+area_struct|plucked!
+part|int|decay
+part|int|color
+part|int|norm_decay
+part|int|release
+part|int|wide
+
+area_struct|simsynth
+part|double|osc1_pw
+part|double|osc1_crs
+part|double|osc1_fine
+part|double|osc1_lvl
+part|double|osc1_lfo
+part|double|osc1_env
+part|double|osc1_shape
+part|double|osc2_pw
+part|double|osc2_crs
+part|double|osc2_fine
+part|double|osc2_lvl
+part|double|osc2_lfo
+part|double|osc2_env
+part|double|osc2_shape
+part|double|osc3_pw
+part|double|osc3_crs
+part|double|osc3_fine
+part|double|osc3_lvl
+part|double|osc3_lfo
+part|double|osc3_env
+part|double|osc3_shape
+part|double|lfo_del
+part|double|lfo_rate
+part|double|unk_1
+part|double|lfo_shape
+part|double|unk_2
+part|double|svf_cut
+part|double|svf_emph
+part|double|svf_env
+part|double|svf_lfo
+part|double|svf_kb
+part|double|unk_3
+part|double|svf_high
+part|double|svf_band
+part|double|unk_4
+part|double|amp_att
+part|double|amp_dec
+part|double|amp_sus
+part|double|amp_rel
+part|double|amp_lvl
+part|double|unk_5
+part|double|svf_att
+part|double|svf_dec
+part|double|svf_sus
+part|double|svf_rel
+part|skip_n.64|
+part|skip_n.12|
+part|int|osc1_on
+part|int|osc1_o1
+part|int|osc1_o2
+part|int|osc1_warm
+part|int|osc2_on
+part|int|osc2_o1
+part|int|osc2_o2
+part|int|osc2_warm
+part|int|osc3_on
+part|int|osc3_o1
+part|int|osc3_o2
+part|int|osc3_warm
+part|int|osc3_on
+part|int|osc3_o1
+part|int|osc3_o2
+part|int|osc3_warm
+part|int|lfo_on
+part|int|lfo_retrigger
+part|int|svf_on
+part|int|unk_6
+part|int|lfo_trackamp
+part|int|unk_7
+part|int|chorus_on
+part|int|unk_8
+
+area_struct|soundgoodizer
+part|int|version
+part|s_int|mode
+part|s_int|amount
+
+area_struct|transient_processor
+part|int|version
+part|s_int|attack
+part|s_int|drive
+part|s_int|release
+part|s_int|gain
+part|s_int|attack_shape
+part|s_int|release_shape
+part|s_int|split_freq
+part|s_int|split_balance
+part|s_int|effect_on
+part|s_int|display_flags
+part|s_int|display_scroll
+
+area_struct|tuner
+part|int|version
+part|s_int|refrence
+part|s_int|reactivity
+part|s_int|bass
+part|s_int|display_mode
+
+area_struct|wasp
+part|int|version
+part|int|1_shape
+part|int|1_crs
+part|int|1_fine
+part|int|2_shape
+part|int|2_crs
+part|int|2_fine
+part|int|3_shape
+part|int|3_amt
+part|int|12_fade
+part|int|pw
+part|int|fm
+part|int|ringmod
+part|int|amp_A
+part|int|amp_S
+part|int|amp_D
+part|int|amp_R
+part|int|fil_A
+part|int|fil_S
+part|int|fil_D
+part|int|fil_R
+part|int|fil_kbtrack
+part|int|fil_qtype
+part|int|fil_cut
+part|int|fil_res
+part|int|fil_env
+part|int|lfo1_shape
+part|int|lfo1_target
+part|int|lfo1_amt
+part|int|lfo1_spd
+part|int|lfo1_sync
+part|int|lfo1_reset
+part|int|lfo2_shape
+part|int|lfo2_target
+part|int|lfo2_amt
+part|int|lfo2_spd
+part|int|lfo2_sync
+part|int|lfo2_reset
+part|int|dist_on
+part|int|dist_drv
+part|int|dist_tone
+part|int|dualvoice
+
+area_struct|wasp_xt
+part|int|version
+part|int|1_shape
+part|int|1_crs
+part|int|1_fine
+part|int|2_shape
+part|int|2_crs
+part|int|2_fine
+part|int|3_shape
+part|int|3_amt
+part|int|12_fade
+part|int|pw
+part|int|fm
+part|int|ringmod
+part|int|amp_A
+part|int|amp_S
+part|int|amp_D
+part|int|amp_R
+part|int|fil_A
+part|int|fil_S
+part|int|fil_D
+part|int|fil_R
+part|int|fil_kbtrack
+part|int|fil_qtype
+part|int|fil_cut
+part|int|fil_res
+part|int|fil_env
+part|int|lfo1_shape
+part|int|lfo1_target
+part|int|lfo1_amt
+part|int|lfo1_spd
+part|int|lfo1_sync
+part|int|lfo1_reset
+part|int|lfo2_shape
+part|int|lfo2_target
+part|int|lfo2_amt
+part|int|lfo2_spd
+part|int|lfo2_sync
+part|int|lfo2_reset
+part|int|dist_on
+part|int|dist_drv
+part|int|dist_tone
+part|int|dualvoice
+part|int|amp
+part|int|analog
+part|int|me_atk
+part|int|me_dec
+part|int|me_amt
+part|int|me_1lvl
+part|int|me_2pitch
+part|int|me_1ami
+part|int|me_pw
+part|int|vol
+part|int|lfo1_delay
+part|int|lfo2_delay
+part|int|me_filter
+part|int|wnoise
+
+area_struct|3x_osc
+part|int|version
+part|s_int|osc1_pan
+part|int|osc1_shape
+part|s_int|osc1_coarse
+part|s_int|osc1_fine
+part|s_int|osc1_ofs
+part|s_int|osc1_detune
+part|int|osc1_mixlevel
+part|s_int|osc2_pan
+part|int|osc2_shape
+part|s_int|osc2_coarse
+part|s_int|osc2_fine
+part|s_int|osc2_ofs
+part|s_int|osc2_detune
+part|int|osc2_mixlevel
+part|s_int|osc3_pan
+part|int|osc3_shape
+part|s_int|osc3_coarse
+part|s_int|osc3_fine
+part|s_int|osc3_ofs
+part|s_int|osc3_detune
+part|int|phase_rand
+part|byte|osc1_invert
+part|byte|osc2_invert
+part|byte|osc3_invert
+part|byte|osc3_am

data_ddef/plugin_vst2/1129066801.ddef

@@ -0,0 +1,92 @@
+meta|name|The CS Cloud
+
+area_struct|main
+part|float|filter_env_a
+part|float|filter_env_d
+part|float|filter_env_r
+part|float|filter_env_s
+part|float|main_env_a
+part|float|main_env_d
+part|float|main_env_r
+part|float|main_env_s
+part|float|amorph1_depth
+part|float|amorph1_speed
+part|float|amorph1_shape
+part|float|amorph2_depth
+part|float|amorph2_speed
+part|float|amorph2_shape
+part|float|amorph3_depth
+part|float|amorph3_speed
+part|float|amorph3_shape
+part|float|delay_on
+part|float|delay_feed
+part|float|delay_mix
+part|float|delay_time
+part|float|lfo1_depth
+part|float|lfo1_speed
+part|float|lfo1_shape
+part|float|lfo2_depth
+part|float|lfo2_speed
+part|float|lfo2_shape
+part|float|lfo3_depth
+part|float|lfo3_speed
+part|float|lfo3_shape
+part|float|lfo3_depth
+part|float|lfo3_speed
+part|float|lfo3_shape
+part|float|amorph1_dest
+part|float|amorph2_dest
+part|float|amorph3_dest
+part|float|filter_cutoff
+part|float|filter_shape
+part|float|filter_res
+part|float|filter_trk
+part|float|filter_amt
+part|float|porta
+part|float|glide
+part|float|lfo1_dest
+part|float|lfo2_dest
+part|float|lfo3_dest
+part|float|lfo4_dest
+part|float|volume
+part|float|osc1_on
+part|float|osc1_on_bits
+part|float|osc1_bits
+part|float|osc1_crush
+part|float|osc1_det
+part|float|osc1_oct
+part|float|osc1_cut
+part|float|osc1_res
+part|float|osc2_cut
+part|float|osc2_res
+part|float|osc3_cut
+part|float|osc3_res
+part|float|osc1_vol
+part|float|osc2_on
+part|float|osc2_on_bits
+part|float|osc2_bits
+part|float|osc2_crush
+part|float|osc2_det
+part|float|osc2_oct
+part|float|osc2_vol
+part|float|osc3_on
+part|float|osc3_on_bits
+part|float|osc3_bits
+part|float|osc3_crush
+part|float|osc3_det
+part|float|osc3_oct
+part|float|osc3_vol
+part|float|osc1_morphx
+part|float|osc1_morphy
+part|float|osc2_morphx
+part|float|osc2_morphy
+part|float|osc3_morphx
+part|float|osc3_morphy
+part|float|reverb_damp
+part|float|reverb_mix
+part|float|reverb_on
+part|float|reverb_room
+part|float|reverb_width
+part|float|stereo_enhance
+part|float|voices
+part|string.32|preset_name

data_ddef/plugin_vst2/1145450801.ddef

@@ -0,0 +1,76 @@
+meta|name|The CS Drafter
+
+area_struct|main
+part|float|filter1_env_a
+part|float|filter1_env_d
+part|float|filter1_env_r
+part|float|filter1_env_s
+part|float|main_env_a
+part|float|main_env_d
+part|float|main_env_r
+part|float|main_env_s
+part|float|delay_on
+part|float|delay_mix
+part|float|delay_feed
+part|float|delay_time
+part|float|lfo1_depth
+part|float|lfo1_speed
+part|float|lfo1_shape
+part|float|lfo2_depth
+part|float|lfo2_speed
+part|float|lfo2_shape
+part|float|lfo3_depth
+part|float|lfo3_speed
+part|float|lfo3_shape
+part|float|lfo3_depth
+part|float|lfo3_speed
+part|float|lfo3_shape
+part|float|filter2_env_a
+part|float|filter2_env_d
+part|float|filter2_env_r
+part|float|filter2_env_s
+part|float|filter2_on
+part|float|filter1_cutoff
+part|float|filter1_shape
+part|float|filter1_res
+part|float|filter1_trk
+part|float|filter2_cutoff
+part|float|filter2_shape
+part|float|filter2_res
+part|float|filter2_trk
+part|float|filter2_amt
+part|float|filter1_amt
+part|float|porta
+part|float|glide
+part|float|lfo1_dest
+part|float|lfo2_dest
+part|float|lfo3_dest
+part|float|lfo4_dest
+part|float|volume
+part|float|osc1_vol
+part|float|osc1_cut
+part|list.256/float|osc1_wave
+part|float|osc1_dec
+part|float|osc1_oct
+part|float|osc2_vol
+part|float|osc2_cut
+part|list.256/float|osc2_wave
+part|float|osc2_dec
+part|float|osc2_oct
+part|float|osc3_vol
+part|float|osc3_cut
+part|list.256/float|osc3_wave
+part|float|osc3_dec
+part|float|osc3_oct
+part|float|rdx_bits
+part|float|rdx_crush
+part|float|rdx_on
+part|float|reverb_damp
+part|float|reverb_mix
+part|float|reverb_on
+part|float|reverb_room
+part|float|reverb_width
+part|float|stereo_enhance
+part|float|dyamic
+part|float|voices
+part|string.32|preset_name

data_ddef/plugin_vst2/1179398449.ddef

@@ -0,0 +1,80 @@
+meta|name|The CS Feeling
+
+area_struct|main
+part|float|filter1_env_a
+part|float|filter1_env_d
+part|float|filter1_env_r
+part|float|filter1_env_s
+part|float|main_env_a
+part|float|main_env_d
+part|float|main_env_r
+part|float|main_env_s
+part|float|delay2_on
+part|float|delay2_feed
+part|float|delay2_mix
+part|float|delay2_time
+part|float|delay2_on
+part|float|delay2_feed
+part|float|delay2_mix
+part|float|delay2_time
+part|float|distortion
+part|float|lfo1_depth
+part|float|lfo1_speed
+part|float|lfo1_shape
+part|float|lfo2_depth
+part|float|lfo2_speed
+part|float|lfo2_shape
+part|float|filter2_env_a
+part|float|filter2_env_d
+part|float|filter2_env_r
+part|float|filter2_env_s
+part|float|doublechorus_on
+part|float|filter2_on
+part|float|filter1_cutoff
+part|float|filter1_shape
+part|float|filter1_res
+part|float|filter1_trk
+part|float|filter2_cutoff
+part|float|filter2_shape
+part|float|filter2_res
+part|float|filter2_trk
+part|float|filter2_amt
+part|float|filter1_amt
+part|float|porta
+part|float|glide
+part|float|doublechorus_1
+part|float|doublechorus_2
+part|float|lfo1_dest
+part|float|lfo2_dest
+part|float|volume
+part|float|osc1_vol
+part|float|osc1_c3
+part|float|osc1_c4
+part|float|osc1_c1
+part|float|osc1_c2
+part|float|osc1_sat
+part|list.128/float|osc1_harm
+part|float|osc1_det
+part|float|osc1_oct
+part|float|osc2_vol
+part|float|osc2_c3
+part|float|osc2_c4
+part|float|osc2_c1
+part|float|osc2_c2
+part|float|osc2_sat
+part|list.128/float|osc2_harm
+part|float|osc2_det
+part|float|osc2_oct
+part|float|osc2_vol
+part|float|osc3_c3
+part|float|osc3_c4
+part|float|osc3_c1
+part|float|osc3_c2
+part|float|osc3_sat
+part|list.128/float|osc3_harm
+part|float|osc3_det
+part|float|osc3_oct
+part|float|doublechorus_3
+part|float|doublechorus_4
+part|float|voices
+part|string.32|preset_name

data_ddef/plugin_vst2/1395863857.ddef

@@ -0,0 +1,100 @@
+meta|name|The CS Serio3
+
+area_struct|main
+part|float|filter_env_a
+part|float|filter_env_d
+part|float|filter_env_r
+part|float|filter_env_s
+part|float|main_env_a
+part|float|main_env_d
+part|float|main_env_r
+part|float|main_env_s
+part|float|chorus_on
+part|float|chorus_depth
+part|float|chorus_mix
+part|float|chorus_predl
+part|float|chorus_rate
+part|float|delay_on
+part|float|delay_feed
+part|float|delay_mix
+part|float|delay_time
+part|float|lfo1_depth
+part|float|lfo1_speed
+part|float|lfo1_shape
+part|float|lfo2_depth
+part|float|lfo2_speed
+part|float|lfo2_shape
+part|float|filter2_cut
+part|float|filter2_res
+part|float|filter2_on
+part|float|filter1_cutoff
+part|float|----unknown28
+part|float|filter1_type
+part|float|filter1_res
+part|float|filter1_trk
+part|float|filter1_env
+part|float|porta
+part|float|glide
+part|float|lfo1_dest
+part|float|lfo2_dest
+part|float|volume
+part|float|----unknown38
+part|float|osc1_det
+part|float|osc1_dist
+part|float|osc1_env_a
+part|float|osc1_env_d
+part|float|osc1_env_r
+part|float|osc1_env_s
+part|float|osc1_oct
+part|float|osc2_det
+part|float|osc2_dist
+part|float|osc2_env_a
+part|float|osc2_env_d
+part|float|osc2_env_r
+part|float|osc2_env_s
+part|float|osc2_oct
+part|float|osc3_det
+part|float|osc3_dist
+part|float|osc3_env_a
+part|float|osc3_env_d
+part|float|osc3_env_r
+part|float|osc3_env_s
+part|float|osc3_oct
+part|float|----unknown60
+part|float|osc1_sub_shape
+part|float|osc1_sub_lvl
+part|float|----unknown63
+part|float|osc2_sub_shape
+part|float|osc2_sub_lvl
+part|float|----unknown66
+part|float|osc3_sub_shape
+part|float|osc3_sub_lvl
+part|float|osc1_vol
+part|float|osc2_vol
+part|float|osc3_vol
+part|float|osc1_ringmod_depth
+part|float|osc1_gain
+part|float|osc1_pitch
+part|float|osc1_ringmod_speed
+part|float|osc1_wf
+part|float|----unknown77
+part|float|osc2_ringmod_depth
+part|float|osc2_gain
+part|float|osc2_pitch
+part|float|osc2_ringmod_speed
+part|float|osc2_wf
+part|float|----unknown83
+part|float|osc3_ringmod_depth
+part|float|osc3_gain
+part|float|osc3_pitch
+part|float|osc3_ringmod_speed
+part|float|osc3_wf
+part|float|reverb_damp
+part|float|reverb_mix
+part|float|reverb_on
+part|float|reverb_room
+part|float|reverb_width
+part|float|stereo_enhance
+part|float|dynamic
+part|float|voices
+part|string_n.32|preset_name

data_ddef/plugin_vst2/1936747315.ddef

@@ -0,0 +1,13 @@
+meta|name|VST Speek
+
+area_struct|main
+part|byte|pitch
+part|byte|speed
+part|byte|mouth
+part|byte|throat
+part|byte|sing_mode
+part|byte|filter_on
+part|byte|phonetic_mode
+part|skip|
+part|string_part/varint|preset_name
+part|string_part/varint|speech_txt

data_idvals/boscaceoil_inst.csv

@@ -0,0 +1,239 @@
+id;valsoundid
+128;
+129;
+130;
+131;
+132;
+133;
+134;
+135;
+136;
+137;
+138;
+139;
+140;
+141;
+142;
+143;bass1
+144;bass2
+145;bass3
+146;bass4
+147;bass5
+148;bass6
+149;bass7
+150;bass8
+151;bass9
+152;bass10
+153;bass11
+154;bass12
+155;bass13
+156;bass14
+157;bass15
+158;bass16
+159;bass17
+160;bass18
+161;bass19
+162;bass20
+163;bass21
+164;bass22
+165;bass23
+166;bass24
+167;bass25
+168;bass26
+169;bass27
+170;bass28
+171;bass29
+172;bass30
+173;bass31
+174;bass32
+175;bass33
+176;bass34
+177;bass35
+178;bass36
+179;bass37
+180;bass38
+181;bass39
+182;bass40
+183;bass41
+184;bass42
+185;bass43
+186;bass44
+187;bass45
+188;bass46
+189;bass47
+190;bass48
+191;bass49
+192;bass50
+193;bass51
+194;bass52
+195;bass53
+196;bass54
+197;brass1
+198;brass2
+199;brass3
+200;brass4
+201;brass5
+202;brass6
+203;brass7
+204;brass8
+205;brass9
+206;brass10
+207;brass11
+208;brass12
+209;brass13
+210;brass14
+211;brass15
+212;brass16
+213;brass17
+214;brass18
+215;brass19
+216;brass20
+217;bell1
+218;bell2
+219;bell3
+220;bell4
+221;bell5
+222;bell6
+223;bell7
+224;bell8
+225;bell9
+226;bell10
+227;bell11
+228;bell12
+229;bell13
+230;bell14
+231;bell15
+232;bell16
+233;bell17
+234;bell18
+235;guitar1
+236;guitar2
+237;guitar3
+238;guitar4
+239;guitar5
+240;guitar6
+241;guitar7
+242;guitar8
+243;guitar9
+244;guitar10
+245;guitar11
+246;guitar12
+247;guitar13
+248;guitar14
+249;guitar15
+250;guitar16
+251;guitar17
+252;guitar18
+253;lead1
+254;lead2
+255;lead3
+256;lead4
+257;lead5
+258;lead6
+259;lead7
+260;lead8
+261;lead9
+262;lead10
+263;lead11
+264;lead12
+265;lead13
+266;lead14
+267;lead15
+268;lead16
+269;lead17
+270;lead18
+271;lead19
+272;lead20
+273;lead21
+274;lead22
+275;lead23
+276;lead24
+277;lead25
+278;lead26
+279;lead27
+280;lead28
+281;lead29
+282;lead30
+283;lead31
+284;lead32
+285;lead33
+286;lead34
+287;lead35
+288;lead36
+289;lead37
+290;lead38
+291;lead39
+292;lead40
+293;lead41
+294;lead42
+295;piano1
+296;piano2
+297;piano3
+298;piano4
+299;piano5
+300;piano6
+301;piano7
+302;piano8
+303;piano9
+304;piano10
+305;piano11
+306;piano12
+307;piano13
+308;piano14
+309;piano15
+310;piano16
+311;piano17
+312;piano18
+313;piano19
+314;piano20
+315;se1
+316;se2
+317;se3
+318;special1
+319;special2
+320;special3
+321;special4
+322;special5
+323;strpad1
+324;strpad2
+325;strpad3
+326;strpad4
+327;strpad5
+328;strpad6
+329;strpad7
+330;strpad8
+331;strpad9
+332;strpad10
+333;strpad11
+334;strpad12
+335;strpad13
+336;strpad14
+337;strpad15
+338;strpad16
+339;strpad17
+340;strpad18
+341;strpad19
+342;strpad20
+343;strpad21
+344;strpad22
+345;strpad23
+346;strpad24
+347;strpad25
+348;wind1
+349;wind2
+350;wind3
+351;wind4
+352;wind5
+353;wind6
+354;wind7
+355;wind8
+356;world1
+357;world2
+358;world3
+359;world4
+360;world5
+361;world6
+362;world7
+363;
+364;
+365;

editor_datadef.py

@@ -0,0 +1,339 @@
+from enum import Enum
+from imgui_bundle import hello_imgui, icons_fontawesome, imgui, immapp
+from imgui_bundle.demos_python import demo_utils
+from typing import List
+import argparse
+import json
+from functions import data_datadef
+
+table_flags = (
+    imgui.TableFlags_.row_bg
+    | imgui.TableFlags_.borders
+    | imgui.TableFlags_.resizable
+    | imgui.TableFlags_.sizing_stretch_same
+)
+
+def widgit_list_manip(i_text, i_list, i_numname, i_vlist):
+    imgui.separator()
+    imgui.push_item_width(400)
+    c_listdata, w_listdata = imgui.list_box('##wlistm', i_numname[0], i_list if i_vlist == None else i_vlist)
+    if c_listdata: 
+        i_numname[0] = w_listdata
+        i_numname[1] = i_list[i_numname[0]]
+        i_text = i_numname[1]
+    return i_text, i_numname, c_listdata, w_listdata
+
+def widgit_txt_manip(i_text):
+    wc_txtfield, wi_txtfield = imgui.input_text('##', i_text)
+    if wc_txtfield: i_text = wi_txtfield
+    btn_add = False
+    btn_del = False
+    if i_text != '':
+        imgui.same_line()
+        btn_add = imgui.button("Add")
+        imgui.same_line()
+        btn_del = imgui.button("Del")
+    return btn_add, btn_del, i_text
+
+def widgit_txt_but(i_text, i_list, i_numname, i_vlist):
+    btn_add, btn_del, i_text = widgit_txt_manip(i_text)
+    i_text, i_numname, c_listdata, ismodded = widgit_list_manip(i_text, i_list, i_numname, i_vlist)
+    return btn_add, btn_del, i_text, i_numname, ismodded
+
+# ####################################################################################################
+# ####################################################################################################
+# --- Struct List
+# ####################################################################################################
+# ####################################################################################################
+
+g_current_struct = [0, None]
+txtbox_struct_name = ''
+
+def window___struct_list():
+    window_data = hello_imgui.DockableWindow()
+    window_data.label = "Struct List"
+    window_data.dock_space_name = "MainDockSpace"
+    window_data.gui_function = widgits___struct_list
+    return window_data
+
+def widgits___struct_list():
+    global txtbox_struct_name
+    global g_current_struct
+    structlist = [x for x in datadef.structs]
+    btn_add, btn_del, txtbox_struct_name, g_current_struct, ismodded = widgit_txt_but(txtbox_struct_name, structlist, g_current_struct, None)
+
+    if ismodded: datadef.parse(g_current_struct[1],databytes)
+
+    if btn_add and txtbox_struct_name not in datadef.structs: datadef.structs[txtbox_struct_name] = []
+    if btn_del and txtbox_struct_name in datadef.structs: del datadef.structs[txtbox_struct_name]
+
+    if btn_add or btn_del: datadef.parse(g_current_struct[1],databytes)
+
+# ####################################################################################################
+# ####################################################################################################
+# --- Struct Data
+# ####################################################################################################
+# ####################################################################################################
+
+
+def widgits___cmd_edit(input_list, parttxt):
+    for listnum in range(len(input_list)):
+        listpart = input_list[listnum]
+        listpartid = str(listnum)+'_'+parttxt
+        imgui.push_item_width(90)
+
+        if listpart[0] in ['raw_part', 'string_part', 'dstring_part', 'list_part']:
+            imgui.text('V')
+            imgui.same_line()
+
+        c_txttype, i_txttype = imgui.input_text('##'+listpartid+'_lp', listpart[0])
+        if c_txttype: 
+            listpart[0] = i_txttype
+            datadef.parse(g_current_struct[1],databytes)
+
+        if listpart[0] in ['raw', 'struct', 'string', 'dstring', 'list', 'getvar', 'skip_n']:
+            imgui.same_line()
+            c_txtnum, i_txtnum = imgui.input_text('##'+listpartid+'_lp_num', listpart[1])
+            if c_txtnum: 
+                listpart[1] = i_txtnum
+                datadef.parse(g_current_struct[1],databytes)
+
+
+    imgui.same_line()
+    btn_add = imgui.button("+##"+parttxt)
+    if btn_add: 
+        input_list.append(['byte', ''])
+        datadef.parse(g_current_struct[1],databytes)
+
+    btn_rem = False
+    if input_list:
+        imgui.same_line()
+        btn_rem = imgui.button("-##"+parttxt)
+        if btn_rem: 
+            del input_list[-1]
+            datadef.parse(g_current_struct[1],databytes)
+
+def window___struct_edit():
+    window_data = hello_imgui.DockableWindow()
+    window_data.label = "Struct Editor"
+    window_data.dock_space_name = "StructEditData"
+    window_data.gui_function = widgits___struct_edit
+    return window_data
+
+def widgits___struct_edit():
+    if g_current_struct[1] != None:
+        if g_current_struct[1] in datadef.structs:
+            imgui.same_line()
+            btn_ptadd = imgui.button("Add")
+
+            partdata = datadef.structs[g_current_struct[1]]
+
+            is_changed = False
+
+            if partdata:
+                imgui.begin_child("TableChild", hello_imgui.em_to_vec2(0, 0))
+                if imgui.begin_table("Apps", 5, table_flags):
+
+                    imgui.table_setup_column("id", 0, 0.05)
+                    imgui.table_setup_column("btns", 0, 0.05)
+                    imgui.table_setup_column("name", 0, 0.2)
+                    imgui.table_setup_column("type", 0, 0.1)
+                    imgui.table_setup_column("blocks", 0, 0.8)
+
+                    delnum = None
+
+                    for partnum in range(len(partdata)):
+                        parttxt = str(partnum)
+                        imgui.table_next_column()
+                        imgui.text(parttxt)
+                        imgui.table_next_column()
+                        btn_del = imgui.button("-##del"+parttxt)
+                        if btn_del: 
+                            is_changed = True
+                            delnum = partnum
+                        imgui.table_next_column()
+                        imgui.push_item_width(120)
+                        c_txtfield, i_txtfield = imgui.input_text('##'+parttxt+'_name', partdata[partnum][2])
+                        if c_txtfield: 
+                            is_changed = True
+                            partdata[partnum][2] = i_txtfield
+                        imgui.table_next_column()
+                        c_txttype, i_txttype = imgui.input_text('##'+parttxt+'_type', partdata[partnum][0])
+                        if c_txttype: 
+                            is_changed = True
+                            partdata[partnum][0] = i_txttype
+                        imgui.table_next_column()
+                        widgits___cmd_edit(partdata[partnum][1], parttxt)
+                        imgui.table_next_row()
+
+                    if delnum != None: del partdata[delnum]
+
+                    imgui.end_table()
+                imgui.end_child()
+
+                if is_changed: datadef.parse(g_current_struct[1],databytes)
+
+
+            if btn_ptadd: 
+                partdata.append(['part', [['byte', '']], ''])
+                datadef.parse(g_current_struct[1],databytes)
+
+
+
+
+
+
+# ####################################################################################################
+# ####################################################################################################
+# --- Output
+# ####################################################################################################
+# ####################################################################################################
+
+def window___output():
+    window_data = hello_imgui.DockableWindow()
+    window_data.label = "Output"
+    window_data.dock_space_name = "OutputData"
+    window_data.gui_function = widgits___output
+    return window_data
+
+def widgits___output():
+    if datadef.errored:
+        imgui.text(datadef.errormeg)
+    else:
+
+        imgui.text("leftover bytes")
+        hex_txt = datadef.leftoverbytes[0:64].hex() 
+        hex_sep = 2
+        hex_leftovertxt = [hex_txt[i:i+hex_sep] for i in range(0, len(hex_txt), hex_sep)]
+        if hex_leftovertxt: imgui.text(' '.join(hex_leftovertxt))
+
+        imgui.begin_child("TableChild", hello_imgui.em_to_vec2(0, 0))
+        if imgui.begin_table("Apps", 5, table_flags):
+
+            delnum = None
+
+            imgui.table_setup_column("offset", 0, 0.1)
+            imgui.table_setup_column("name", 0, 0.3)
+            imgui.table_setup_column("pname", 0, 0.3)
+            imgui.table_setup_column("type", 0, 0.4)
+            imgui.table_setup_column("value", 0, 0.8)
+
+            for debgdata in datadef.debugoutput:
+                imgui.table_next_column()
+                imgui.text(debgdata[0])
+                imgui.table_next_column()
+                imgui.text(debgdata[1])
+                imgui.table_next_column()
+                imgui.text(debgdata[2])
+                imgui.table_next_column()
+                imgui.text(debgdata[3])
+                imgui.table_next_column()
+                imgui.text(debgdata[4])
+                imgui.table_next_row()
+
+            imgui.end_table()
+        imgui.end_child()
+
+
+# ####################################################################################################
+# ####################################################################################################
+# --- Docking Data
+# ####################################################################################################
+# ####################################################################################################
+
+def create_default_docking_splits() -> List[hello_imgui.DockingSplit]:
+    split_w_cat = hello_imgui.DockingSplit()
+    split_w_cat.initial_dock = "MainDockSpace"
+    split_w_cat.new_dock = "LeftSpace"
+    split_w_cat.direction = imgui.Dir_.right
+    split_w_cat.ratio = 0.4
+
+    split_w_structedit = hello_imgui.DockingSplit()
+    split_w_structedit.initial_dock = "MainDockSpace"
+    split_w_structedit.new_dock = "StructEditData"
+    split_w_structedit.direction = imgui.Dir_.right
+    split_w_structedit.ratio = 0.7
+
+    split_w_structlist = hello_imgui.DockingSplit()
+    split_w_structlist.initial_dock = "LeftSpace"
+    split_w_structlist.new_dock = "OutputData"
+    split_w_structlist.direction = imgui.Dir_.right
+    split_w_structlist.ratio = 0.3
+
+    splits = [
+        split_w_cat, 
+        split_w_structedit, 
+        split_w_structlist
+        ]
+    return splits
+
+def create_dockable_windows() -> List[hello_imgui.DockableWindow]:
+    return [
+        window___struct_list(),
+        window___struct_edit(),
+        window___output(),
+        ]
+
+def create_default_layout() -> hello_imgui.DockingParams:
+    docking_params = hello_imgui.DockingParams()
+    docking_params.docking_splits = create_default_docking_splits()
+    docking_params.dockable_windows = create_dockable_windows()
+    return docking_params
+
+# ####################################################################################################
+# ####################################################################################################
+# --- Main
+# ####################################################################################################
+# ####################################################################################################
+
+def main():
+    global main_dataset
+    global datadef
+    global databytes
+    global g_current_struct
+    global txtbox_struct_name
+
+    aparser = argparse.ArgumentParser()
+    aparser.add_argument("-d", default=None)
+    aparser.add_argument("-f", default=None)
+
+    argsd = vars(aparser.parse_args())
+
+    datadef = data_datadef.datadef()
+
+    if argsd['d'] != None:
+        df_file = argsd['d']
+        datadef.load_file(df_file)
+    
+    if argsd['f'] != None:
+        dat_file = argsd['f']
+        databytes_str = open(dat_file, "rb")
+        databytes = databytes_str.read()
+    else:
+        databytes = b'qwertyuiop[]asdfghjkl;zxcvbnm,./'*100
+
+    g_current_struct = [0, 'main']
+    txtbox_struct_name = 'main'
+
+    hello_imgui.set_assets_folder(demo_utils.demos_assets_folder())
+    runner_params = hello_imgui.RunnerParams()
+
+    runner_params.app_window_params.restore_previous_geometry = True
+    runner_params.app_window_params.window_geometry.size = (1000, 600)
+    runner_params.app_window_params.window_title = "DawVert DataDef Editor"
+
+    runner_params.docking_params = create_default_layout()
+
+    runner_params.imgui_window_params.default_imgui_window_type = hello_imgui.DefaultImGuiWindowType.provide_full_screen_dock_space
+    runner_params.imgui_window_params.enable_viewports = True
+    runner_params.imgui_window_params.menu_app_title = "DawVert DataDef Editor"
+    runner_params.imgui_window_params.show_menu_bar = True  
+    runner_params.imgui_window_params.show_status_bar = True
+
+    hello_imgui.run(runner_params)
+
+    if argsd['f'] != None:
+        datadef.save_file(df_file)
+
+if __name__ == "__main__":
+    main()

editor_dataset.py

@@ -172,11 +172,12 @@ def widgits___object_vis_editor():
     global g_current_cat
     global g_current_object
 
-    group_isobjfound, group_data = main_dataset.object_group_get(g_current_cat[1], g_current_object[1])
-    if group_isobjfound:
-        if group_data == None: group_data = ''
-        c_pard_group, v_pard_group = imgui.input_text('Group', group_data)
-        if c_pard_group: main_dataset.object_group_set(g_current_cat[1], g_current_object[1], v_pard_group)
+    for nameval in [['group','Group'],['datadef','DataDef'],['datadef_struct','DataDef Struct']]:
+        group_isobjfound, group_data = main_dataset.object_var_get(nameval[0], g_current_cat[1], g_current_object[1])
+        if group_isobjfound:
+            if group_data == None: group_data = ''
+            c_pard_group, v_pard_group = imgui.input_text(nameval[1], group_data)
+            if c_pard_group: main_dataset.object_var_set(nameval[0], g_current_cat[1], g_current_object[1], v_pard_group)
 
 # ####################################################################################################
 # ####################################################################################################

functions/data_datadef.py

@@ -0,0 +1,362 @@
+
+from functions import data_bytes
+from io import BytesIO
+import struct
+import varint
+import json
+
+def string_fix(inputtxt):
+    return inputtxt.split(b'\x00')[0].decode().translate(dict.fromkeys(range(32)))
+
+class datadef:
+    def __init__(self, filepath):
+        self.structs = {}
+        self.cases = {}
+        self.metadata = {}
+        self.using_structs = []
+        self.errored = False
+        self.errormeg = ''
+        self.debugoutput = []
+        self.leftoverbytes = b''
+        self.bytestream = BytesIO()
+        if filepath: self.load_file(filepath)
+
+# ####################################################################################################
+# ####################################################################################################
+# --- decode
+# ####################################################################################################
+# ####################################################################################################
+
+    def parse(self, dataname, databytes):
+        self.debugoutput = []
+        self.using_structs = []
+        self.output = {}
+        self.vars = {}
+        self.errored = False
+        self.emsg_partnum = ''
+        self.emsg_structname = ''
+        self.bytestream = BytesIO(databytes)
+        try:
+            if dataname in self.structs:
+                self.output = self.decode_struct(dataname)
+                self.leftoverbytes = self.bytestream.read(64)
+        except Exception as e:
+            self.errored = True
+            self.errormeg = str(e)+' at line '+self.emsg_partnum+' on '+self.emsg_structname+':'
+
+        return self.output
+
+    def getnum(self, partdata, partnum, structname):
+        if len(partdata) > 1:
+            numpart, outpartdata = self.decode_part(partdata[1:], partnum, 'N '+structname)
+            if isinstance(numpart, int): return numpart, outpartdata
+            else: raise Exception('out is not int')
+        else: raise Exception('not enough valtypes')
+
+    def decode_part(self, partdata, partnum, structname):
+
+        self.emsg_partnum = str(partnum+1)
+        self.emsg_structname = structname
+
+        if partdata:
+            if self.bytestream.tell() < len(self.bytestream.getvalue()):
+                outval = [1, None]
+                outpartdata = partdata.copy()
+
+                if partdata[0][0] in ['raw', 'string', 'dstring', 'list', 'skip_n']: 
+                    outval[0] = 2
+                    if outval[0] == 2 and not partdata[0][1].isnumeric(): raise Exception('subvaltype is not numeric')
+                    else: subvalnum = int(partdata[0][1])
+
+                if self.errored == False:
+
+                    if partdata[0][0] == 'skip':             self.bytestream.read(1)
+                    elif partdata[0][0] == 'skip_n':         self.bytestream.read(subvalnum)
+                    elif partdata[0][0] == 'struct':         outval[1] = self.decode_struct(partdata[0][1])
+                    elif partdata[0][0] == 'getvar':
+                        if partdata[0][1] in self.vars:      outval[1] = self.vars[partdata[0][1]]
+                        else: raise Exception('var "'+partdata[0][1]+'" not found')
+
+                    elif partdata[0][0] == 'byte':           outval[1] = struct.unpack('B', self.bytestream.read(1))[0]
+                    elif partdata[0][0] == 's_byte':         outval[1] = struct.unpack('b', self.bytestream.read(1))[0]
+
+                    elif partdata[0][0] == 'short':          outval[1] = struct.unpack('H', self.bytestream.read(2))[0]
+                    elif partdata[0][0] == 'short_b':        outval[1] = struct.unpack('>H', self.bytestream.read(2))[0]
+                    elif partdata[0][0] == 's_short':        outval[1] = struct.unpack('h', self.bytestream.read(2))[0]
+                    elif partdata[0][0] == 's_short_b':      outval[1] = struct.unpack('>h', self.bytestream.read(2))[0]
+
+                    elif partdata[0][0] == 'int':            outval[1] = struct.unpack('I', self.bytestream.read(4))[0]
+                    elif partdata[0][0] == 'int_b':          outval[1] = struct.unpack('>I', self.bytestream.read(4))[0]
+                    elif partdata[0][0] == 's_int':          outval[1] = struct.unpack('i', self.bytestream.read(4))[0]
+                    elif partdata[0][0] == 's_int_b':        outval[1] = struct.unpack('>i', self.bytestream.read(4))[0]
+
+                    elif partdata[0][0] == 'float':          outval[1] = struct.unpack('f', self.bytestream.read(4))[0]
+                    elif partdata[0][0] == 'float_b':        outval[1] = struct.unpack('>f', self.bytestream.read(4))[0]
+                    elif partdata[0][0] == 'double':         outval[1] = struct.unpack('d', self.bytestream.read(8))[0]
+                    elif partdata[0][0] == 'double_b':       outval[1] = struct.unpack('>d', self.bytestream.read(8))[0]
+
+                    elif partdata[0][0] == 'varint':         outval[1] = varint.decode_stream(self.bytestream)
+                    #elif partdata[0][0] == 'varint_4':       outval[1] = varint.decode_bytes(self.bytestream.read(4))
+
+                    elif partdata[0][0] == 'raw':            outval[1] = self.bytestream.read(subvalnum)
+                    elif partdata[0][0] == 'raw_part':
+                        intval, outpartdata = self.getnum(outpartdata, partnum, structname)
+                        outval[1] = self.bytestream.read(intval)
+
+                    elif partdata[0][0] == 'string':         outval[1] = self.bytestream.read(subvalnum).split(b'\x00')[0].decode()
+                    elif partdata[0][0] == 'string_part':
+                        intval, outpartdata = self.getnum(outpartdata, partnum, structname)
+                        outval[1] = self.bytestream.read(intval).split(b'\x00')[0].decode()
+
+                    elif partdata[0][0] == 'dstring':        outval[1] = self.bytestream.read(subvalnum*2).decode()
+                    elif partdata[0][0] == 'dstring_part':
+                        intval, outpartdata = self.getnum(outpartdata, partnum, structname)
+                        outval[1] = self.bytestream.read(intval*2).decode()
+
+                    elif partdata[0][0] == 'string_t':       outval[1] = data_bytes.readstring(self.bytestream)
+
+                    elif partdata[0][0] == 'list':
+                        listdata = []
+                        for _ in range(subvalnum):
+                            pvalue, _ = self.decode_part(outpartdata[1:], partnum, 'L '+structname)
+                            listdata.append(pvalue)
+                        outpartdata = outpartdata[1:]
+                        outval[1] = listdata
+
+                    elif partdata[0][0] == 'list_part':
+                        intval, outpartdata = self.getnum(outpartdata, partnum, structname)
+                        listdata = []
+                        for _ in range(intval):
+                            pvalue, _ = self.decode_part(outpartdata[1:], partnum, 'L '+structname)
+                            listdata.append(pvalue)
+                        outpartdata = outpartdata[1:]
+                        outval[1] = listdata
+
+                    else: outval = [0, None]
+
+                    bytepos = self.bytestream.tell()
+
+                    if outval == [0, None]: 
+                        raise Exception('unknown valtype')
+                    else:
+                        self.debugoutput.append([str(bytepos), self.emsg_structname, self.emsg_partname, partdata[0][0], str(outval[1])])
+                        return outval[1], outpartdata
+            else: raise Exception('end of stream')
+        else: raise Exception('no valtypes found')
+
+
+    def decode_struct(self, structname):
+        dictval = {}
+        self.emsg_partname = ''
+        if structname not in self.using_structs: 
+            if structname in self.structs:
+                self.using_structs.append(structname)
+
+                structdata = self.structs[structname]
+                for strnum in range(len(structdata)):
+                    strpart = structdata[strnum]
+
+                    pa_type, pa_dv, pa_name = strpart
+
+                    self.emsg_partname = pa_name
+
+                    if pa_type in ['part', 'setvar']: 
+                        pvalue, outpartdata = self.decode_part(pa_dv, strnum, structname)
+                        if pa_name != '' and pvalue != None:
+                            if pa_type == 'part': dictval[pa_name] = pvalue
+                            if pa_type == 'setvar': self.vars[pa_name] = pvalue
+                    else: raise Exception('unknown type on '+str(strnum+1)+' at '+structname)
+                self.using_structs.remove(structname)
+            else: raise Exception('struct not found: '+structname)
+        else: raise Exception('recursion detected: '+structname)
+
+        return dictval
+
+# ####################################################################################################
+# ####################################################################################################
+# --- encode
+# ####################################################################################################
+# ####################################################################################################
+
+    def create(self, structname, dictdata):
+        self.debugoutput = []
+        self.using_structs = []
+        self.output = dictdata
+        self.vars = {}
+        self.errored = False
+        self.bytestream = BytesIO()
+        try:
+            if structname in self.structs: 
+                self.output = self.encode_struct(structname, dictdata)
+        except Exception as e:
+            self.errored = True
+            self.errormeg = str(e)
+
+    def encode_numdata(self, valtype, outval):
+        if valtype == 'byte': outbytes = struct.pack('B', outval)
+        elif valtype == 's_byte': outbytes = struct.pack('b', outval)
+
+        elif valtype == 'short': outbytes = struct.pack('H', outval)
+        elif valtype == 'short_b': outbytes = struct.pack('>H', outval)
+        elif valtype == 's_short': outbytes = struct.pack('h', outval)
+        elif valtype == 's_short_b': outbytes = struct.pack('>h', outval)
+
+        elif valtype == 'int': outbytes = struct.pack('I', outval)
+        elif valtype == 'int_b': outbytes = struct.pack('>I', outval)
+        elif valtype == 's_int': outbytes = struct.pack('i', outval)
+        elif valtype == 's_int_b': outbytes = struct.pack('>i', outval)
+
+        elif valtype == 'float': outbytes = struct.pack('f', outval)
+        elif valtype == 'float_b': outbytes = struct.pack('>f', outval)
+        elif valtype == 'double': outbytes = struct.pack('d', outval)
+        elif valtype == 'double_b': outbytes = struct.pack('>d', outval)
+
+        elif valtype == 'varint': outbytes = varint.encode(outval)
+
+        else: raise Exception('unsupported number-related valtype')
+
+        return outbytes
+
+    def getfallback(self, valtype, subvalnum):
+        if valtype == 'raw': return b'\x00'*subvalnum
+        elif valtype == 'raw_part': return b''
+        elif valtype == 'string': return ''
+        elif valtype == 'string_part': return ''
+        elif valtype == 'list': return []
+        elif valtype == 'struct': return {}
+        else: return 0
+
+    def getval(self, v_tag, v_name, v_type, v_value, subvalnum):
+        return v_value if v_value != None else self.getfallback(partdata[0][0], subvalnum)
+
+    def encode_part(self, partdata, outval, structname):
+        subvalnum = None
+        if partdata:
+            outpartdata = partdata.copy()
+            if partdata[0][0] in ['raw', 'string', 'dstring', 'list', 'skip_n']: 
+                if not partdata[0][1].isnumeric(): raise Exception('subvaltype is not numeric')
+                else: subvalnum = int(partdata[0][1])
+            
+            if outval == None: outval = self.getfallback(partdata[0][0], subvalnum)
+
+            if partdata[0][0] == 'skip': outbytes = b'\x00'
+            elif partdata[0][0] == 'skip_n': outbytes = b'\x00'*subvalnum
+
+            elif partdata[0][0] in ['int', 'int_b', 's_int', 's_int_b', 'byte', 's_byte', 'short', 'short_b', 's_short', 's_short_b', 'float', 'float_b', 'double', 'double_b', 'varint']: 
+                outbytes = self.encode_numdata(partdata[0][0], outval)
+            
+            elif partdata[0][0] == 'raw': 
+                if len(outval) != subvalnum: raise Exception('raw length not match')
+                outbytes = outval
+
+            elif partdata[0][0] == 'string': 
+                outbytes = data_bytes.makestring_fixedlen(outval, subvalnum)
+
+            elif partdata[0][0] == 'raw_part': 
+                datalen = self.encode_numdata(partdata[1][0], len(outval))
+                outbytes = outval
+                outpartdata = outpartdata[1:]
+
+            elif partdata[0][0] == 'string_part': 
+                stringbytes = outval.encode()
+                datalen = self.encode_numdata(partdata[1][0], len(stringbytes))
+                outbytes = stringbytes
+                outpartdata = outpartdata[1:]
+
+            elif partdata[0][0] == 'list': 
+                if len(outval) != subvalnum: raise Exception('list length not match')
+                outbytes = b''
+                outpartdata = outpartdata[1:]
+                for listnum in range(subvalnum): self.encode_part(outpartdata, outval[listnum], structname)
+
+            elif partdata[0][0] == 'list_part': 
+                outbytes = b''
+                outpartdata = outpartdata[1:]
+                self.encode_part(outpartdata, len(outval), structname)
+                outpartdata = outpartdata[1:]
+                for liste in outval: self.encode_part(outpartdata, liste, structname)
+
+            elif partdata[0][0] == 'struct': 
+                outbytes = b''
+                self.encode_struct(outpartdata[0][1], outval)
+                self.emsg_structname = outpartdata[0][1]
+
+
+
+            else: raise Exception('unsupported valtype: '+partdata[0][0])
+
+            self.bytestream.write(outbytes)
+
+            return outpartdata[1:]
+
+    def encode_struct(self, structname, dictdata):
+        self.emsg_structname = structname
+        if structname not in self.using_structs: 
+            if structname in self.structs:
+                self.using_structs.append(structname)
+                structdata = self.structs[structname]
+                for strnum in range(len(structdata)):
+                    strpart = structdata[strnum]
+                    pa_type, pa_dv, pa_name = strpart
+
+                    dictval = dictdata[pa_name] if pa_name in dictdata else None
+                    if pa_type in ['part']: 
+                        self.emsg_partnum = str(strnum+1)
+                        self.encode_part(pa_dv, dictval, structname)
+                    else: raise Exception('unsupported type on '+str(strnum+1)+' at '+structname)
+                self.using_structs.remove(structname)
+            else: raise Exception('struct not found: '+structname)
+        else: raise Exception('recursion detected: '+structname)
+
+# ####################################################################################################
+# ####################################################################################################
+# --- file
+# ####################################################################################################
+# ####################################################################################################
+
+    def load_file(self, in_datadef):
+        self.structs = {}
+        self.metadata = {}
+        self.cases = {}
+
+        try:
+            if in_datadef != None:
+                f = open(in_datadef, "r")
+                print('[datadef] Loaded '+in_datadef)
+                ddlines = [x.strip().split('#')[0].split('|') for x in f.readlines()]
+                ddlines = [[p.strip() for p in l] for l in ddlines]
+
+                current_struct = None
+                for ddline in ddlines:
+                    if ddline != ['']:
+                        if ddline[0] == 'meta':
+                            self.metadata[ddline[1]] = ddline[2]
+                        if ddline[0] == 'area_struct':
+                            current_struct = ddline[1]
+                            self.structs[ddline[1]] = []
+                        if ddline[0] == 'part':
+                            valtypes = ddline[1].split('/')
+                            valtypes = [x.split('.') for x in valtypes]
+                            valtypes = [x if len(x) > 1 else [x[0], ''] for x in valtypes]
+                            self.structs[current_struct].append([ddline[0], valtypes, ddline[2]])
+        except:
+            pass
+
+    def save_file(self, file_name):
+        linesdata = []
+
+        for key, value in self.metadata.items():
+            linesdata.append('meta|'+key+'|'+value)
+
+        for structname in self.structs:
+            linesdata.append('')
+            linesdata.append('area_struct|'+structname)
+            for structpart in self.structs[structname]:
+                subvals = structpart[1]
+                subvals = [x[0] if x[1] == '' else x[0]+'.'+x[1] for x in subvals]
+                subvals = '/'.join(subvals).replace(' ','')
+                linesdata.append(structpart[0]+'|'+subvals+'|'+structpart[2])
+
+        with open(file_name, "w") as fileout:
+            for line in linesdata:
+                fileout.write(line+'\n')

functions/data_dataset.py

@@ -4,12 +4,12 @@ from functions import data_values
 
 class dataset:
     def __init__(self, in_dataset):
-        print(in_dataset)
         if in_dataset != None:
             try:
                 f = open(in_dataset, "r")
                 self.dataset = json.load(f)
                 self.category_list = [x for x in self.dataset]
+                print('[dataset] Loaded '+in_dataset)
             except:
                 self.dataset = {}
                 self.category_list = []
@@ -86,21 +86,21 @@ class dataset:
                 objdata = self.dataset[c_name]['objects'][o_name]
                 if visual_data != None: objdata['visual'] = visual_data
 
-    def object_group_get(self, c_name, o_name):
+    def object_var_get(self, v_name, c_name, o_name):
         group_data = None
         isobjfound = False
         if c_name in self.dataset: 
             if o_name in self.dataset[c_name]['objects']:
                 objdata = self.dataset[c_name]['objects'][o_name]
                 isobjfound = True
-                if 'group' in objdata: group_data = objdata['group']
+                if v_name in objdata: group_data = objdata[v_name]
         return isobjfound, group_data
 
-    def object_group_set(self, c_name, o_name, group_data):
+    def object_var_set(self, v_name, c_name, o_name, group_data):
         if c_name in self.dataset: 
             if o_name in self.dataset[c_name]['objects']:
                 objdata = self.dataset[c_name]['objects'][o_name]
-                if group_data != None: objdata['group'] = group_data
+                if group_data != None: objdata[v_name] = group_data
 
     def object_get_name_color(self, c_name, o_name):
         visualdata = data_values.nested_dict_get_value(self.dataset, [c_name, 'objects', o_name, 'visual'])

functions/data_plugparams.py

@@ -1,10 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-def fake_tension(cvpj_plugindata):
-    a_predelay, a_attack, a_hold, a_decay, a_sustain, a_release, a_amount = cvpj_plugindata.asdr_env_get(asdrtype)
-    t_attack, t_decay, t_release = plugins.asdr_env_tension_get(asdrtype)
-    a_attack *= pow(2, min(t_attack*3.14, 0))
-    a_decay *= pow(2, min(t_decay*3.14, 0))
-    a_release *= pow(2, min(t_release*3.14, 0))
-    return a_predelay, a_attack, a_hold, a_decay, a_sustain, a_release, a_amount

functions/data_values.py

@@ -203,4 +203,11 @@ def list_usefirst(i_list):
         if p != None: 
             finalval = p
             break
-    return finalval
+    return finalval
+
+def get_all_keys(i_dict, nestedval):
+    for key, value in i_dict.items():
+        if isinstance(value, dict):
+            yield from get_all_keys(value, nestedval+[key])
+        else:
+            yield nestedval+[key], value

functions/format_midi_in.py

@@ -1,429 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later 
-
-from functions import notelist_data
-from functions import note_data
-from functions import data_values
-from functions import idvals
-from functions import plugins
-from functions import tracks
-
-idvals_midi_ctrl = idvals.parse_idvalscsv('data_idvals/midi_ctrl.csv')
-idvals_midi_inst = idvals.parse_idvalscsv('data_idvals/midi_inst.csv')
-idvals_midi_inst_drums = idvals.parse_idvalscsv('data_idvals/midi_inst_drums.csv')
-
-cvpj_l = {}
-cvpj_l_playlist = {}
-cvpj_l_timemarkers = []
-cvpj_l_fxrack = {}
-
-def addpoint(dict_val, pos_val, value):
-    if pos_val not in dict_val: dict_val[pos_val] = []
-    dict_val[pos_val].append(value)
-
-def song_start(channels, ppq):
-    global t_tracknum
-    global t_chan_auto
-    global t_chan_usedinst_all
-    global s_tempo
-    global s_ppqstep
-    global s_timemarkers
-    global t_trk_ch
-    s_ppqstep = ppq/4
-    t_tracknum = 0
-    s_tempo = {}
-    s_timemarkers = []
-    t_trk_ch = [[] for x in range(channels)]
-    t_chan_usedinst_all = [[] for x in range(channels)]
-    t_chan_auto = []
-    for _ in range(channels): t_chan_auto.append({})
-
-# -------------------------------------- TRACK --------------------------------------
-def get_trackid(t_tracknum, channelnum, cvpj_midibank, cvpj_midiinst):
-    return 't'+str(t_tracknum)+'_c'+str(channelnum)+'_b'+str(cvpj_midibank)+'_i'+str(cvpj_midiinst)
-
-def track_start(channels, startpos):
-    global t_tracknum
-    global t_trackname
-    global t_trackcolor
-    global t_startpos
-    global midi_cmds
-    global t_curpos
-
-    global cvpj_notes
-    global midichanneltype
-
-    t_curpos = 0
-    t_startpos = startpos
-    t_trackname = None
-    t_trackcolor = None
-
-    midichanneltype = []
-    for num in range(channels):
-        if num == 9: midichanneltype.append(1)
-        else: midichanneltype.append(0)
-
-    t_tracknum += 1
-    cmd_before_note = True
-    cmd_before_program = True
-
-    cvpj_notes = []
-    for _ in range(channels): cvpj_notes.append([])
-
-    midi_cmds = []
-
-def track_end(channels):
-    global hasnotes
-    global midi_cmds
-    global s_ppqstep
-    global t_chan_auto
-    global t_chan_usedinst
-    global t_trackname
-    global t_trackcolor
-    global t_tracknum
-    global t_trk_ch
-
-    t_cvpj_notelist = []
-    cvpj_inst_start = 't'+str(t_tracknum)
-
-    t_cur_inst = [[0, -1] for x in range(channels)]
-
-    t_chan_usedinst = [{} for x in range(channels)]
-    t_active_notes = [[[] for x in range(128)] for x in range(channels)]
-
-    curpos = 0
-    for midi_cmd in midi_cmds:
-
-        if midi_cmd[0] == 'break': curpos += midi_cmd[1]
-
-        if midi_cmd[0] == 'program': 
-            t_cur_inst[midi_cmd[1]][1] = midi_cmd[2]
-
-        if midi_cmd[0] == 'control': 
-            if midi_cmd[2] == 0:
-                t_cur_inst[midi_cmd[1]][0] = midi_cmd[3]
-            else:
-                if midi_cmd[2] not in t_chan_auto[midi_cmd[1]]: t_chan_auto[midi_cmd[1]][midi_cmd[2]] = {}
-                t_chan_auto[midi_cmd[1]][midi_cmd[2]][curpos] = midi_cmd[3]
-
-        if midi_cmd[0] == 'pitch': 
-            if 'pitch' not in t_chan_auto[midi_cmd[1]]: t_chan_auto[midi_cmd[1]]['pitch'] = {}
-            t_chan_auto[midi_cmd[1]]['pitch'][curpos] = midi_cmd[2]
-
-        if midi_cmd[0] in ['note', 'note_on']: 
-            curinst = t_cur_inst[midi_cmd[1]]
-            if curinst[0] not in t_chan_usedinst[midi_cmd[1]]: t_chan_usedinst[midi_cmd[1]][curinst[0]] = []
-            if curinst[1] not in t_chan_usedinst[midi_cmd[1]][curinst[0]]: t_chan_usedinst[midi_cmd[1]][curinst[0]].append(curinst[1])
-            trkname = get_trackid(t_tracknum, midi_cmd[1], curinst[0], curinst[1])
-            if trkname not in t_chan_usedinst_all[midi_cmd[1]]: t_chan_usedinst_all[midi_cmd[1]].append(trkname)
-            if midi_cmd[0] == 'note': t_active_notes[midi_cmd[1]][midi_cmd[2]].append([curpos,midi_cmd[4],midi_cmd[3],t_tracknum,curinst[0],curinst[1]])
-            if midi_cmd[0] == 'note_on': t_active_notes[midi_cmd[1]][midi_cmd[2]].append([curpos,None,midi_cmd[3],t_tracknum,curinst[0],curinst[1]])
-
-        if midi_cmd[0] == 'note_off': 
-            for note in t_active_notes[midi_cmd[1]][midi_cmd[2]]:
-                if note[1] == None:
-                    note[1] = curpos
-                    break
-
-    for channelnum in range(channels):
-        #print(channelnum)
-        notekey = -60
-        for c_active_notes in t_active_notes[channelnum]:
-            for t_actnote in c_active_notes:
-                #print(notekey, '-------------', t_actnote)
-                if t_actnote[1] != None:
-                    notedata = note_data.mx_makenote(get_trackid(t_actnote[3],channelnum,t_actnote[4],t_actnote[5]), t_actnote[0]/s_ppqstep, (t_actnote[1]-t_actnote[0])/s_ppqstep, notekey, t_actnote[2]/127, None)
-                    notedata['channel'] = channelnum+1
-                    t_cvpj_notelist.append(notedata)
-            notekey += 1
-
-    playlistrowdata = {}
-    if t_trackname != None: playlistrowdata['name'] = str(t_trackname)
-    if t_trackcolor != None: playlistrowdata['color'] = t_trackcolor
-    else: playlistrowdata['color'] = [0.3, 0.3, 0.3]
-
-    if t_cvpj_notelist != []:
-        hasnotes = True
-        cvpj_placement = {}
-        cvpj_placement['position'] = t_startpos/s_ppqstep
-        cvpj_placement['duration'] = notelist_data.getduration(t_cvpj_notelist)
-        cvpj_placement['notelist'] = notelist_data.sort(t_cvpj_notelist)
-        playlistrowdata['placements_notes'] = [cvpj_placement]
-    else:
-        hasnotes = False
-
-    cvpj_l_playlist[str(t_tracknum)] = playlistrowdata
-
-def make_custominst(channelnum, cvpj_midibank, cvpj_midiinst, **kwargs):
-    cvpj_instid = get_trackid(t_tracknum, channelnum, cvpj_midibank, cvpj_midiinst)
-    cvpj_name = data_values.get_value(kwargs, 'name', '')
-    cvpj_color = data_values.get_value(kwargs, 'color', None)
-    tracks.m_inst_create(cvpj_l, cvpj_instid, name=cvpj_name, color=cvpj_color)
-    if 'pluginid' in kwargs:
-        tracks.m_inst_pluginid(cvpj_l, cvpj_instid, kwargs['pluginid'])
-
-def make_inst(channelnum, cvpj_midibank, cvpj_midiinst):
-    cvpj_instid = get_trackid(t_tracknum, channelnum, cvpj_midibank, cvpj_midiinst)
-    if cvpj_instid not in t_trk_ch[channelnum]:
-        t_trk_ch[channelnum].append(cvpj_instid)
-
-    cvpj_color = [0,0,0]
-    cvpj_name = ''
-    cvpj_usemasterpitch = True
-
-    pluginid = plugins.get_id()
-
-    if cvpj_midiinst == -1:
-        if midichanneltype[channelnum] != 0: 
-            plugins.add_plug_gm_midi(cvpj_l, pluginid, 128, cvpj_midiinst)
-            cvpj_usemasterpitch = False
-            cvpj_name = 'Drums'
-            cvpj_color = [0.81, 0.80, 0.82]
-    else:
-        if midichanneltype[channelnum] == 0: 
-            plugins.add_plug_gm_midi(cvpj_l, pluginid, cvpj_midibank, cvpj_midiinst)
-            cvpj_usemasterpitch = True
-            cvpj_name = idvals.get_idval(idvals_midi_inst, str(cvpj_midiinst), 'name') + ' [Ch' + str(channelnum+1) + ']'
-            miditrkcolor = idvals.get_idval(idvals_midi_inst, str(cvpj_midiinst), 'color')
-            if miditrkcolor != None: cvpj_color = miditrkcolor
-        else: 
-            plugins.add_plug_gm_midi(cvpj_l, pluginid, 128, cvpj_midiinst)
-            cvpj_usemasterpitch = False
-            cvpj_name = 'Drums'
-            cvpj_color = [0.81, 0.80, 0.82]
-
-    tracks.m_inst_create(cvpj_l, cvpj_instid, name=cvpj_name, color=cvpj_color)
-    tracks.r_add_param(cvpj_l, cvpj_instid, 'usemasterpitch', cvpj_usemasterpitch, 'bool')
-
-    tracks.m_inst_pluginid(cvpj_l, cvpj_instid, pluginid)
-    tracks.m_inst_add_dataval(cvpj_l, cvpj_instid, None, 'fxrack_channel', channelnum+1)
-
-def getusedinsts(channels):
-    global t_chan_usedinst
-
-    usedinst_output = []
-
-    #print(t_chan_usedinst)
-
-    for channelnum in range(channels):
-        for s_chan_usedbank in t_chan_usedinst[channelnum]:
-            for s_chan_usedinst in t_chan_usedinst[channelnum][s_chan_usedbank]:
-                usedinst_output.append([channelnum, s_chan_usedbank, s_chan_usedinst])
-
-    return usedinst_output
-
-# -------------------------------------- FUNCTIONS --------------------------------------
-
-def get_hasnotes(): 
-    global hasnotes
-    return hasnotes
-
-# -------------------------------------- MIDI COMMANDS --------------------------------------
-
-def resttime(addtime):
-    global t_curpos
-    global midi_cmds
-    if addtime != 0:
-        midi_cmds.append(['break', addtime])
-    t_curpos += addtime
-
-def note_on(key, channel, vel):
-    global t_curpos
-    global midi_cmds
-    midi_cmds.append(['note_on', channel, key, vel])
-    #print(str(t_curpos).ljust(8), 'NOTE ON    ', str(channel).ljust(3), str(key).ljust(4), str(vel).ljust(3))
-
-def note_off(key, channel):
-    global t_curpos
-    global midi_cmds
-    midi_cmds.append(['note_off', channel, key])
-    #print(str(t_curpos).ljust(8), 'NOTE OFF   ', str(channel).ljust(3), str(key).ljust(7))
-
-def note(key, dur, channel, vel):
-    global t_curpos
-    global midi_cmds
-    midi_cmds.append(['note', channel, key, vel, t_curpos+dur])
-    #print(str(t_curpos).ljust(8), 'NOTE       ', str(channel).ljust(3), str(key).ljust(4), str(vel).ljust(3), str(dur).ljust(3))
-
-def pitchwheel(channel, pitch): 
-    global t_curpos
-    global midi_cmds
-    midi_cmds.append(['pitch', channel, pitch])
-    #print(str(t_curpos).ljust(8), 'PITCH      ', str(channel).ljust(3), str(pitch).ljust(4))
-
-def program_change(channel, program): 
-    global t_curpos
-    global midi_cmds
-    midi_cmds.append(['program', channel, program])
-    #print(str(t_curpos).ljust(8), 'PROGRAM    ', str(channel).ljust(3), str(program).ljust(4))
-
-def control_change(channel, control, value): 
-    global t_curpos
-    global midi_cmds
-    midi_cmds.append(['control', channel, control, value])
-    #print(str(t_curpos).ljust(8), 'CONTROL    ', str(channel).ljust(3), str(control).ljust(4), str(value).ljust(3))
-
-def tempo(time, tempo): 
-    global s_tempo
-    s_tempo[time] = tempo
-
-def track_name(name): 
-    global t_trackname
-    t_trackname = name
-
-def track_color(name): 
-    global t_trackcolor
-    t_trackcolor = name
-
-def marker(time, name):
-    global s_timemarkers
-    global s_ppqstep
-    s_timemarkers.append({'position':time/s_ppqstep, 'name': name})
-
-def time_signature(time, numerator, denominator):
-    global s_timemarkers
-    global s_ppq
-    s_timemarkers.append({'position':time/s_ppqstep, 'name': str(numerator)+'/'+str(denominator), 'type': 'timesig', 'numerator': numerator, 'denominator': denominator})
-
-# -------------------------------------- COMMANDS --------------------------------------
-
-
-
-def midiauto2cvpjauto(points, divi, add):
-    auto_output = []
-    for point in points:
-        auto_output.append([point/s_ppqstep, (points[point]/divi)+add])
-    return auto_output
-
-def add_auto_to_song(twopoints, autoname, channum, s_chan_trackids):
-    if len(s_chan_trackids) == 1: tracks.a_auto_nopl_twopoints(['track', s_chan_trackids[0], autoname], 'bpm', twopoints, 1, 'instant')
-    elif len(s_chan_trackids) > 1: tracks.a_auto_nopl_twopoints(['fxmixer', str(channum+1), autoname], 'bpm', twopoints, 1, 'instant')
-
-def add_auto_to_song_no_mixer(twopoints, autoname, channum, s_chan_trackids):
-    if len(s_chan_trackids) == 1: tracks.a_auto_nopl_twopoints(['track', s_chan_trackids[0], autoname], 'bpm', twopoints, 1, 'instant')
-    if len(s_chan_trackids) > 1:
-        for s_chan_trackid in s_chan_trackids:
-            tracks.a_auto_nopl_twopoints(['track', s_chan_trackid, autoname], 'bpm', twopoints, 1, 'instant')
-
-def add_auto_to_slot_gmfx(twopoints, autoname, slotname, issend):
-    if issend == False:
-        tracks.a_auto_nopl_twopoints(['slot', slotname, autoname], 'bpm', twopoints, 1, 'instant')
-    else:
-        tracks.a_auto_nopl_twopoints(['send', slotname, autoname], 'bpm', twopoints, 1, 'instant')
-
-def do_slot_wet(schannum, slotendname, fxrack_chan, issend):
-    wetval = 0
-    if len(schannum) == 1 and 0 in schannum: wetval = schannum[0]/127
-    else: 
-        if issend == False:
-            add_auto_to_slot_gmfx(midiauto2cvpjauto(schannum,127,0), 'wet', fxrack_chan+slotendname, issend)
-        else:
-            add_auto_to_slot_gmfx(midiauto2cvpjauto(schannum,127,0), 'amount', fxrack_chan+slotendname, issend)
-    return wetval
-
-def song_end(channels):
-    global midi_cmds
-    global s_ppqstep
-    global t_trk_ch
-    global t_chan_auto
-
-    songduration = 0
-
-    cvpj_l['bpm'] = 140
-    if 0 in s_tempo:
-        cvpj_l['bpm'] = s_tempo[0]
-        del s_tempo[0]
-
-    for s_tempo_point in s_tempo:
-        tracks.a_auto_nopl_addpoint(['main', 'bpm'], 'bpm', s_tempo_point/s_ppqstep, s_tempo[s_tempo_point], 'instant')
-
-    cvpj_l_automation = {}
-    cvpj_l_automation['main'] = {}
-
-    tracks.fxrack_add(cvpj_l, 0, "Master", [0.3, 0.3, 0.3], 1.0, None)
-
-    fx_used = False
-
-    for midi_channum in range(channels):
-        fxrack_chan = str(midi_channum+1)
-        tracks.fxrack_add(cvpj_l, fxrack_chan, "Channel "+fxrack_chan, [0.3, 0.3, 0.3], 1.0, None)
-
-        s_chan_trackids = t_chan_usedinst_all[midi_channum]
-
-        s_chan_auto = t_chan_auto[midi_channum]
-
-        tracks.fxrack_addsend(cvpj_l, fxrack_chan, 0, 1, None)
-
-        for s_chan_auto_num in s_chan_auto:
-            schannum = s_chan_auto[s_chan_auto_num]
-
-            if s_chan_auto_num == 1: 
-                if len(schannum) == 1 and 0 in schannum: tracks.r_add_param(cvpj_l, schannum[0], 'modulation', schannum[0]/127, 'Float')
-                else: add_auto_to_song_no_mixer(midiauto2cvpjauto(schannum,127,0), 'modulation', midi_channum, s_chan_trackids)
-
-            elif s_chan_auto_num == 7: 
-                if len(schannum) == 1 and 0 in schannum: tracks.fxrack_param(cvpj_l, fxrack_chan, 'vol', schannum[0]/127, 'Float')
-                else: add_auto_to_song(midiauto2cvpjauto(schannum,127,0), 'vol', midi_channum, s_chan_trackids)
-
-            elif s_chan_auto_num == 10: 
-                if len(schannum) == 1 and 0 in schannum: tracks.r_add_param(cvpj_l, schannum[0], 'pan', (schannum[0]/64)-1, 'Float')
-                else: add_auto_to_song_no_mixer(midiauto2cvpjauto(schannum,64,-1), 'pan', midi_channum, s_chan_trackids)
-
-            elif s_chan_auto_num == 11: 
-                if len(schannum) == 1 and 0 in schannum: tracks.r_add_param(cvpj_l, schannum[0], 'expression', schannum[0]/127, 'Float')
-                else: add_auto_to_song_no_mixer(midiauto2cvpjauto(schannum,127,0), 'expression', midi_channum, s_chan_trackids)
-
-            elif s_chan_auto_num == 91: 
-                wetval = do_slot_wet(schannum, '_reverb', fxrack_chan, True)
-                fx_used = True
-
-            elif s_chan_auto_num == 92: 
-                wetval = do_slot_wet(schannum, '_tremelo', fxrack_chan, False)
-                fx_used = True
-
-            elif s_chan_auto_num == 93: 
-                wetval = do_slot_wet(schannum, '_chorus', fxrack_chan, True)
-                fx_used = True
-
-            elif s_chan_auto_num == 94: 
-                if len(schannum) == 1 and 0 in schannum: tracks.r_add_param(cvpj_l, schannum[0], 'detuning', schannum[0]/127, 'Float')
-                else: add_auto_to_song_no_mixer(midiauto2cvpjauto(schannum,127,0), 'detuning', midi_channum, s_chan_trackids)
-
-            elif s_chan_auto_num == 95: 
-                wetval = do_slot_wet(schannum, '_phaser', fxrack_chan, False)
-                fx_used = True
-
-            elif s_chan_auto_num == 'pitch':
-                add_auto_to_song_no_mixer(midiauto2cvpjauto(s_chan_auto['pitch'],12,0), 'pitch', midi_channum, s_chan_trackids)
-
-            #else:
-            #    midictname = idvals.get_idval(idvals_midi_ctrl, str(s_chan_auto_num), 'name')
-            #    print('unknown controller', s_chan_auto_num, midictname)
-
-    if fx_used == True:
-        tracks.fxrack_add(cvpj_l, channels+1, "[S] Reverb", [0.4, 0.4, 0.4], 1.0, None)
-        tracks.fxrack_add(cvpj_l, channels+2, "[S] Chorus", [0.4, 0.4, 0.4], 1.0, None)
-        tracks.fxrack_add(cvpj_l, channels+3, "[S] Tremelo", [0.4, 0.4, 0.4], 1.0, None)
-        tracks.fxrack_add(cvpj_l, channels+4, "[S] Phaser", [0.4, 0.4, 0.4], 1.0, None)
-
-        plugins.add_plug(cvpj_l, 'plugin-reverb', 'simple', 'reverb-send')
-        plugins.add_plug_fxvisual(cvpj_l, 'plugin-reverb', 'Reverb', None)
-        tracks.insert_fxslot(cvpj_l, ['fxrack', channels+1], 'audio', 'plugin-reverb')
-
-        plugins.add_plug(cvpj_l, 'plugin-chorus', 'simple', 'chorus-send')
-        plugins.add_plug_fxvisual(cvpj_l, 'plugin-chorus', 'Chorus', None)
-        tracks.insert_fxslot(cvpj_l, ['fxrack', channels+2], 'audio', 'plugin-chorus')
-
-        plugins.add_plug(cvpj_l, 'plugin-tremelo', 'simple', 'tremelo-send')
-        plugins.add_plug_fxvisual(cvpj_l, 'plugin-tremelo', 'Tremelo', None)
-        tracks.insert_fxslot(cvpj_l, ['fxrack', channels+3], 'audio', 'plugin-tremelo')
-
-        plugins.add_plug(cvpj_l, 'plugin-phaser', 'simple', 'phaser-send')
-        plugins.add_plug_fxvisual(cvpj_l, 'plugin-phaser', 'Phaser', None)
-        tracks.insert_fxslot(cvpj_l, ['fxrack', channels+4], 'audio', 'plugin-phaser')
-
-    tracks.a_auto_nopl_to_cvpj(cvpj_l)
-    cvpj_l['timemarkers'] = s_timemarkers
-    cvpj_l['playlist'] = cvpj_l_playlist
-    return cvpj_l
-    

functions/plug_conv.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from plugin_plugconv import base as base_plugconv
+from plugin_plugconv_extern import base as base_plugconv_extern
 
 import json
 import os
@@ -12,17 +13,12 @@ from functions import data_values
 from functions import plugin_vst2
 from functions import plugins
 
-from functions_plugparams import data_vc2xml
-from functions_plugparams import params_various_fx
-from functions_plugparams import params_vital
-
-
 ______debugtxt______ = False
 
-
 pl_pc_in = []
 pl_pc_in_always = []
 pl_pc_out = []
+pl_pc_ext = []
 
 def getvisualname(plugidinput):
 	if plugidinput[1] == None: return plugidinput[0]+':*'
@@ -32,22 +28,36 @@ def load_plugins():
 	global pl_pc_in
 	global pl_pc_in_always
 	global pl_pc_out
+	global pl_pc_ext
+
 	pluglist_plugconv = {}
 
 	dv_pluginclasses = base_plugconv
+	dv_pluginclasses_ext = base_plugconv_extern
 
 	for plugconvplugin in dv_pluginclasses.plugins:
-		plco_class_list = plugconvplugin()
+		plco_class_data = plugconvplugin()
 		try:
-			plugtype = plco_class_list.is_dawvert_plugin()
+			plugtype = plco_class_data.is_dawvert_plugin()
 			if plugtype == 'plugconv': 
-				pcp_i_data, pcp_o_data, pcp_isoutput, pcp_i_always = plco_class_list.getplugconvinfo()
+				pcp_i_data, pcp_o_data, pcp_isoutput, pcp_i_always = plco_class_data.getplugconvinfo()
 				if not pcp_isoutput: 
-					if pcp_i_always: pl_pc_in_always.append([plco_class_list, pcp_i_data, pcp_o_data])
-					else: pl_pc_in.append([plco_class_list, pcp_i_data, pcp_o_data])
-				else: pl_pc_out.append([plco_class_list, pcp_i_data, pcp_o_data])
+					if pcp_i_always: pl_pc_in_always.append([plco_class_data, pcp_i_data, pcp_o_data])
+					else: pl_pc_in.append([plco_class_data, pcp_i_data, pcp_o_data])
+				else: pl_pc_out.append([plco_class_data, pcp_i_data, pcp_o_data])
 		except: pass
 
+
+	for plugconvplugin in dv_pluginclasses_ext.plugins:
+		plco_class_data = plugconvplugin()
+		try:
+			plugtype = plco_class_data.is_dawvert_plugin()
+			if plugtype == 'plugconv_ext': 
+				plugtype, supportedplugs, nativedaw = plco_class_data.getplugconvinfo()
+				pl_pc_ext.append([plco_class_data, plugtype, supportedplugs, nativedaw])
+		except: pass
+
+
 	for vispluginlistdata in [[pl_pc_in_always, 'A-Input'], [pl_pc_in, 'Input'], [pl_pc_out, 'Output']]:
 		print('[plug_conv] Plugins ('+vispluginlistdata[1]+'): ')
 		for pl_pc_in_p in vispluginlistdata[0]:
@@ -57,6 +67,12 @@ def load_plugins():
 		print('')
 
 
+	print('[plug_conv] Plugins (External): ')
+	for pl_pc_ext_p in pl_pc_ext:
+		visualplugname = getvisualname(pl_pc_ext_p[1])
+		print('    ['+visualplugname+' > '+','.join(pl_pc_ext_p[2])+'] ')
+	print('')
+
 
 
 # -------------------- convproj --------------------
@@ -106,11 +122,12 @@ def convertpluginconvproj(cvpj_l, pluginid, pci_in, cvpj_plugindata, extra_json)
 	return is_converted
 
 def convproj(cvpjdata, platform_id, in_type, out_type, in_daw, out_daw, 
-	out_supportedplugins, out_getsupportedplugformats, extra_json):
+	out_supportedplugins, out_supportedplugformats, extra_json):
 
 	global pl_pc_in
 	global pl_pc_in_always
 	global pl_pc_out
+	global pl_pc_ext
 
 	out_supportedplugins = commalist2plugtypes(out_supportedplugins)
 
@@ -138,14 +155,13 @@ def convproj(cvpjdata, platform_id, in_type, out_type, in_daw, out_daw,
 				cvpj_plugindata = plugindataclasses[pluginid]
 				plugintype_plug = cvpj_plugindata.type_get()
 
-				if plugintype_plug[0] not in out_getsupportedplugformats:
+				if plugintype_plug[0] not in out_supportedplugins:
 
 					if ______debugtxt______: print('-------')
 	
 					if ______debugtxt______: print('- input always')
 					is_converted = convertpluginconvproj(cvpj_l, pluginid, pl_pc_in_always, cvpj_plugindata, extra_json)
 
-
 					if ______debugtxt______: print('- input')
 					is_converted = convertpluginconvproj(cvpj_l, pluginid, pl_pc_in, cvpj_plugindata, extra_json)
 
@@ -153,13 +169,16 @@ def convproj(cvpjdata, platform_id, in_type, out_type, in_daw, out_daw,
 					is_converted = convertpluginconvproj(cvpj_l, pluginid, sep_pl_pc_out__native, cvpj_plugindata, extra_json)
 
 					if is_converted != True:
-						is_plugin_unsupported = cvpj_plugindata.type_get() not in out_supportedplugins
-					#	if ______debugtxt______: print('---pluugin not supported:', is_plugin_unsupported)
-
-						if is_plugin_unsupported:
-							for out_getsupportedplugformat in out_getsupportedplugformats:
-								if out_getsupportedplugformat in sep_pl_pc_out__plugins:
-									is_converted = convertpluginconvproj(cvpj_l, pluginid, sep_pl_pc_out__plugins[out_getsupportedplugformat], cvpj_plugindata, extra_json)
+						plug_type = cvpj_plugindata.type_get()
+						if not (True in [plugtype_match(plugintype_plug, x) for x in out_supportedplugins]):
+							for p_pl_pc_ext in pl_pc_ext:
+								ismatched = plugtype_match(plugintype_plug, p_pl_pc_ext[1])
+								if ismatched and p_pl_pc_ext[3] != out_daw:
+									for plugformat in out_supportedplugformats:
+										is_converted = p_pl_pc_ext[0].convert(cvpj_l, pluginid, cvpj_plugindata, extra_json, plugformat)
+										if is_converted: break
+								if is_converted: break
+						#exit()
 
 					cvpj_plugindata.to_cvpj(cvpj_l, pluginid)
 

functions/plugin_vst2.py

@@ -43,41 +43,62 @@ def getplatformtxt(in_platform):
 def find_locpath(out_paths):
 	vst_cpuarch = None
 	vst_path = None
-
-	if out_paths[0] != None and out_paths[1] == None and 32 in cpu_arch_list: 
-		vst_cpuarch = 32
-		vst_path = out_paths[0]
-	if out_paths[0] == None and out_paths[1] != None and 64 in cpu_arch_list: 
-		vst_cpuarch = 64
-		vst_path = out_paths[1]
-	if out_paths[0] != None and out_paths[1] != None and 64 in cpu_arch_list: 
-		vst_cpuarch = 64
-		vst_path = out_paths[1]
-
+	if out_paths[0] != None and out_paths[1] == None and 32 in cpu_arch_list: vst_cpuarch, vst_path = 32, out_paths[0]
+	if out_paths[0] == None and out_paths[1] != None and 64 in cpu_arch_list: vst_cpuarch, vst_path = 64, out_paths[1]
+	if out_paths[0] != None and out_paths[1] != None and 64 in cpu_arch_list: vst_cpuarch, vst_path = 64, out_paths[1]
 	return vst_cpuarch, vst_path
 
-def find_path(in_data, platformtype, bycat):
+def db_search(in_data, platformtype, bycat):
 	vst_cpuarch = None
 	vst_path = None
 	vst_name = None
+	vst_id = None
+	vst_version = None
+	out_paths = [None, None]
 
 	if db_exists:
 		if bycat == 'name':
-			vst_name = in_data
 			if platformtype == 'win': out_paths = db_plugins.execute("SELECT path_32bit_win, path_64bit_win FROM vst2 WHERE name = ?", (in_data,)).fetchone()
 			else: out_paths = db_plugins.execute("SELECT path_32bit_unix, path_64bit_unix FROM vst2 WHERE name = ?", (in_data,)).fetchone()
+			vst_name = in_data
+			vst_id = db_plugins.execute("SELECT id FROM vst2 WHERE name = ?", (in_data,)).fetchone()[0]
+
 		if bycat == 'id':
-			if platformtype == 'win':  out_paths = db_plugins.execute("SELECT path_32bit_win, path_64bit_win FROM vst2 WHERE id = ?", (in_data,)).fetchone()
+			if platformtype == 'win': out_paths = db_plugins.execute("SELECT path_32bit_win, path_64bit_win FROM vst2 WHERE id = ?", (in_data,)).fetchone()
 			else: out_paths = db_plugins.execute("SELECT path_32bit_unix, path_64bit_unix FROM vst2 WHERE id = ?", (in_data,)).fetchone()
 			vst_name = db_plugins.execute("SELECT name FROM vst2 WHERE id = ?", (in_data,)).fetchone()[0]
-	else:
-		out_paths = [None, None]
+			vst_id = in_data
+
+		if bycat == 'path':
+			if platformtype == 'win': 
+				vst_path = in_data.replace('/', '\\')
+				vstname_32 = db_plugins.execute("SELECT name FROM vst2 WHERE path_32bit_win = ?", (vst_path,)).fetchone()
+				vstname_64 = db_plugins.execute("SELECT name FROM vst2 WHERE path_64bit_win = ?", (vst_path,)).fetchone()
+				vstpath_32 = db_plugins.execute("SELECT name, id, path_32bit_win, path_64bit_win FROM vst2 WHERE path_32bit_win = ?", (vst_path,)).fetchone()
+				vstpath_64 = db_plugins.execute("SELECT name, id, path_32bit_win, path_64bit_win FROM vst2 WHERE path_64bit_win = ?", (vst_path,)).fetchone()
+			else: 
+				vstname_32 = db_plugins.execute("SELECT name FROM vst2 WHERE path_32bit_unix = ?", (vst_path,)).fetchone()
+				vstname_64 = db_plugins.execute("SELECT name FROM vst2 WHERE path_64bit_unix = ?", (vst_path,)).fetchone()
+				vstpath_32 = db_plugins.execute("SELECT name, id, path_32bit_unix, path_64bit_unix FROM vst2 WHERE path_32bit_unix = ?", (vst_path,)).fetchone()
+				vstpath_64 = db_plugins.execute("SELECT name, id, path_32bit_unix, path_64bit_unix FROM vst2 WHERE path_64bit_unix = ?", (vst_path,)).fetchone()
+
+			if vstname_32 != None: vst_cpuarch = 32
+			if vstname_64 != None: vst_cpuarch = 64
+
+			vst_paths = data_values.list_usefirst([vstpath_32, vstpath_64])
+			if vst_paths != None: 
+				vst_name = vst_paths[0]
+				vst_id = vst_paths[1]
+				out_paths = [vst_paths[2], vst_paths[3]]
+
+		if vst_id:
+			vst_version_db = db_plugins.execute("SELECT version FROM vst2 WHERE id = ?", (str(vst_id),)).fetchone()
+			if vst_version_db: vst_version = vst_version_db[0]
 
-	#print(bycat, vst_cpuarch, out_paths, vst_name)
 	if out_paths == None: out_paths = [None, None]
 	vst_cpuarch, vst_path = find_locpath(out_paths)
 
-	return vst_cpuarch, vst_path, vst_name
+	return vst_cpuarch, vst_path, vst_name, vst_id, vst_version
 
 def check_exists(in_name):
 	if db_exists:
@@ -89,7 +110,7 @@ def check_exists(in_name):
 def replace_data(cvpj_plugindata, bycat, platform, in_name, datatype, data, numparams):
 	global cpu_arch_list
 	platformtxt = getplatformtxt(platform)
-	vst_cpuarch, vst_path, vst_name = find_path(in_name, platformtxt, bycat)
+	vst_cpuarch, vst_path, vst_name, vst_id, vst_version = db_search(in_name, platformtxt, bycat)
 
 	if vst_path != None:
 		plugintype = cvpj_plugindata.type_get()
@@ -104,27 +125,18 @@ def replace_data(cvpj_plugindata, bycat, platform, in_name, datatype, data, nump
 		cvpj_plugindata.dataval_add('name', vst_name)
 		cvpj_plugindata.dataval_add('path', vst_path)
 		cvpj_plugindata.dataval_add('cpu_arch', vst_cpuarch)
+		cvpj_plugindata.dataval_add('fourid', int(vst_id))
+		cvpj_plugindata.dataval_add('version', vst_version)
 
-		if db_exists:
-			if bycat == 'name':
-				fouridval = db_plugins.execute("SELECT id FROM vst2 WHERE name = ?", (in_name,)).fetchone()
-				versionval = db_plugins.execute("SELECT version FROM vst2 WHERE name = ?", (in_name,)).fetchone()
-			if bycat == 'id':
-				fouridval = in_name
-				versionval = db_plugins.execute("SELECT version FROM vst2 WHERE name = ?", (in_name,)).fetchone()
-
-		if fouridval != None and fouridval != (None,): 
-			if bycat == 'name': cvpj_plugindata.dataval_add('fourid', int(fouridval[0]))
-			if bycat == 'id': cvpj_plugindata.dataval_add('fourid', in_name)
-
-		if versionval != None and versionval != (None,) and versionval != ('',): 
-			versionsplit = [int(i) for i in versionval[0].split('.')]
+		if vst_version != None: 
+			versionsplit = [int(i) for i in vst_version.split('.')]
 			versionbytes =  struct.pack('B'*len(versionsplit), *versionsplit)
-			cvpj_plugindata.dataval_add('version', int.from_bytes(versionbytes, "little"))
+			cvpj_plugindata.dataval_add('version_bytes', int.from_bytes(versionbytes, "little"))
+			cvpj_plugindata.dataval_add('version', vst_version)
 
 		if datatype == 'chunk':
 			cvpj_plugindata.dataval_add('datatype', 'chunk')
-			cvpj_plugindata.dataval_add('chunk', base64.b64encode(data).decode('ascii'))
+			cvpj_plugindata.rawdata_add(data)
 		if datatype == 'param':
 			cvpj_plugindata.dataval_add('datatype', 'param')
 			cvpj_plugindata.dataval_add('numparams', numparams) 

functions/plugin_vst3.py

@@ -0,0 +1,136 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from os.path import exists
+from functions import data_values
+from functions import plugins
+import configparser
+import base64
+import struct
+import platform
+import os
+import sqlite3
+
+cpu_arch_list = [64, 32]
+
+platform_architecture = platform.architecture()
+if platform_architecture[1] == 'WindowsPE': platformtxt = 'win'
+else: platformtxt = 'lin'
+
+os.makedirs(os.getcwd() + '/__config/', exist_ok=True)
+
+db_exists = False
+
+if os.path.exists('./__config/plugins_external.db'):
+	db_plugins = sqlite3.connect('./__config/plugins_external.db')
+	db_exists = True
+
+def set_cpu_arch_list(cpu_arch_list_in):
+	global cpu_arch_list
+	cpu_arch_list = cpu_arch_list_in
+
+def getplatformtxt(in_platform):
+	if in_platform == 'win': platform_txt = 'win'
+	if in_platform == 'lin': platform_txt = 'lin'
+	if in_platform == 'any': 
+		platform_architecture = platform.architecture()
+		if platform_architecture[1] == 'WindowsPE': platform_txt = 'win'
+		else: platform_txt = 'lin'
+	return platform_txt
+
+# -------------------- VST List --------------------
+
+def find_locpath(out_paths):
+	vst_cpuarch = None
+	vst_path = None
+	if out_paths[0] != None and out_paths[1] == None and 32 in cpu_arch_list: vst_cpuarch, vst_path = 32, out_paths[0]
+	if out_paths[0] == None and out_paths[1] != None and 64 in cpu_arch_list: vst_cpuarch, vst_path = 64, out_paths[1]
+	if out_paths[0] != None and out_paths[1] != None and 64 in cpu_arch_list: vst_cpuarch, vst_path = 64, out_paths[1]
+	return vst_cpuarch, vst_path
+
+def db_search(in_data, platformtype, bycat):
+	vst_cpuarch = None
+	vst_path = None
+	vst_name = None
+	vst_id = None
+	vst_version = None
+	out_paths = [None, None]
+
+	if db_exists:
+		if bycat == 'name':
+			if platformtype == 'win': out_paths = db_plugins.execute("SELECT path_32bit_win, path_64bit_win FROM vst3 WHERE name = ?", (in_data,)).fetchone()
+			else: out_paths = db_plugins.execute("SELECT path_32bit_unix, path_64bit_unix FROM vst3 WHERE name = ?", (in_data,)).fetchone()
+			vst_name = in_data
+			vst_id = db_plugins.execute("SELECT id FROM vst3 WHERE name = ?", (in_data,)).fetchone()[0]
+
+		if bycat == 'id':
+			if platformtype == 'win': out_paths = db_plugins.execute("SELECT path_32bit_win, path_64bit_win FROM vst3 WHERE id = ?", (in_data,)).fetchone()
+			else: out_paths = db_plugins.execute("SELECT path_32bit_unix, path_64bit_unix FROM vst3 WHERE id = ?", (in_data,)).fetchone()
+			vst_name = db_plugins.execute("SELECT name FROM vst3 WHERE id = ?", (in_data,)).fetchone()[0]
+			vst_id = in_data
+
+		if bycat == 'path':
+			if platformtype == 'win': 
+				vst_path = in_data.replace('/', '\\')
+				vstname_32 = db_plugins.execute("SELECT name FROM vst3 WHERE path_32bit_win = ?", (vst_path,)).fetchone()
+				vstname_64 = db_plugins.execute("SELECT name FROM vst3 WHERE path_64bit_win = ?", (vst_path,)).fetchone()
+				vstpath_32 = db_plugins.execute("SELECT name, id, path_32bit_win, path_64bit_win FROM vst3 WHERE path_32bit_win = ?", (vst_path,)).fetchone()
+				vstpath_64 = db_plugins.execute("SELECT name, id, path_32bit_win, path_64bit_win FROM vst3 WHERE path_64bit_win = ?", (vst_path,)).fetchone()
+			else: 
+				vstname_32 = db_plugins.execute("SELECT name FROM vst3 WHERE path_32bit_unix = ?", (vst_path,)).fetchone()
+				vstname_64 = db_plugins.execute("SELECT name FROM vst3 WHERE path_64bit_unix = ?", (vst_path,)).fetchone()
+				vstpath_32 = db_plugins.execute("SELECT name, id, path_32bit_unix, path_64bit_unix FROM vst3 WHERE path_32bit_unix = ?", (vst_path,)).fetchone()
+				vstpath_64 = db_plugins.execute("SELECT name, id, path_32bit_unix, path_64bit_unix FROM vst3 WHERE path_64bit_unix = ?", (vst_path,)).fetchone()
+
+			if vstname_32 != None: vst_cpuarch = 32
+			if vstname_64 != None: vst_cpuarch = 64
+
+			vst_paths = data_values.list_usefirst([vstpath_32, vstpath_64])
+			if vst_paths != None: 
+				vst_name = vst_paths[0]
+				vst_id = vst_paths[1]
+				out_paths = [vst_paths[2], vst_paths[3]]
+
+		if vst_id:
+			vst_version_db = db_plugins.execute("SELECT version FROM vst3 WHERE id = ?", (str(vst_id),)).fetchone()
+			if vst_version_db: vst_version = vst_version_db[0]
+
+	if out_paths == None: out_paths = [None, None]
+	vst_cpuarch, vst_path = find_locpath(out_paths)
+
+	return vst_cpuarch, vst_path, vst_name, vst_id, vst_version
+
+def check_exists(in_name):
+	if db_exists:
+		outval = db_plugins.execute("SELECT count(*) FROM vst3 WHERE name = ?", (in_name,)).fetchone()
+		return bool(outval[0])
+	else:
+		return False
+
+def replace_data(cvpj_plugindata, bycat, platform, in_name, data):
+	global cpu_arch_list
+	platformtxt = getplatformtxt(platform)
+	vst_cpuarch, vst_path, vst_name, vst_id, vst_version = db_search(in_name, platformtxt, bycat)
+
+	if vst_path != None:
+		plugintype = cvpj_plugindata.type_get()
+
+		if plugintype[0] != 'vst3': cvpj_plugindata.replace('vst3', platformtxt)
+
+		if bycat == 'name': 
+			if plugintype[0] == None and plugintype[1] == None: print('[plugin-vst3] ' + vst_name + ' (vst3 '+str(vst_cpuarch)+'-bit)')
+			if plugintype[0] != None and plugintype[1] == None: print('[plugin-vst3] ' + plugintype[0] +' > ' + vst_name + ' (vst3 '+str(vst_cpuarch)+'-bit)')
+			if plugintype[0] != None and plugintype[1] != None: print('[plugin-vst3] ' + ':'.join(plugintype) +' > ' + vst_name + ' (vst3 '+str(vst_cpuarch)+'-bit)')
+
+		cvpj_plugindata.dataval_add('name', vst_name)
+		cvpj_plugindata.dataval_add('path', vst_path)
+		cvpj_plugindata.dataval_add('cpu_arch', vst_cpuarch)
+		cvpj_plugindata.dataval_add('id', vst_id)
+		cvpj_plugindata.dataval_add('version', vst_version)
+
+		cvpj_plugindata.dataval_add('datatype', 'chunk')
+		cvpj_plugindata.rawdata_add(data)
+	else:
+		print('[plugin-vst3] Plugin, '+str(in_name)+' not found.')
+
+	return cvpj_plugindata

functions/plugins.py

@@ -4,6 +4,7 @@
 from functions import params
 from functions import xtramath
 from functions import data_values
+import base64
 
 def namegroup_add(i_dict, i_group, i_name, i_data):
     data_values.nested_dict_add_value(i_dict, [i_group, i_name], i_data)
@@ -157,6 +158,20 @@ class cvpj_plugin:
                 datavallist.append(datavalname)
         return datavallist
 
+    # -------------------------------------------------- rawdata
+    def rawdata_add(self, i_value):
+        self.cvpjdata['rawdata'] = base64.b64encode(i_value).decode('ascii')
+
+    def rawdata_add_b64(self, i_value):
+        self.cvpjdata['rawdata'] = i_value
+
+    def rawdata_get(self):
+        if 'rawdata' in self.cvpjdata: return base64.b64decode(self.cvpjdata['rawdata'])
+        else: return b''
+
+    def rawdata_get_b64(self):
+        if 'rawdata' in self.cvpjdata: return self.cvpjdata['rawdata']
+        else: return b''
     # -------------------------------------------------- regions
     def region_add(self, regiondata):
         data_values.nested_dict_add_to_list(self.cvpjdata, ['regions'], regiondata)
@@ -578,6 +593,26 @@ class cvpj_plugin:
         if i_name in self.cvpjdata['osc_data']:
             return self.cvpjdata['osc_data'][i_name]
 
+    # -------------------------------------------------- dsf_import
+
+    def param_dict_dataset_get(self, i_dict, dataset, catname, pluginname):
+        paramlist = dataset.params_list(catname, pluginname)
+        if paramlist:
+            for param in paramlist:
+                outval = data_values.nested_dict_get_value(i_dict, param.split('/'))
+                self.param_add_dset(param, outval, dataset, catname, pluginname)
+
+    def param_dict_dataset_set(self, dataset, catname, pluginname):
+        paramlist = dataset.params_list(catname, pluginname)
+        outdict = {}
+        if paramlist:
+            for param in paramlist:
+                defparams = dataset.params_i_get(catname, pluginname, param)
+                if not defparams[0]: outdata = self.param_get(param, defparams[2])[0]
+                else: outdata = self.dataval_get(param, defparams[2])
+                data_values.nested_dict_add_value(outdict, param.split('/'), outdata)
+        return outdict
+
     # -------------------------------------------------- to_cvpj
     def to_cvpj(self, cvpj_l, pluginid):
         if 'plugins' not in cvpj_l: cvpj_l['plugins'] = {}

functions_plugdata/plugin_adlplug.py

@@ -3,7 +3,7 @@
 
 import lxml.etree as ET
 from functions import plugin_vst2
-from functions_plugparams import data_vc2xml
+from functions_plugdata import data_vc2xml
 
 def addvalue(xmltag, name, value):
     temp_xml = ET.SubElement(xmltag, 'VALUE')

functions_plugdata/plugin_dragonfly_reverb.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from functions import plugin_vst2
+from functions_plugdata import data_nullbytegroup
+
+class dragonfly_hall_data:
+	def __init__(self):
+		self.params = {}
+		self.params['dry_level'] = 100
+		self.params['early_level'] = 0
+		self.params['early_send'] = 25
+		self.params['late_level'] = 0
+
+		self.params['size'] = 24
+		self.params['width'] = 100
+		self.params['delay'] = 0
+		self.params['diffuse'] = 0
+
+		self.params['low_cut'] = 0
+		self.params['low_xo'] = 200
+		self.params['low_mult'] = 1
+
+		self.params['high_cut'] = 16000
+		self.params['high_xo'] = 16000
+		self.params['high_mult'] = 0.2
+
+		self.params['spin'] = 0
+		self.params['wander'] = 0
+		self.params['decay'] = 1
+		self.params['modulation'] = 0
+
+	def set_param(self, name, value):
+		self.params[name] = value
+	
+	def to_cvpj_vst2(self, cvpj_plugindata):
+		plugin_vst2.replace_data(cvpj_plugindata, 'name', 'any', 'Dragonfly Hall Reverb', 'chunk', data_nullbytegroup.make([{'preset': 'Small Dark Hall'}, self.params]), None)

functions_plugdata/plugin_juicysfplugin.py

@@ -3,7 +3,7 @@
 
 import lxml.etree as ET
 from functions import plugin_vst2
-from functions_plugparams import data_vc2xml
+from functions_plugdata import data_vc2xml
 
 class juicysfplugin_data:
 	def __init__(self, cvpj_plugindata):

functions_plugdata/plugin_m8bp.py

@@ -3,7 +3,7 @@
 
 import lxml.etree as ET
 from functions import plugin_vst2
-from functions_plugparams import data_vc2xml
+from functions_plugdata import data_vc2xml
 
 class m8bp_data:
 	def __init__(self, cvpj_plugindata):

functions_plugdata/plugin_nf_spaceship_delay.py

@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from functions import plugin_vst2
+import xml.etree.ElementTree as ET
+
+class spaceship_delay_data:
+	def __init__(self):
+		self.params = {}
+		self.params['INPUT'] = 0
+		self.params['OUTPUT'] = 0.5
+		self.params['MIX'] = 5
+		self.params['DELAYMODE'] = 0
+		self.params['DELAYL'] = 0
+		self.params['DELAYR'] = 0
+		self.params['DELAYSYNCL'] = 22
+		self.params['DELAYSYNCR'] = 22
+		self.params['DELAYVT'] = 0
+		self.params['DELAYBPM'] = 0.35714286565780639648
+		self.params['FEEDBACK'] = 0
+		self.params['CFEEDBACK'] = 0
+		self.params['DELAYSLEW'] = 0.5
+		self.params['DLYTYPE'] = 2
+		self.params['FREEZE'] = 0
+		self.params['REVERB'] = 0
+		self.params['ATTACK'] = 0
+		self.params['MODAMOUNT'] = 0
+		self.params['MODRATE'] = 0.5
+		self.params['MODFILTAMOUNT'] = 0
+		self.params['MODFILTRATE'] = 0.5
+		self.params['MODENVAMOUNT'] = 0.5
+		self.params['FILTALGO'] = 1
+		self.params['FILTPRM1'] = 0
+		self.params['FILTPRM2'] = 1
+		self.params['FILTPRM3'] = 0.75
+		self.params['FILTPRM4'] = 0
+		self.params['FILTLOC'] = 0
+		self.params['FXALGO'] = 0
+		self.params['FXPRM1'] = 0
+		self.params['FXPRM2'] = 0
+		self.params['FXPRM3'] = 0
+		self.params['FXPRM4'] = 0
+		self.params['FXPRM5'] = 0
+		self.params['EFFLOC'] = 1
+		self.params['NLALGO'] = 1
+		self.params['NLPRM1'] = 0
+		self.params['NLPRM2'] = 0
+		self.params['NLPRM3'] = 0
+		self.params['NLPRM4'] = 0
+
+	def set_param(self, name, value):
+		self.params[name] = value
+	
+	def to_cvpj_vst2(self, cvpj_plugindata):
+        xmldata = ET.Element("SPSHIPDELAY1.0.5")  
+        for key, value in self.params.iteritems():
+        	xmldata.set(key) = value
+		plugin_vst2.replace_data(cvpj_plugindata, 'id', 'any', 1181644592, 'chunk', data_vc2xml.make(xmldata), None)

functions_plugdata/plugin_socalabs.py

@@ -3,7 +3,7 @@
 
 import lxml.etree as ET
 from functions import plugin_vst2
-from functions_plugparams import data_vc2xml
+from functions_plugdata import data_vc2xml
 
 class socalabs_data:
 	def __init__(self, cvpj_plugindata):

functions_plugdata/plugin_vital.py

@@ -5,7 +5,7 @@ import json
 import base64
 import struct
 import math
-from functions_plugparams import wave
+from functions_plugdata import data_wave
 from functions import data_values
 from functions import plugins
 from functions import xtramath
@@ -438,11 +438,11 @@ class vital_data:
                 return True
 
     def importcvpj_wave(self, cvpj_plugdata, osc_num, wave_name, **kwargs):
-        wavedata = wave.cvpjwave2wave(cvpj_plugdata, wave_name, **kwargs)
+        wavedata = data_wave.cvpjwave2wave(cvpj_plugdata, wave_name, **kwargs)
         if wavedata != None: self.replacewave(osc_num-1, wavedata)
 
     def importcvpj_harm(self, cvpj_plugdata, osc_num, harm_name):
-        wavedata = wave.cvpjharm2wave(cvpj_plugdata, harm_name)
+        wavedata = data_wave.cvpjharm2wave(cvpj_plugdata, harm_name)
         if wavedata != None: self.replacewave(osc_num-1, wavedata)
 
     def importcvpj_wavetable(self, cvpj_plugdata, osc_num, lfo_num, wave_name, **kwargs):
@@ -458,7 +458,7 @@ class vital_data:
 
             vital_keyframes = {}
             for num in range(cvpj_wt_len):
-                vital_keyframes[cvpj_wt_locs[num]*256] = wave.cvpjwave2wave(cvpj_plugdata, cvpj_wt_ids[num], **kwargs)
+                vital_keyframes[cvpj_wt_locs[num]*256] = data_wave.cvpjwave2wave(cvpj_plugdata, cvpj_wt_ids[num], **kwargs)
 
             self.replacemultiwave(osc_num, vital_keyframes)
 

functions_plugdata/plugin_wolfshaper.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from functions import plugin_vst2
-from functions_plugparams import data_nullbytegroup
+from functions_plugdata import data_nullbytegroup
 
 class wolfshaper_data:
 	def __init__(self):

functions_plugin/flp_dec_plugins.py

@@ -10,8 +10,7 @@ from functions import data_bytes
 from functions import data_values
 from functions import plugins
 from functions import plugin_vst2
-from functions_plugin import flstudio_datadef
-from functions_plugparams import datadef
+from functions import plugin_vst3
 from io import BytesIO
 
 def decode_pointdata(fl_plugstr):
@@ -46,7 +45,7 @@ envshapes = {
     12: 'doublecurve3',
 }
 
-def getparams(cvpj_l, pluginid, pluginname, chunkpdata, foldername):
+def getparams(cvpj_l, pluginid, pluginname, chunkpdata, foldername, datadef, dataset):
     fl_plugstr = BytesIO(chunkpdata if chunkpdata else b'')
     pluginname = pluginname.lower()
     cvpj_plugindata = plugins.cvpj_plugin('deftype', 'native-flstudio', pluginname)
@@ -80,9 +79,10 @@ def getparams(cvpj_l, pluginid, pluginname, chunkpdata, foldername):
             if chunktype == 57: wrapperdata['57'] = chunkdata
 
         if 'plugin_info' in wrapperdata:
+
             wrapper_vsttype = int.from_bytes(wrapperdata['plugin_info'][0:4], "little")
             if 'fourid' in wrapperdata:
-                cvpj_plugindata = plugins.cvpj_plugin('deftype', 'vst2', None)
+                cvpj_plugindata = plugins.cvpj_plugin('deftype', 'vst2', 'win')
                 pluginstate = wrapperdata['state']
                 wrapper_vststate = pluginstate[0:9]
                 wrapper_vstsize = int.from_bytes(pluginstate[9:13], "little")
@@ -90,37 +90,52 @@ def getparams(cvpj_l, pluginid, pluginname, chunkpdata, foldername):
                 wrapper_vstprogram = int.from_bytes(pluginstate[17:21], "little")
                 wrapper_vstdata = pluginstate[21:]
 
-                if wrapper_vststate == b'\xf7\xff\xff\xff\r\xfe\xff\xff\xff':
-                    plugin_vst2.replace_data(cvpj_plugindata, 'name' ,'win', wrapperdata['name'], 'chunk', wrapper_vstdata, 0)
-                    cvpj_plugindata.dataval_add('current_program', wrapper_vstprogram)
+                if wrapper_vststate[0:4] == b'\xf7\xff\xff\xff' and wrapper_vststate[5:9] == b'\xfe\xff\xff\xff':
 
-                if wrapper_vststate == b'\xf7\xff\xff\xff\x05\xfe\xff\xff\xff':
-                    stream_data = BytesIO(wrapper_vstdata)
-                    vst_total_params = int.from_bytes(stream_data.read(4), "little")
-                    vst_params_data = struct.unpack('f'*vst_total_params, stream_data.read(4*vst_total_params))
-                    vst_num_names = int.from_bytes(stream_data.read(4), "little")
-                    vst_names = []
-                    for _ in range(vst_num_names):
-                        vst_names.append( data_bytes.readstring_fixedlen(stream_data, 25, 'utf-8') )
+                    if wrapper_vststate[4] == 13:
+                        plugin_vst2.replace_data(cvpj_plugindata, 'name' ,'win', wrapperdata['name'], 'chunk', wrapper_vstdata, 0)
+                        cvpj_plugindata.dataval_add('current_program', wrapper_vstprogram)
 
-                    numparamseach = vst_total_params//vst_num_names
-                    bankparams = data_values.list_chunks(vst_params_data, numparamseach)
+                    if wrapper_vststate[4] == 5:
+                        stream_data = BytesIO(wrapper_vstdata)
+                        vst_total_params = int.from_bytes(stream_data.read(4), "little")
+                        vst_params_data = struct.unpack('f'*vst_total_params, stream_data.read(4*vst_total_params))
+                        vst_num_names = int.from_bytes(stream_data.read(4), "little")
+                        vst_names = []
+                        for _ in range(vst_num_names):
+                            vst_names.append( data_bytes.readstring_fixedlen(stream_data, 25, 'utf-8') )
 
-                    cvpj_programs = []
-                    for num in range(vst_num_names):
-                        cvpj_program = {}
-                        cvpj_program['datatype'] = 'params'
-                        cvpj_program['numparams'] = numparamseach
-                        cvpj_program['params'] = {}
-                        for paramnum in range(numparamseach):
-                            cvpj_program['params'][str(paramnum)] = {'value': bankparams[num][paramnum]}
-                        cvpj_program['program_name'] = vst_names[num]
-                        cvpj_programs.append(cvpj_program)
+                        numparamseach = vst_total_params//vst_num_names
+                        bankparams = data_values.list_chunks(vst_params_data, numparamseach)
 
-                    plugin_vst2.replace_data(cvpj_plugindata, 'name' ,'win', wrapperdata['name'], 'bank', cvpj_programs, None)
-                    cvpj_plugindata.dataval_add('current_program', wrapper_vstprogram)
+                        cvpj_programs = []
+                        for num in range(vst_num_names):
+                            cvpj_program = {}
+                            cvpj_program['datatype'] = 'params'
+                            cvpj_program['numparams'] = numparamseach
+                            cvpj_program['params'] = {}
+                            for paramnum in range(numparamseach): cvpj_program['params'][str(paramnum)] = {'value': bankparams[num][paramnum]}
+                            cvpj_program['program_name'] = vst_names[num]
+                            cvpj_programs.append(cvpj_program)
+
+                        plugin_vst2.replace_data(cvpj_plugindata, 'name' ,'win', wrapperdata['name'], 'bank', cvpj_programs, None)
+                        cvpj_plugindata.dataval_add('current_program', wrapper_vstprogram)
+            else:
+                pluginstate = wrapperdata['state']
+                pluginstate_str = BytesIO(pluginstate)
+                stateheader = pluginstate_str.read(80)
+
+                vststatedata = {}
+
+                while pluginstate_str.tell() < len(pluginstate):
+                    chunktype = int.from_bytes(pluginstate_str.read(4), 'little')
+                    chunksize = int.from_bytes(pluginstate_str.read(4), 'little')
+                    pluginstate_str.read(4)
+                    chunkdata = pluginstate_str.read(chunksize)
+                    vststatedata[chunktype] = chunkdata
+
+                plugin_vst3.replace_data(cvpj_plugindata, 'name', 'win', wrapperdata['name'], vststatedata[3] if 3 in vststatedata else b'')
 
-                    
 
     elif pluginname == 'fruity compressor':
         flplugvals = struct.unpack('i'*8, chunkpdata)
@@ -335,27 +350,15 @@ def getparams(cvpj_l, pluginid, pluginname, chunkpdata, foldername):
         for point in autodata_table:
             cvpj_plugindata.env_points_add('shape', point[0], point[1][0], tension=point[2], type=envshapes[point[3]])
         
-
     else:
-        fl_datadef = flstudio_datadef.get_datadef(pluginname)
-
-        if fl_datadef != []:
+        datadef_struct = dataset.object_var_get('datadef_struct', 'plugin', pluginname)
+        #print(     chunkpdata.hex()     )
+        if datadef_struct[0]:
             cvpj_plugindata = plugins.cvpj_plugin('deftype', 'native-flstudio', pluginname)
-            datadef.to_plugdata(cvpj_plugindata, fl_datadef, fl_plugstr)
-        #if pluginname == 'simsynth': exit()
-
-    #elif pluginname == 'pitcher': LATER
-    #    chunkdata = data_bytes.riff_read(chunkdata, 0)
-    #    riffbio = BytesIO(chunkdata[0][1][4:])
-    #    flplugvals = struct.unpack('f'*33, riffbio.read(33*4))
-    #    flplugflags = struct.unpack('b'*16, riffbio.read(16))
-    #    for test in range(len(flplugvals)):
-    #        print(test, flplugvals[test])
-    #    cvpj_plugindata.param_add('speed', flplugvals[0], 'int', "Correction Speed")
-    #    cvpj_plugindata.param_add('gender', flplugvals[2], 'int', "Gender")
-    #    cvpj_plugindata.param_add('finetune', flplugvals[3], 'int', "Fine Tune")
+            jsondecoded = datadef.parse(datadef_struct[1], chunkpdata)
+            cvpj_plugindata.param_dict_dataset_get(jsondecoded, dataset, 'plugin', pluginname)
 
     # ------------------------------------------------------------------------------------------- Other
 
-    cvpj_plugindata.dataval_add('chunk', base64.b64encode(chunkpdata).decode('ascii'))
+    if pluginname != 'fruity wrapper': cvpj_plugindata.rawdata_add(chunkpdata)
     return cvpj_plugindata

functions_plugin/flp_enc_plugins.py

@@ -7,23 +7,24 @@ import os
 import math
 import base64
 from functions import data_bytes
+from functions import data_values
 from functions import plugins
 from functions import plugin_vst2
-from functions_plugin import flstudio_datadef
-from functions_plugparams import datadef
 
 def wrapper_addchunk(chunkid, chunkdata):
     return chunkid.to_bytes(4, "little") + len(chunkdata).to_bytes(4, "little") + b'\x00\x00\x00\x00' + chunkdata
 
-def setparams(cvpj_plugdata):
+def setparams(cvpj_plugdata, datadef, dataset):
     fl_plugin, fl_pluginparams = None, None
     plug_type = cvpj_plugdata.type_get()
 
     if plug_type[0] == 'native-flstudio':
-        fl_datadef = flstudio_datadef.get_datadef(plug_type[1])
-        if fl_datadef != []:
+        datadef_struct = dataset.object_var_get('datadef_struct', 'plugin', plug_type[1])
+        if datadef_struct[0]:
+            dictdata = cvpj_plugdata.param_dict_dataset_set(dataset, 'plugin', plug_type[1])
             fl_plugin = plug_type[1]
-            fl_pluginparams = datadef.from_plugdata(cvpj_plugdata, fl_datadef)
+            datadef.create(datadef_struct[1], dictdata)
+            fl_pluginparams = datadef.bytestream.getvalue()
 
     if plug_type[0] == 'soundfont2':
         fl_plugin = 'fruity soundfont player'
@@ -64,7 +65,7 @@ def setparams(cvpj_plugdata):
         vst_name = cvpj_plugdata.dataval_get('name', None)
         vst_path = cvpj_plugdata.dataval_get('path', None)
 
-        vstdata_bytes = base64.b64decode(vst_chunk)
+        vstdata_bytes = cvpj_plugdata.rawdata_get()
 
         if vst_datatype == 'chunk':
             wrapper_state = b'\xf7\xff\xff\xff\r\xfe\xff\xff\xff' + len(vstdata_bytes).to_bytes(4, "little") + b'\x00\x00\x00\x00' + vst_current_program.to_bytes(4, "little") + vstdata_bytes
@@ -110,7 +111,7 @@ def setparams(cvpj_plugdata):
         if vst_fourid != None: wrapper_data += wrapper_addchunk(51, data_bytes.swap32(vst_fourid).to_bytes(4, "little") )
         wrapper_data += wrapper_addchunk(57, b'`\t\x00\x00' )
         if vst_name != None: wrapper_data += wrapper_addchunk(54, vst_name.encode() )
-        wrapper_data += wrapper_addchunk(55, vst_path.encode() )
+        if vst_path != None: wrapper_data += wrapper_addchunk(55, vst_path.encode() )
         wrapper_data += wrapper_addchunk(53, wrapper_state )
 
 

functions_plugin/flstudio_datadef.py

@@ -467,7 +467,7 @@ def get_datadef(pluginname):
 		out = [
 			["I",True,"type","Type"],
 			["I",True,"freq","Frequency"],
-			["I",True,"lowpass","Q"],
+			["I",True,"q","Q"],
 			["I",True,"gain","Gain"],
 			["I",True,"center","Center"],
 		]

functions_plugin/format_midi_in.py

@@ -330,7 +330,7 @@ def song_end(cvpj_l):
 		s_fx_usedinstid = fx_usedinstid[fxnum]
 
 		for i_fx_usedinstid in s_fx_usedinstid:
-			_, groupname = dataset_midi.object_group_get('inst', str(i_fx_usedinstid[1]))
+			_, groupname = dataset_isobjfound, dataset_data = dataset_midi.object_var_get('group', 'inst', str(i_fx_usedinstid[1]))
 			i_fx_usedinstid.append(groupname)
 
 		fx_name = None

functions_plugparams/opl_sbi.py

@@ -1,68 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from functions import plugins
-from functions import data_bytes
-
-def opl2sbi_plugin(cvpj_l, pluginid, 
-    iModChar, iCarChar, iModScale, iCarScale, 
-    iModAttack, iCarAttack, iModSustain, iCarSustain, 
-    iModWaveSel, iCarWaveSel, iFeedback):
-    print('opl2sbi_plugin')
-
-    opl_mod_flags, opl_mod_mul = data_bytes.splitbyte(iModChar) 
-    opl_mod_trem, opl_mod_vib, opl_mod_sust, opl_mod_krs = data_bytes.to_bin(opl_mod_flags, 4)
-    opl_car_flags, opl_car_mul = data_bytes.splitbyte(iCarChar)
-    opl_car_trem, opl_car_vib, opl_car_sust, opl_car_krs = data_bytes.to_bin(opl_car_flags, 4)
-    opl_mod_kls = iModScale >> 6
-    opl_mod_out = iModScale & 0x3F
-    opl_car_kls = iCarScale >> 6
-    opl_car_out = iCarScale & 0x3F
-    opl_fb = iFeedback
-
-    opl_fb = iFeedback & 0x07
-    opl_con = iFeedback >> 3
-
-    opl_mod_wave = iModWaveSel
-    opl_car_wave = iCarWaveSel
-    opl_mod_att, opl_mod_dec = data_bytes.splitbyte(iModAttack) 
-    opl_car_att, opl_car_dec = data_bytes.splitbyte(iCarAttack) 
-    opl_mod_sus, opl_mod_rel = data_bytes.splitbyte(iModSustain) 
-    opl_car_sus, opl_car_rel = data_bytes.splitbyte(iCarSustain)
-
-    print(opl_mod_wave, opl_car_wave)
-
-    plugins.replace_plug(cvpj_l, pluginid, 'fm', 'opl2')
-
-    plugins.add_plug_param(cvpj_l, pluginid, "feedback", opl_fb, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "percussive", 0, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "perctype", 0, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "tremolo_depth", 0, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "vibrato_depth", 0, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "fm", opl_con, 'int', "")
-
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_scale", opl_mod_kls, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_freqmul", opl_mod_mul, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_env_attack", (opl_mod_att*-1)+15, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_env_sustain", (opl_mod_sus*-1)+15, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_perc_env", 0, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_env_decay", (opl_mod_dec*-1)+15, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_env_release", opl_mod_rel, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_level", (opl_mod_out*-1)+63, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_tremolo", opl_mod_trem, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_vibrato", opl_mod_vib, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_ksr", opl_mod_krs, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "mod_waveform", opl_mod_wave, 'int', "")
-
-    plugins.add_plug_param(cvpj_l, pluginid, "car_scale", opl_car_kls, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_freqmul", opl_car_mul, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_env_attack", (opl_car_att*-1)+15, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_env_sustain", (opl_car_sus*-1)+15, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_perc_env", 0, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_env_decay", (opl_car_dec*-1)+15, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_env_release", opl_car_rel, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_level", (opl_car_out*-1)+63, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_tremolo", opl_car_trem, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_vibrato", opl_car_vib, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_ksr", opl_car_krs, 'int', "")
-    plugins.add_plug_param(cvpj_l, pluginid, "car_waveform", opl_car_wave, 'int', "")

functions_plugparams/params_kickmess.py

@@ -1,57 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import io
-import math
-
-def initparams():
-    global params
-    params = {}
-    params['pub'] = {}
-    params['pub']['freq_start'] = 440
-    params['pub']['freq_end'] = 440
-    params['pub']['f_env_release'] = 1000
-    params['pub']['dist_start'] = 0
-    params['pub']['dist_end'] = 0
-    params['pub']['gain'] = 0.5
-    params['pub']['env_slope'] = 0.5
-    params['pub']['freq_slope'] = 0.5
-    params['pub']['noise'] = 0
-    params['pub']['freq_note_start'] = 0.25
-    params['pub']['freq_note_end'] = 0.25
-    params['pub']['env_release'] = 0
-    params['pub']['phase_offs'] = 0
-    params['pub']['dist_on'] = 0
-    params['pub']['f1_cutoff'] = 1
-    params['pub']['f1_res'] = 0
-    params['pub']['f1_drive'] = 0.2
-    params['pub']['main_gain'] = 0.70710677
-    params['pub']['e1_attack'] = 0.1
-    params['pub']['e1_decay'] = 0.14142135
-    params['pub']['e1_sustain'] = 0.75
-    params['pub']['e1_release'] = 0.1
-    params['priv'] = {}
-    params['priv']['f1_type'] = 0.5
-    params['priv']['f1_on'] = 0.25
-    params['priv']['midi_chan'] = 0
-
-def setvalue(i_cat, i_name, i_value):
-    global params
-    params[i_cat][i_name] = i_value
-
-def getparams():
-    global params
-
-    out = io.BytesIO()
-    out.write(b'!PARAMS;\n')
-
-    for paramcat in params:
-        for paramval in params[paramcat]:
-            o_value = params[paramcat][paramval]
-            if paramval == 'freq_start': o_value = math.sqrt((o_value-2.51)/3000)
-            if paramval == 'freq_end': o_value = math.sqrt((o_value-2.51)/2000)
-            if paramval == 'f_env_release': if o_value > 2.4: o_value = math.sqrt((o_value-2.51)/5000)
-            out.write(str.encode(i_cat+' : '+i_name+'='+str(i_value)+';\n'))
-
-    out.seek(0)
-    return out.read()

functions_plugparams/params_ninjas2.py

@@ -1,90 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from functions import data_values
-from functions import plugins
-
-def create_blank_prog():
-    progout = ''
-    progtext = '0 0 0 0.001000 0.001000 1.000000 0.001000 '
-    progout += '1 '
-    for _ in range(128): progout += progtext
-    return progout
-
-def initparams():
-    global data_progs
-    global data_main
-    data_main = {}
-    data_progs = {}
-
-    data_main['number_of_slices'] = '0.000000'
-    data_main['sliceSensitivity'] = '0.500000'
-    data_main['attack'] = '0.001000'
-    data_main['decay'] = '0.001000'
-    data_main['sustain'] = '1.000000'
-    data_main['release'] = '0.001000'
-    data_main['load'] = '0.000000'
-    data_main['slicemode'] = '1.000000'
-    data_main['programGrid'] = '1.000000'
-    data_main['playmode'] = '0.000000'
-    data_main['pitchbendDepth'] = '12.000000'
-    data_main['OneShotForward'] = '1.000000'
-    data_main['OneShotReverse'] = '0.000000'
-    data_main['LoopForward'] = '0.000000'
-    data_main['LoopReverse'] = '0.000000'
-
-    data_progs['slices'] = 'empty'
-    data_progs['filepathFromUI'] = ''
-    data_progs['program00'] = create_blank_prog()
-    data_progs['program01'] = create_blank_prog()
-    data_progs['program02'] = create_blank_prog()
-    data_progs['program03'] = create_blank_prog()
-    data_progs['program04'] = create_blank_prog()
-    data_progs['program05'] = create_blank_prog()
-    data_progs['program06'] = create_blank_prog()
-    data_progs['program07'] = create_blank_prog()
-    data_progs['program08'] = create_blank_prog()
-    data_progs['program09'] = create_blank_prog()
-    data_progs['program10'] = create_blank_prog()
-    data_progs['program11'] = create_blank_prog()
-    data_progs['program12'] = create_blank_prog()
-    data_progs['program13'] = create_blank_prog()
-    data_progs['program14'] = create_blank_prog()
-    data_progs['program15'] = create_blank_prog()
-
-def slicerdata(cvpj_l, pluginid):
-    global data_progs
-    global data_main
-
-    filepath = plugins.get_plug_dataval(cvpj_l, pluginid, 'file', '')
-    slices = plugins.get_plug_dataval(cvpj_l, pluginid, 'slices', [])
-    trigger = plugins.get_plug_dataval(cvpj_l, pluginid, 'trigger', 'normal')
-
-    if trigger == 'normal': releasevalue = '0.001000'
-    if trigger == 'oneshot': releasevalue = '1.000000'
-
-    progtable = []
-    for _ in range(127): progtable.append('0 0 0 0.001000 0.001000 1.000000 '+releasevalue+' ')
-    data_main['release'] = releasevalue
-    progout = ''
-    progout += str(len(slices))+' 128 '
-    data_main['number_of_slices'] = str(len(slices))
-
-    for slicenum in range(len(slices)):
-        slicedata = slices[slicenum]
-        s_reverse = data_values.get_value(slicedata, 'reverse', False)
-        s_looped = data_values.get_value(slicedata, 'looped', False)
-        loopout = 0
-        if s_reverse == True: loopout += 1
-        if s_looped == True: loopout += 2
-        progtable[slicenum] = str(slicedata['pos']*2)+' '+str(slicedata['end']*2)+' '+str(loopout)+' 0.001000 0.001000 1.000000 '+releasevalue
-
-    data_progs['filepathFromUI'] = filepath
-
-    for prognums in progtable: progout += prognums+' '
-    data_progs['program00'] = progout
-
-def getparams():
-    global data_progs
-    global data_main
-    return [data_progs, data_main]

functions_plugparams/params_various_fx.py

@@ -1,49 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-# -------------------- wolfshaper --------------------
-
-def wolfshaper_init():
-	global wolfshapergraph
-	global wolfshaperparams
-	wolfshapergraph = {}
-	wolfshapergraph['graph'] = ''
-	wolfshaperparams = {}
-	wolfshaperparams['pregain'] = 2.000000
-	wolfshaperparams['wet'] = 1.000000
-	wolfshaperparams['postgain'] = 1.000000
-	wolfshaperparams['removedc'] = 1.000000
-	wolfshaperparams['oversample'] = 0.000000
-	wolfshaperparams['bipolarmode'] = 0.000000
-	wolfshaperparams['warptype'] = 0.000000
-	wolfshaperparams['warpamount'] = 0.000000
-	wolfshaperparams['vwarptype'] = 0.000000
-	wolfshaperparams['vwarpamount'] = 0.000000
-
-def wolfshaper_setvalue(name, value):
-	global wolfshaperparams
-	wolfshaperparams[name] = value
-	
-def wolfshaper_addshape(cvpj_auto):
-	for cvpj_point in cvpj_auto['points']:
-		tension = data_values.get_value(cvpj_point, 'tension', 0)
-		pointtype = data_values.get_value(cvpj_point, 'type', 'normal')
-		wolfshaper_addpoint(cvpj_point['position'],cvpj_point['value'],tension,pointtype)
-def wolfshaper_addpoint(posX,posY,tension,pointtype):
-	global wolfshapergraph
-	if pointtype == 'normal': pointtype = 0
-	elif pointtype in ['doublecurve', 'doublecurve2', 'doublecurve3']: pointtype = 1
-	elif pointtype == 'stairs': 
-		pointtype = 2
-		tension *= -1
-	elif pointtype == 'wave': 
-		pointtype = 3
-		tension = ((abs(tension)*-1)+100)*0.2
-	else: 
-		pointtype = 1
-
-	wolfshapergraph['graph'] += float.hex(posX)+','+float.hex(posY)+','+float.hex(tension*-100)+','+str(int(pointtype))+';'
-def wolfshaper_get():
-	global wolfshapergraph
-	global wolfshaperparams
-	return [wolfshapergraph, wolfshaperparams]

functions_plugparams/params_various_inst.py

@@ -1,125 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import lxml.etree as ET
-
-# -------------------- magical8bitplug --------------------
-def shape_m8bp(pluginname, plugindata):
-	m8p_root = ET.Element("root")
-	m8p_params = ET.SubElement(m8p_root, "Params")
-	m8bp_addvalue(m8p_params, "arpeggioDirection", 0.0)
-	m8bp_addvalue(m8p_params, "arpeggioTime", 0.02999999932944775)
-	m8bp_addvalue(m8p_params, "attack", 0.0)
-	m8bp_addvalue(m8p_params, "bendRange", 12.0)
-	m8bp_addvalue(m8p_params, "colorScheme", 1.0)
-	m8bp_addvalue(m8p_params, "decay", 0.0)
-	m8bp_addvalue(m8p_params, "duty", 0.0)
-	m8bp_addvalue(m8p_params, "gain", 0.5)
-	m8bp_addvalue(m8p_params, "isAdvancedPanelOpen_raw", 1.0)
-	m8bp_addvalue(m8p_params, "isArpeggioEnabled_raw", 0.0)
-	m8bp_addvalue(m8p_params, "isDutySequenceEnabled_raw", 0.0)
-	m8bp_addvalue(m8p_params, "isVolumeSequenceEnabled_raw", 0.0)
-	m8bp_addvalue(m8p_params, "maxPoly", 8.0)
-	m8bp_addvalue(m8p_params, "noiseAlgorithm_raw", 0.0)
-	if pluginname == 'shape-square':
-		m8bp_addvalue(m8p_params, "osc", 0.0)
-		m8bp_addvalue(m8p_params, "duty", 2.0)
-	elif pluginname == 'shape-pulse':
-		m8bp_addvalue(m8p_params, "osc", 0.0)
-		if 'duty' in plugindata:
-			if plugindata['duty'] == 0.25: m8bp_addvalue(m8p_params, "duty", 1.0)
-			elif plugindata['duty'] == 0.125: m8bp_addvalue(m8p_params, "duty", 0.0)
-			else: m8bp_addvalue(m8p_params, "duty", 0.0)
-		else: m8bp_addvalue(m8p_params, "duty", 1.0)
-	elif pluginname == 'shape-triangle':
-		m8bp_addvalue(m8p_params, "osc", 1.0)
-		m8bp_addvalue(m8p_params, "duty", 0.0)
-	elif pluginname == 'retro-noise':
-		m8bp_addvalue(m8p_params, "osc", 2.0)
-		if 'type' in plugindata:
-			if plugindata['type'] == '4bit': m8bp_addvalue(m8p_params, "duty", 0.0)
-			elif plugindata['type'] == '1bit_long': m8bp_addvalue(m8p_params, "duty", 1.0)
-			elif plugindata['type'] == '1bit_short': m8bp_addvalue(m8p_params, "duty", 2.0)
-			else: m8bp_addvalue(m8p_params, "duty", 0.0)
-		else: m8bp_addvalue(m8p_params, "duty", 0.0)
-	else: m8bp_addvalue(m8p_params, "osc", 0.0)
-	m8bp_addvalue(m8p_params, "pitchSequenceMode_raw", 0.0)
-	m8bp_addvalue(m8p_params, "release", 0.0)
-	m8bp_addvalue(m8p_params, "restrictsToNESFrequency_raw", 0.0)
-	m8bp_addvalue(m8p_params, "suslevel", 1.0)
-	m8bp_addvalue(m8p_params, "sweepInitialPitch", 0.0)
-	m8bp_addvalue(m8p_params, "sweepTime", 0.1000000014901161)
-	m8bp_addvalue(m8p_params, "vibratoDelay", 0.2999999821186066)
-	m8bp_addvalue(m8p_params, "vibratoDepth", 0.0)
-	m8bp_addvalue(m8p_params, "vibratoIgnoresWheel_raw", 1.0)
-	m8bp_addvalue(m8p_params, "vibratoRate", 0.1500000059604645)
-	return m8p_root
-
-def m8bp_init():
-	global m8bp_params
-	global m8bp_params_env
-
-	m8bp_params_env = {}
-	m8bp_params_env["duty"] = None
-	m8bp_params_env["pitch"] = None
-	m8bp_params_env["volume"] = None
-
-	m8bp_params = {}
-	m8bp_params["arpeggioDirection"] = 0.0
-	m8bp_params["arpeggioTime"] = 0.02999999932944775
-	m8bp_params["attack"] = 0.0
-	m8bp_params["bendRange"] = 12.0
-	m8bp_params["colorScheme"] = 1.0
-	m8bp_params["decay"] = 0.0
-	m8bp_params["duty"] = 0.0
-	m8bp_params["gain"] = 0.5
-	m8bp_params["isAdvancedPanelOpen_raw"] = 1.0
-	m8bp_params["isArpeggioEnabled_raw"] = 0.0
-	m8bp_params["isPitchSequenceEnabled_raw"] = 0.0
-	m8bp_params["isDutySequenceEnabled_raw"] = 0.0
-	m8bp_params["isVolumeSequenceEnabled_raw"] = 0.0
-	m8bp_params["maxPoly"] = 8.0
-	m8bp_params["noiseAlgorithm_raw"] = 0.0
-	m8bp_params["osc"] = 0.0
-	m8bp_params["duty"] = 2.0
-	m8bp_params["pitchSequenceMode_raw"] = 0.0
-	m8bp_params["release"] = 0.0
-	m8bp_params["restrictsToNESFrequency_raw"] = 0.0
-	m8bp_params["suslevel"] = 1.0
-	m8bp_params["sweepInitialPitch"] = 0.0
-	m8bp_params["sweepTime"] = 0.1000000014901161
-	m8bp_params["vibratoDelay"] = 0.2999999821186066
-	m8bp_params["vibratoDepth"] = 0.0
-	m8bp_params["vibratoIgnoresWheel_raw"] = 1.0
-	m8bp_params["vibratoRate"] = 0.1500000059604645
-
-def m8bp_setvalue(name, value):
-	global m8bp_params
-	m8bp_params[name] = value
-
-def m8bp_setenv(name, value):
-	global m8bp_params_env
-	m8bp_params_env[name] = value
-
-def m8bp_addvalue(xmltag, name, value):
-	temp_xml = ET.SubElement(xmltag, 'PARAM')
-	temp_xml.set('id', str(name))
-	temp_xml.set('value', str(value))
-
-def m8bp_out():
-	global m8bp_params
-	global m8bp_params_env
-	xml_m8p_root = ET.Element("root")
-	xml_m8p_params = ET.SubElement(xml_m8p_root, "Params")
-	for m8bp_param in m8bp_params:
-		m8bp_addvalue(xml_m8p_params, m8bp_param, str(m8bp_params[m8bp_param]))
-
-	m8p_dutyEnv = ET.SubElement(xml_m8p_root, "dutyEnv")
-	m8p_pitchEnv = ET.SubElement(xml_m8p_root, "pitchEnv")
-	m8p_volumeEnv = ET.SubElement(xml_m8p_root, "volumeEnv")
-
-	if m8bp_params_env["duty"] != None: m8p_dutyEnv.text = ','.join(str(item) for item in m8bp_params_env["duty"])
-	if m8bp_params_env["pitch"] != None: m8p_pitchEnv.text = ','.join(str(item) for item in m8bp_params_env["pitch"])
-	if m8bp_params_env["volume"] != None: m8p_volumeEnv.text = ','.join(str(item) for item in m8bp_params_env["volume"])
-
-	return xml_m8p_root

functions_plugparams/params_vital_wavetable.py

@@ -1,38 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import math
-
-# -------------------- Shapes --------------------
-def wave_sine(x): return math.sin((x-0.5)*(math.pi*2))
-def wave_saw(x): return x-math.floor(x)
-def wave_tri(x): return abs((x*2)%(2)-1)
-def wave_squ(x, pw):
-    if wave_tri(x) > pw: return 1
-    else: return -1
-
-def tripleoct(x, shape, pw, one, two):
-    if shape == 'sine': samplepoint = wave_sine(x) + wave_sine(x*2)*one + wave_sine(x*4)*two
-    elif shape == 'saw': samplepoint = wave_saw(x) + wave_saw(x*2)*one + wave_saw(x*4)*two
-    elif shape == 'triangle': samplepoint = wave_tri(x) + wave_tri(x*2)*one + wave_tri(x*4)*two
-    elif shape == 'square': samplepoint = wave_squ(x, pw) + wave_squ(x*2, pw)*one + wave_squ(x*4, pw)*two
-    else: samplepoint = x
-    return samplepoint
-
-def create_wave(shape, mul, pw):
-    vital_osc_shape = []
-    if shape == 'sine': vital_osc_shape = [wave_sine(num/2048) for num in range(2048)]
-    if shape == 'saw': vital_osc_shape = [wave_saw(num/2048) for num in range(2048)]
-    if shape == 'triangle': vital_osc_shape = [wave_tri(num/2048) for num in range(2048)]
-    if shape == 'square': vital_osc_shape = [wave_squ(num/2048) for num in range(2048)]
-    if shape == 'square_roundend':
-        for num in range(2048): 
-            if num <= 1024: vital_osc_shape.append((wave_sine(num/4096)*-1))
-            else: vital_osc_shape.append(0)
-    if shape == 'mooglike':
-        for num in range(2048): 
-            if num <= 1024: vital_osc_shape.append(num/1024)
-            else: vital_osc_shape.append(wave_tri((num+1024)/2048)**3)
-    if shape == 'exp': vital_osc_shape = [wave_tri((num+1024)/2048)**3 for num in range(2048)]
-    return vital_osc_shape
-

functions_song/convert_r2m.py

@@ -33,12 +33,23 @@ def convert(song):
     if 'track_order' not in cvpj_proj:
         print('[error] track_order not found')
 
-    t_s_track_order = cvpj_proj['track_order']
-    t_s_trackdata = cvpj_proj['track_data']
-    t_s_trackplacements = cvpj_proj['track_placements']
-    del cvpj_proj['track_data']
-    del cvpj_proj['track_order']
-    del cvpj_proj['track_placements']
+    if 'track_order' in cvpj_proj:
+        t_s_track_order = cvpj_proj['track_order']
+        del cvpj_proj['track_order']
+    else:
+        t_s_track_order = []
+
+    if 'track_data' in cvpj_proj:
+        t_s_trackdata = cvpj_proj['track_data']
+        del cvpj_proj['track_data']
+    else:
+        t_s_trackdata = {}
+
+    if 'track_placements' in cvpj_proj:
+        t_s_trackplacements = cvpj_proj['track_placements']
+        del cvpj_proj['track_placements']
+    else:
+        t_s_trackplacements = {}
 
     cvpj_proj['instruments_data'] = {}
     cvpj_proj['instruments_order'] = []

functions_tracks/tracks_m.py

@@ -65,9 +65,9 @@ def add_pl(cvpj_l, idnum, pl_type, placements_data):
         data_values.nested_dict_add_to_list(cvpj_l, ['playlist', str(idnum), placement_name], placements_data)
 
 
-def import_dset(cvpj_l, trackid, instid, main_dataset, midi_dataset, def_name, def_color):
-    m_bank, m_inst, m_drum = main_dataset.midito_get('inst', instid)
-    di_name, di_color = main_dataset.object_get_name_color('inst', instid)
+def import_dset(cvpj_l, instid, dsetinstname, main_dataset, midi_dataset, def_name, def_color):
+    m_bank, m_inst, m_drum = main_dataset.midito_get('inst', str(dsetinstname))
+    di_name, di_color = main_dataset.object_get_name_color('inst', str(dsetinstname))
     if m_inst != None:
         dm_name, dm_color = midi_dataset.object_get_name_color('inst', str(m_inst))
         out_name = data_values.list_usefirst([def_name, di_name, instid])

plugin_input/mi_boscaceoil.py

@@ -4,6 +4,7 @@
 from functions import placements
 from functions import placement_data
 from functions import idvals
+from functions import data_dataset
 from functions import plugins
 from functions import song
 from functions_tracks import fxslot
@@ -53,15 +54,9 @@ class input_ceol(plugin_input.base):
 
         cvpj_l_keynames_data = {}
 
-        idvals_inst_midi = idvals.parse_idvalscsv('data_idvals/midi_inst.csv')
+        dataset = data_dataset.dataset('./data_dset/boscaceoil.dset')
+        dataset_midi = data_dataset.dataset('./data_dset/midi.dset')
         idvals_inst_bosca = idvals.parse_idvalscsv('data_idvals/boscaceoil_inst.csv')
-        idvals_drumkit_midi = idvals.parse_idvalscsv('data_idvals/boscaceoil_drumkit_midi.csv')
-        idvals_drumkit_simple = idvals.parse_idvalscsv('data_idvals/boscaceoil_drumkit_simple.csv')
-        idvals_drumkit_sion = idvals.parse_idvalscsv('data_idvals/boscaceoil_drumkit_sion.csv')
-
-        cvpj_l_keynames_data['drumkit_midi'] = idvals.idval2drumkeynames(idvals_drumkit_midi)
-        cvpj_l_keynames_data['drumkit_simple'] = idvals.idval2drumkeynames(idvals_drumkit_simple)
-        cvpj_l_keynames_data['drumkit_sion'] = idvals.idval2drumkeynames(idvals_drumkit_sion)
 
         bio_mainfile = open(input_file, 'r')
         ceol_data = bio_mainfile.readline().split(',')
@@ -153,13 +148,13 @@ class input_ceol(plugin_input.base):
             cvpj_instcolor = ceol_colors[ceol_inst_palette] if (ceol_inst_palette in ceol_colors) else [0.55, 0.55, 0.55]
 
             if ceol_inst_number <= 127:
-                cvpj_instname = idvals.get_idval(idvals_inst_midi, str(ceol_inst_number), 'name')
+                cvpj_instname, _ = dataset_midi.object_get_name_color('inst', str(ceol_inst_number))
                 inst_plugindata = plugins.cvpj_plugin('midi', 0, ceol_inst_number)
             elif ceol_inst_number == 365: 
                 cvpj_instname = 'MIDI Drums'
                 inst_plugindata = plugins.cvpj_plugin('midi', 128, 0)
             else: 
-                cvpj_instname = idvals.get_idval(idvals_inst_bosca, str(ceol_inst_number), 'name')
+                cvpj_instname, _ = dataset.object_get_name_color('inst', str(ceol_inst_number))
                 valsoundid = idvals.get_idval(idvals_inst_bosca, str(ceol_inst_number), 'valsoundid')
                 if valsoundid not in [None, '']: inst_plugindata = plugins.cvpj_plugin('deftype', 'valsound', valsoundid)
                 else: inst_plugindata = plugins.cvpj_plugin('deftype', 'native-boscaceoil', ceol_inst_number)

plugin_input/mi_flp.py

@@ -25,8 +25,14 @@ from functions_tracks import tracks_mi
 from functions_tracks import fxrack
 from functions_tracks import fxslot
 
+from functions import data_datadef
+from functions import data_dataset
+
 filename_len = {}
 
+stretch_algorithms = ['resample','elastique_v3','elastique_v3_mono','slice_stretch','auto','slice_map','elastique_v2','elastique_v2_transient','elastique_v2_mono','elastique_v2_speech']
+
+
 def getsamplefile(channeldata, flppath):
 
     if 'samplefilename' in channeldata: 
@@ -110,6 +116,9 @@ class input_flp(plugin_input.base):
         global cvpj_l
         FLP_Data = format_flp_dec.parse(input_file)
 
+        datadef = data_datadef.datadef('./data_ddef/fl_studio.ddef')
+        dataset = data_dataset.dataset('./data_dset/fl_studio.dset')
+
         FL_Main = FLP_Data['FL_Main']
         FL_Patterns = FLP_Data['FL_Patterns']
         FL_Channels = FLP_Data['FL_Channels']
@@ -209,7 +218,6 @@ class input_flp(plugin_input.base):
                     plug_exists = None
 
                     if flplugindata != None:
-
                         window_detatched = flplugindata[16]&4
                         window_active = flplugindata[16]&1
                         window_data = struct.unpack('iiii', flplugindata[36:52])
@@ -217,22 +225,17 @@ class input_flp(plugin_input.base):
                         song.add_visual_window(cvpj_l, 'plugin', pluginid, window_data[0:2], window_size, bool(window_active), False)
 
                     if flpluginname != None: 
-                        inst_plugindata = flp_dec_plugins.getparams(cvpj_l, pluginid, flpluginname, flpluginparams, samplefolder)
+                        inst_plugindata = flp_dec_plugins.getparams(cvpj_l, pluginid, flpluginname, flpluginparams, samplefolder, datadef, dataset)
                         inst_plugindata.fileref_add('audiofile', filename_sample)
                         inst_plugindata.to_cvpj(cvpj_l, pluginid)
 
-
-                    #if plug_exists == True:
-                    #    print(channeldata['plugin'])
-
                 tracks_mi.inst_dataval_add(cvpj_l, cvpj_instid, 'poly', 'max', channeldata['polymax'])
 
                 id_inst[str(instrument)] = 'FLInst' + str(instrument)
 
             if channeldata['type'] == 4:
                 cvpj_s_sample = {}
-                if 'name' in channeldata: cvpj_s_sample['name'] = channeldata['name']
-                else: cvpj_s_sample['name'] = ''
+                cvpj_s_sample['name'] = channeldata['name'] if 'name' in channeldata else ''
                 cvpj_s_sample['pan'] = channeldata['pan']
                 cvpj_s_sample['vol'] = channeldata['volume']
                 cvpj_s_sample['color'] = conv_color(channeldata['color'])
@@ -262,31 +265,19 @@ class input_flp(plugin_input.base):
                 if 'stretchingmode' in channeldata: t_stretchingmode = channeldata['stretchingmode']
                 if 'stretchingmultiplier' in channeldata: t_stretchingmultiplier = pow(2, channeldata['stretchingmultiplier']/10000)
 
-                if t_stretchingmode == -1: cvpj_audiomod['stretch_algorithm'] = 'stretch'
-                if t_stretchingmode == 0: cvpj_audiomod['stretch_algorithm'] = 'resample'
-                if t_stretchingmode == 1: cvpj_audiomod['stretch_algorithm'] = 'elastique_v3'
-                if t_stretchingmode == 2: cvpj_audiomod['stretch_algorithm'] = 'elastique_v3_mono'
-                if t_stretchingmode == 3: cvpj_audiomod['stretch_algorithm'] = 'slice_stretch'
-                if t_stretchingmode == 5: cvpj_audiomod['stretch_algorithm'] = 'auto'
-                if t_stretchingmode == 4: cvpj_audiomod['stretch_algorithm'] = 'slice_map'
-                if t_stretchingmode == 6: cvpj_audiomod['stretch_algorithm'] = 'elastique_v2'
-                if t_stretchingmode == 7: cvpj_audiomod['stretch_algorithm'] = 'elastique_v2_transient'
-                if t_stretchingmode == 8: cvpj_audiomod['stretch_algorithm'] = 'elastique_v2_mono'
-                if t_stretchingmode == 9: cvpj_audiomod['stretch_algorithm'] = 'elastique_v2_speech'
+                cvpj_audiomod['stretch_algorithm'] = 'stretch' if t_stretchingmode == -1 else stretch_algorithms[t_stretchingmode]
 
                 #if t_stretchingtime != 0 or t_stretchingmultiplier != 1 or t_stretchingpitch != 0:
 
                 if ald != None:
                     if t_stretchingtime != 0:
                         cvpj_audiomod['stretch_method'] = 'rate_tempo'
-                        cvpj_audiomod['stretch_data'] = {}
-                        cvpj_audiomod['stretch_data']['rate'] = (ald['dur_sec']/t_stretchingtime)/t_stretchingmultiplier
+                        cvpj_audiomod['stretch_data'] = {'rate': (ald['dur_sec']/t_stretchingtime)/t_stretchingmultiplier}
                         samplestretch[instrument] = ['rate_tempo', (ald['dur_sec']/t_stretchingtime)/t_stretchingmultiplier]
 
                     elif t_stretchingtime == 0:
                         cvpj_audiomod['stretch_method'] = 'rate_speed'
-                        cvpj_audiomod['stretch_data'] = {}
-                        cvpj_audiomod['stretch_data']['rate'] = 1/t_stretchingmultiplier
+                        cvpj_audiomod['stretch_data'] = {'rate': 1/t_stretchingmultiplier}
                         samplestretch[instrument] = ['rate_speed', 1/t_stretchingmultiplier]
 
                     else:
@@ -305,8 +296,7 @@ class input_flp(plugin_input.base):
                 for flnote in patterndata['notes']:
                     cvpj_note = {}
                     cvpj_note['position'] = (flnote['pos']/ppq)*4
-                    if str(flnote['rack']) in id_inst: cvpj_note['instrument'] = id_inst[str(flnote['rack'])]
-                    else: cvpj_note['instrument'] = ''
+                    cvpj_note['instrument'] = id_inst[str(flnote['rack'])] if str(flnote['rack']) in id_inst else ''
                     cvpj_note['duration'] = (flnote['dur']/ppq)*4
                     cvpj_note['key'] = flnote['key']-60
                     cvpj_note['finepitch'] = (flnote['finep']-120)*10
@@ -343,8 +333,7 @@ class input_flp(plugin_input.base):
                 id_pat[str(pattern)] = 'FLPat' + str(pattern)
             if 'color' in patterndata:
                 color = patterndata['color'].to_bytes(4, "little")
-                if color != b'HQV\x00':
-                    cvpj_l_notelistindex['FLPat' + str(pattern)]['color'] = [color[0]/255,color[1]/255,color[2]/255]
+                if color != b'HQV\x00': cvpj_l_notelistindex['FLPat' + str(pattern)]['color'] = [color[0]/255,color[1]/255,color[2]/255]
             if 'name' in patterndata: cvpj_l_notelistindex['FLPat' + str(pattern)]['name'] = patterndata['name']
 
         if len(FL_Arrangements) != 0:
@@ -376,15 +365,12 @@ class input_flp(plugin_input.base):
                     arrangementitemJ['fromindex'] = 'FLSample' + str(item['itemindex'])
                     cvpj_l_playlist[str(playlistline)]['placements_audio'].append(arrangementitemJ)
 
-                    if str(item['itemindex']) in samplestretch: pl_stretch = samplestretch[str(item['itemindex'])]
-                    else: pl_stretch = ['rate_speed', 1.0]
+                    pl_stretch = samplestretch[str(item['itemindex'])] if str(item['itemindex']) in samplestretch else ['rate_speed', 1.0]
 
                     if 'startoffset' in item or 'endoffset' in item:
                         arrangementitemJ['cut'] = {}
                         arrangementitemJ['cut']['type'] = 'cut'
 
-                        #print(pl_stretch)
-  
                         if pl_stretch[0] == 'rate_speed':
                             if 'startoffset' in item: arrangementitemJ['cut']['start'] = (item['startoffset']/pl_stretch[1])/tempomul
                             if 'endoffset' in item: arrangementitemJ['cut']['end'] = (item['endoffset']/pl_stretch[1])/tempomul
@@ -393,32 +379,16 @@ class input_flp(plugin_input.base):
                             if 'endoffset' in item: arrangementitemJ['cut']['end'] = (item['endoffset']/pl_stretch[1])
                         if 'startoffset' not in item: arrangementitemJ['cut']['start'] = 0
 
-                    #for value in ['startoffset', 'endoffset']:
-                    #    outprint = None
-                    #    if value in item: outprint = round(item[value], 6)
-                    #    print(str(outprint).ljust(13), end=' ')
-                    #print(pl_stretch)
-
             FL_Tracks = FL_Arrangement['tracks']
 
             if len(FL_Tracks) != 0:
                 for track in FL_Tracks:
                     #print(track, FL_Tracks[track])
-                    if str(track) not in cvpj_l_playlist:
-                        cvpj_l_playlist[str(track)] = {}
-                    if 'color' in FL_Tracks[track]:
-                        cvpj_l_playlist[str(track)]['color'] = conv_color(FL_Tracks[track]['color'])
-                    if 'name' in FL_Tracks[track]:
-                        cvpj_l_playlist[str(track)]['name'] = FL_Tracks[track]['name']
-                    if 'height' in FL_Tracks[track]:
-                        cvpj_l_playlist[str(track)]['size'] = FL_Tracks[track]['height']
-                    if 'enabled' in FL_Tracks[track]:
-                        cvpj_l_playlist[str(track)]['enabled'] = FL_Tracks[track]['enabled']
-
-
-        #for hexnum in FL_InitFXVals:
-        #    print(hexnum, FL_InitFXVals[test][0])
-
+                    if str(track) not in cvpj_l_playlist: cvpj_l_playlist[str(track)] = {}
+                    if 'color' in FL_Tracks[track]: cvpj_l_playlist[str(track)]['color'] = conv_color(FL_Tracks[track]['color'])
+                    if 'name' in FL_Tracks[track]: cvpj_l_playlist[str(track)]['name'] = FL_Tracks[track]['name']
+                    if 'height' in FL_Tracks[track]: cvpj_l_playlist[str(track)]['size'] = FL_Tracks[track]['height']
+                    if 'enabled' in FL_Tracks[track]: cvpj_l_playlist[str(track)]['enabled'] = FL_Tracks[track]['enabled']
 
         for fxchannel in FL_Mixer:
             fl_fx_chan = FL_Mixer[str(fxchannel)]
@@ -459,8 +429,7 @@ class input_flp(plugin_input.base):
 
                             fx_plugindata = None
                             if 'pluginparams' in fl_fxslotdata: 
-                                fx_plugindata = flp_dec_plugins.getparams(cvpj_l, fxslotid, flpluginname, fl_fxslotdata['pluginparams'], samplefolder)
-
+                                fx_plugindata = flp_dec_plugins.getparams(cvpj_l, fxslotid, flpluginname, fl_fxslotdata['pluginparams'], samplefolder, datadef, dataset)
                             if fx_plugindata != None:
                                 v_name = fl_fxslotdata["name"] if "name" in fl_fxslotdata else None
                                 v_color = None

plugin_input/mi_jummbox.py

@@ -184,7 +184,7 @@ def parse_instrument(channum, instnum, bb_instrument, bb_type, bb_color, bb_inst
 
 		if bb_inst_type == 'chip':
 			bb_inst_wave = bb_instrument['wave']
-			cvpj_instname = bb_inst_wave+' ('+cvpj_instname+')'
+			cvpj_instname = bb_inst_wave+' ('+cvpj_instname+')' if cvpj_instname != None else bb_inst_wave+' ('+bb_inst_type+')'
 			if bb_inst_wave in rawChipWaves:
 				wavesample = rawChipWaves[bb_inst_wave]['samples']
 				inst_plugindata.wave_add('chipwave', wavesample, min(wavesample), max(wavesample))

plugin_input/mi_notessimo_v3.py

@@ -342,13 +342,16 @@ class input_notessimo_v3(plugin_input.base):
                 tracks_mi.inst_visual(cvpj_l, cvpj_instid, name=inst_name, color=inst_color)
             else: tracks_mi.inst_visual(cvpj_l, cvpj_instid, name='noname ('+inst+')', color=[0.3,0.3,0.3])
 
-            if inst_found: tracks_mi.inst_visual(cvpj_l, cvpj_instid, color=colors.moregray(outdsd[5]))
+            if outdsd[5] != None: colors.moregray(outdsd[5])
+            
+            if inst_found: 
+                tracks_mi.inst_visual(cvpj_l, cvpj_instid, color=outdsd[5])
 
             if outdsd[3]: 
                 tracks_mi.inst_fxrackchan_add(cvpj_l, cvpj_instid, 1)
             else:
                 tracks_mi.inst_fxrackchan_add(cvpj_l, cvpj_instid, 1)
-                fxrack.add(cvpj_l, fxnum, 1, 0, name=outdsd[4], color=colors.moregray(outdsd[5]))
+                fxrack.add(cvpj_l, fxnum, 1, 0, name=outdsd[4], color=outdsd[5])
                 fxnum += 1
 
         song.add_param(cvpj_l, 'bpm', 120)

plugin_input/r_amped.py

@@ -98,6 +98,8 @@ def encode_devices(amped_tr_devices, trackid, amped_autodata):
             europa_xml = ET.fromstring(wampreset['settings'])
             europa_xml_prop = europa_xml.findall('Properties')[0]
 
+            europa_params = {}
+
             for xmlsub in europa_xml_prop:
                 if xmlsub.tag == 'Object':
                     object_name = xmlsub.get('name')
@@ -106,14 +108,19 @@ def encode_devices(amped_tr_devices, trackid, amped_autodata):
                             value_name = objsub.get('property')
                             value_type = objsub.get('type')
                             value_value = float(objsub.text) if value_type == 'number' else objsub.text
+                            europa_params[value_name] = [value_type, value_value]
 
-                            if value_type == 'number': 
-                                device_plugindata.param_add_dset(value_name, value_value, dataset_synth_nonfree, 'plugin', 'europa')
-                            else:
-                                if value_name in ['Curve1','Curve2','Curve3','Curve4','Curve']: 
-                                    value_value = list(bytes.fromhex(value_value))
+            paramlist = dataset_synth_nonfree.params_list('plugin', 'europa')
+            for paramname in paramlist:
+                dset_paramdata = dataset_synth_nonfree.params_i_get('plugin', 'europa', paramname)
+                if dset_paramdata[5] in europa_params:
+                    s_paramdata = europa_params[dset_paramdata[5]]
 
-                                device_plugindata.dataval_add(value_name, value_value)
+                    if s_paramdata[0] == 'number': 
+                        device_plugindata.param_add_dset(paramname, s_paramdata[1], dataset_synth_nonfree, 'plugin', 'europa')
+                    else:
+                        if value_name in ['Curve1','Curve2','Curve3','Curve4','Curve']: value_value = list(bytes.fromhex(value_value))
+                        device_plugindata.dataval_add(paramname, s_paramdata[1])
 
             if 'encodedSampleData' in wampreset:
                 europa_sampledata = wampreset['encodedSampleData']

plugin_input/r_audiosauna.py

@@ -207,7 +207,8 @@ class input_audiosanua(plugin_input.base):
 
             cvpj_pldata = placement_data.makepl_n(as_pattern_startTick/32, (as_pattern_endTick-as_pattern_startTick)/32, [])
             cvpj_pldata['cut'] = {'type': 'cut', 'start': 0, 'end': as_pattern_patternLength/32}
-            cvpj_pldata['color'] = colordata.getcolornum(as_pattern_patternColor)
+            plcolor = colordata.getcolornum(as_pattern_patternColor)
+            if plcolor: cvpj_pldata['color'] = plcolor
 
             if as_pattern_patternId in as_patt_notes:
                 t_notelist = as_patt_notes[as_pattern_patternId]

plugin_input/r_lmms.py

@@ -18,6 +18,7 @@ from functions import colors
 from functions import auto
 from functions import plugins
 from functions import song
+from functions import plugin_vst2
 from functions_tracks import auto_id
 from functions_tracks import auto_nopl
 from functions_tracks import fxrack
@@ -122,6 +123,9 @@ def getvstparams(cvpj_plugindata, pluginid, xmldata):
         cvpj_plugindata.dataval_add('path', xmldata.get('plugin'))
     else:
         cvpj_plugindata.dataval_add('path', lmms_vstpath+xmldata.get('plugin'))
+
+
+
     vst_data = xmldata.get('chunk')
     vst_numparams = xmldata.get('numparams')
     vst_program = xmldata.get('program')
@@ -132,9 +136,12 @@ def getvstparams(cvpj_plugindata, pluginid, xmldata):
 
     if vst_program != None: 
         cvpj_plugindata.dataval_add('current_program', int(vst_program))
+
     if vst_data != None:
         cvpj_plugindata.dataval_add('datatype', 'chunk')
-        cvpj_plugindata.dataval_add('chunk', vst_data)
+        cvpj_plugindata.rawdata_add(vst_data)
+        plugin_vst2.replace_data(cvpj_plugindata, 'path', 'win', xmldata.get('plugin'), 'chunk', vst_data, None)
+
     elif vst_numparams != None:
         cvpj_plugindata.dataval_add('datatype', 'param')
         cvpj_plugindata.dataval_add('numparams', int(vst_numparams))
@@ -142,6 +149,7 @@ def getvstparams(cvpj_plugindata, pluginid, xmldata):
             paramdata = xmldata.get('param'+str(param)).split(':')
             paramnum = 'vst_param_'+str(param)
             cvpj_plugindata.param_add(paramnum, float(paramdata[-1]), 'float', paramdata[1])
+
     for node in xmldata.iter():
         notetagtxt = node.tag
         if notetagtxt.startswith('param'):
@@ -435,7 +443,7 @@ def lmms_decode_inst_track(trkX, trackid):
     plug_color, pluginname, instpluginid = lmms_decodeplugin(trkX_insttr)
     track_color = trkX.get('color')
     if track_color == None: track_color = plug_color
-    else: track_color = track_color = colors.hex_to_rgb_float(track_color)
+    else: track_color = colors.hex_to_rgb_float(track_color)
     add_window_data(trkX, cvpj_l, 'plugin', instpluginid)
     cvpj_pan = float(lmms_auto_getvalue(trkX_insttr, 'pan', 0, 'float', [0, 0.01], ['track', trackid, 'pan']))
     cvpj_vol = float(lmms_auto_getvalue(trkX_insttr, 'vol', 100, 'float', [0, 0.01], ['track', trackid, 'vol']))

plugin_input/r_soundation.py

@@ -244,13 +244,14 @@ class input_soundation(plugin_input.base):
                     elif instpluginname == 'com.soundation.europa':
                         inst_plugindata = plugins.cvpj_plugin('deftype', 'synth-nonfree', 'europa')
                         paramlist = dataset_synth_nonfree.params_list('plugin', 'europa')
-                        for paramid in paramlist:
-                            outval = None
-                            param = dataset_synth_nonfree.params_i_get('plugin', 'europa', paramid)
-                            sng_paramid = "/custom_properties/"+param[5]
-                            if sng_paramid in sound_instdata:
-                                if 'value' in sound_instdata[sng_paramid]: outval = sound_instdata[sng_paramid]['value']
-                            inst_plugindata.param_add_dset(paramid, outval, dataset_synth_nonfree, 'plugin', 'europa')
+                        if paramlist:
+                            for paramid in paramlist:
+                                outval = None
+                                param = dataset_synth_nonfree.params_i_get('plugin', 'europa', paramid)
+                                sng_paramid = "/custom_properties/"+param[5]
+                                if sng_paramid in sound_instdata:
+                                    if 'value' in sound_instdata[sng_paramid]: outval = sound_instdata[sng_paramid]['value']
+                                inst_plugindata.param_add_dset(paramid, outval, dataset_synth_nonfree, 'plugin', 'europa')
 
                     elif instpluginname == 'com.soundation.GM-2':
                         inst_plugindata = plugins.cvpj_plugin('deftype', 'native-soundation', instpluginname)
@@ -271,11 +272,13 @@ class input_soundation(plugin_input.base):
                     elif instpluginname in ['com.soundation.fm_synth', 'com.soundation.mono', 'com.soundation.spc', 'com.soundation.supersaw', 'com.soundation.the_wub_machine', 'com.soundation.va_synth']:
                         inst_plugindata = plugins.cvpj_plugin('deftype', 'native-soundation', instpluginname)
                         paramlist = dataset.params_list('plugin', instpluginname)
-                        for paramid in paramlist:
-                            outval = None
-                            if paramid in sound_instdata:
-                                if 'value' in sound_instdata[paramid]: outval = sound_instdata[paramid]['value']
-                            inst_plugindata.param_add_dset(paramid, outval, dataset, 'plugin', instpluginname)
+
+                        if paramlist:
+                            for paramid in paramlist:
+                                outval = None
+                                if paramid in sound_instdata:
+                                    if 'value' in sound_instdata[paramid]: outval = sound_instdata[paramid]['value']
+                                inst_plugindata.param_add_dset(paramid, outval, dataset, 'plugin', instpluginname)
 
                         if instpluginname == 'com.soundation.spc':
                             inst_plugindata.dataval_add('cuts', sound_instdata['cuts'])
@@ -350,6 +353,15 @@ class input_soundation(plugin_input.base):
                     master_gain = (master_gain-0.5)*40
                     fx_plugindata.param_add('gain_out', master_gain, 'float', 'Out Gain')
 
+                elif fxpluginname == 'com.soundation.filter':
+                    filterfx_cutoff = 20 * 1000**get_paramval(sound_chan_effect, 'cutoff')[0]
+                    filterfx_resonance = get_paramval(sound_chan_effect, 'resonance')[0]
+                    filterfx_mode = get_paramval(sound_chan_effect, 'mode')[0]
+                    fx_plugindata = plugins.cvpj_plugin('deftype', 'universal', 'eq-bands')
+                    eq_bandtype = 'low_pass' if filterfx_mode == 0 else 'high_pass'
+                    band_res = eq_calc_q(eq_bandtype, filterfx_resonance)
+                    fx_plugindata.eqband_add(1, 20*(1000**filterfx_cutoff), 0, eq_bandtype, band_res, None)
+
                 else:
                     fx_plugindata = plugins.cvpj_plugin('deftype', 'native-soundation', fxpluginname)
                     fx_plugindata.fxdata_add(fxenabled, 1)

plugin_input/rm_adlib_rol.py

@@ -206,8 +206,10 @@ class input_adlib_rol(plugin_input.base):
                     fmdata.to_cvpj(cvpj_l, instname_upper)
                     
         else:
-            for instid in dataset.midito_list('inst'):
-                tracks_rm.import_dset(cvpj_l, instid, instid, dataset, dataset_midi, None, None)
+            miditolist = dataset.midito_list('inst')
+            if miditolist:
+                for instid in miditolist:
+                    tracks_rm.import_dset(cvpj_l, instid, instid, dataset, dataset_midi, None, None)
 
         rol_header_majorVersion = int.from_bytes(song_file.read(2), 'little')
         print("[input-adlib_rol] majorVersion: " + str(rol_header_majorVersion))

plugin_input/rm_lovelycomposer.py

@@ -252,7 +252,7 @@ def lc_parse_placements(sl_json, tracknum, pl_color, ischord):
         else: notelist, currentchord = lc_parse_voice_chords(lc_notes, length, currentchord)
 
         placement = placement_data.makepl_n(position, length, notelist)
-        placement['color'] = pl_color
+        if pl_color != None: placement['color'] = pl_color
         if notelist != []: placements.append(placement)
         patternpos.append(position)
         patternlen.append(length)

plugin_output/amped_studio.py

@@ -517,7 +517,7 @@ class output_cvpj_f(plugin_output.base):
                         vstdatatype = cvpj_plugindata.dataval_get('datatype', '')
                         if vstdatatype == 'chunk':
                             vstcondata['pluginPath'] = cvpj_plugindata.dataval_get('path', 'path')
-                            vstcondata['pluginState'] = cvpj_plugindata.dataval_get('chunk', '')
+                            vstcondata['pluginState'] = cvpj_plugindata.rawdata_get()
                         amped_trackdata["devices"].append(vstcondata)
 
             if inst_supported == False:

plugin_output/debug_plugdata.py

@@ -0,0 +1,99 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import plugin_output
+import json
+from functions import plugins
+
+class output_cvpj(plugin_output.base):
+    def __init__(self): pass
+    def is_dawvert_plugin(self): return 'output'
+    def getname(self): return 'debug_plugdata'
+    def getshortname(self): return 'debug_plugdata'
+    def gettype(self): return 'debug'
+    def plugin_archs(self): return None
+    def getdawcapabilities(self): 
+        return {
+        'fxrack': 'debug',
+        'track_lanes': 'debug',
+        'placement_cut': 'debug',
+        'placement_loop': 'debug',
+        'track_nopl': 'debug',
+        'auto_nopl': 'debug',
+        'placement_audio_events': 'debug',
+        'placement_audio_stretch': ['warp', 'rate']
+        }
+    def getsupportedplugformats(self): return ['vst2', 'vst3', 'clap', 'ladspa']
+    def getsupportedplugins(self): return ['sampler:single', 'sampler:multi', 'sampler:slicer', 'soundfont2']
+    def getfileextension(self): return 'nothing'
+    def parse(self, convproj_json, output_file):
+        cvpj_l = json.loads(convproj_json)
+
+        if 'plugins' in cvpj_l:
+            for pluginid in cvpj_l['plugins']:
+                cvpj_plugindata = plugins.cvpj_plugin('cvpj', cvpj_l, pluginid)
+
+                plugintype = cvpj_plugindata.type_get()
+                print()
+                print(pluginid,'-------------------------------',':'.join([str(x) for x in plugintype]))
+
+
+                i_enabled, i_wet = cvpj_plugindata.fxdata_get()
+                if i_enabled != True or i_wet != 1: print('\t\t FX Data:',i_enabled, i_wet)
+
+
+                param_list = cvpj_plugindata.param_list()
+                if param_list: 
+                    print('\t\t Params:',', '.join(param_list))
+                    for pid in param_list:
+                        param_mm = cvpj_plugindata.param_get_minmax(pid, None)
+                        #print(param_mm)
+                        if param_mm[3] != None: 
+                            if param_mm[0] < param_mm[3]: 
+                                print(pid+': '+str(param_mm[0])+" is lower then "+str(param_mm[3]))
+                        if param_mm[4] != None: 
+                            if param_mm[0] > param_mm[4]: 
+                                print(pid+': '+str(param_mm[0])+" is higher then "+str(param_mm[4]))
+
+
+                dataval_list = cvpj_plugindata.dataval_list()
+                if dataval_list: print('\t\t DataVals:',', '.join(dataval_list))
+
+
+                asdr_env_list = cvpj_plugindata.asdr_env_list()
+                if asdr_env_list: print('\t\t Env ASDR:',', '.join(asdr_env_list))
+
+
+                env_points_list = cvpj_plugindata.env_points_list()
+                if env_points_list: print('\t\t Env Points:',', '.join(env_points_list))
+
+
+                env_blocks_list = cvpj_plugindata.env_blocks_list()
+                if env_blocks_list: print('\t\t Env Blocks:',', '.join(env_blocks_list))
+
+
+                plug_filter = cvpj_plugindata.filter_get()
+                if plug_filter != (0, 44100, 0, None, None): print('\t\t Filter:',plug_filter)
+
+
+                lfo_list = cvpj_plugindata.lfo_list()
+                if lfo_list: print('\t\t LFOs:',', '.join(lfo_list))
+
+
+                eqbands = cvpj_plugindata.eqband_get(None)
+                if eqbands: print('\t\t EQ Bands:',len(eqbands))
+
+
+                harmonics = cvpj_plugindata.harmonics_list()
+                if harmonics: print('\t\t Harmonics:',len(harmonics))
+
+
+                wavedata = cvpj_plugindata.wave_list()
+                if wavedata: print('\t\t Waves:',len(wavedata))
+
+
+                waveable = cvpj_plugindata.wavetable_list()
+                if waveable: print('\t\t Wavetable:',len(waveable))
+
+
+

plugin_output/flp.py

@@ -19,6 +19,9 @@ from functions import params
 from functions import song
 from functions_tracks import tracks_mi
 
+from functions import data_datadef
+from functions import data_dataset
+
 filename_len = {}
 
 def decode_color(color):
@@ -45,6 +48,9 @@ class output_cvpjs(plugin_output.base):
     def parse(self, convproj_json, output_file):
         cvpj_l = json.loads(convproj_json)
 
+        datadef = data_datadef.datadef('./data_ddef/fl_studio.ddef')
+        dataset = data_dataset.dataset('./data_dset/fl_studio.dset')
+
         FLP_Data = {}
 
         FLP_Data['FL_Main'] = {}
@@ -170,7 +176,7 @@ class output_cvpjs(plugin_output.base):
                     inst_plugdata = plugins.cvpj_plugin('cvpj', cvpj_l, pluginid)
                     plugintype = inst_plugdata.type_get()
 
-                    fl_plugin, fl_pluginparams = flp_enc_plugins.setparams(inst_plugdata)
+                    fl_plugin, fl_pluginparams = flp_enc_plugins.setparams(inst_plugdata, datadef, dataset)
 
                     if plugintype == ['sampler', 'single']:
                         T_Main['type'] = 0
@@ -502,7 +508,7 @@ class output_cvpjs(plugin_output.base):
                     for pluginid in cvpj_fxdata['chain_fx_audio']:
 
                         fx_plugdata = plugins.cvpj_plugin('cvpj', cvpj_l, pluginid)
-                        fl_plugin, fl_pluginparams = flp_enc_plugins.setparams(fx_plugdata)
+                        fl_plugin, fl_pluginparams = flp_enc_plugins.setparams(fx_plugdata, datadef, dataset)
                         if fl_plugin != None:
                             FL_Mixer[cvpj_fx]['slots'][slotnum] = {}
                             slotdata = FL_Mixer[cvpj_fx]['slots'][slotnum]

plugin_output/lmms.py

@@ -156,7 +156,7 @@ def setvstparams(cvpj_plugindata, pluginid, xmldata):
                 xmldata.set('param'+str(param), str(param)+':noname:'+str(pval) )
 
     if datatype == 'chunk':
-        xmldata.set('chunk', cvpj_plugindata.dataval_get('chunk', ''))
+        xmldata.set('chunk', cvpj_plugindata.rawdata_get_b64())
 
     if datatype == 'param':
         xmldata.set('numparams', str(numparams))
@@ -635,7 +635,8 @@ def lmms_encode_inst_track(xmltag, trkJ, trackid, trkplacementsJ):
                 patX.set('steps', "16")
                 patX.set('name', json_placement['name'] if 'name' in json_placement else "" )
                 patX.set('type', "1")
-                if 'color' in json_placement: patX.set('color', '#' + colors.rgb_float_to_hex(json_placement['color']))
+                if 'color' in json_placement: 
+                    patX.set('color', '#' + colors.rgb_float_to_hex(json_placement['color']))
                 lmms_encode_notelist(patX, json_notelist)
                 tracksnum += 1
             print(' ')

plugin_output/reaper.py

@@ -26,10 +26,9 @@ def make_vst2(rpp_fxchain, cvpj_plugindata):
     vst_fx_fourid = cvpj_plugindata.dataval_get('fourid', None)
     vst_fx_datatype = cvpj_plugindata.dataval_get('datatype', None)
     vst_fx_numparams = cvpj_plugindata.dataval_get('numparams', 0)
-    vst_fx_chunk = cvpj_plugindata.dataval_get('chunk', None)
 
     if vst_fx_datatype == 'chunk': 
-        vstparams = base64.b64decode(vst_fx_chunk.encode())
+        vstparams = cvpj_plugindata.rawdata_get()
     if vst_fx_datatype == 'param': 
         floatdata = []
         for num in range(vst_fx_numparams):
@@ -136,9 +135,8 @@ def convert_placementdata(rpp_trackdata, trackplacements, cliptype, track_uuid):
         if 'audiomod' in trackplacement_data:
             audiomoddata = trackplacement_data['audiomod']
             #print(audiomoddata)
-            if 'pitch' in audiomoddata: pitch = audiomoddata['pitch']
-
-            stretch_algorithm = audiomoddata['stretch_algorithm']
+            pitch = audiomoddata['pitch'] if 'pitch' in audiomoddata else 0
+            stretch_algorithm = audiomoddata['stretch_algorithm'] if 'stretch_algorithm' in audiomoddata else 'stretch'
 
             if stretch_algorithm != 'resample': preserve_pitch = 1
 

plugin_plugconv/flstudio__n_lmms.py

@@ -3,7 +3,6 @@
 
 import plugin_plugconv
 
-import base64
 import struct
 import os
 import math
@@ -18,10 +17,10 @@ class plugconv(plugin_plugconv.base):
         if plugintype[1] == 'stereomatrix':  
             print('[plug-conv] LMMS to FL Studio: Stereo Matrix > Fruity Stereo Shaper:',pluginid)
 
-            fl_r_l = cvpj_plugindata.param_get('r-l', 0)*12800
-            fl_l_l = cvpj_plugindata.param_get('l-l', 0)*12800
-            fl_r_r = cvpj_plugindata.param_get('r-r', 0)*12800
-            fl_l_r = cvpj_plugindata.param_get('l-r', 0)*12800
+            fl_r_l = cvpj_plugindata.param_get('r-l', 0)[0]*12800
+            fl_l_l = cvpj_plugindata.param_get('l-l', 0)[0]*12800
+            fl_r_r = cvpj_plugindata.param_get('r-r', 0)[0]*12800
+            fl_l_r = cvpj_plugindata.param_get('l-r', 0)[0]*12800
 
             cvpj_plugindata.replace('native-flstudio', 'fruity stereo shaper')
             cvpj_plugindata.param_add('r2l', fl_r_l, 'int', "")

plugin_plugconv/lmms__n_beepbox.py

@@ -3,7 +3,7 @@
 
 import os
 import plugin_plugconv
-from functions_plugparams import wave
+from functions_plugdata import data_wave
 
 class plugconv(plugin_plugconv.base):
 	def __init__(self): pass
@@ -19,8 +19,8 @@ class plugconv(plugin_plugconv.base):
 			os.makedirs(samplefolder, exist_ok=True)
 			wave_path = os.path.join(samplefolder, pluginid+'_wave.wav')
 
-			if plugintype[1] in ['custom chip', 'chip']: wave.wave2file(cvpj_plugindata, 'chipwave', wave_path)
-			if plugintype[1] in ['harmonics']: wave.harm2file(cvpj_plugindata, 'harmonics', wave_path)
+			if plugintype[1] in ['custom chip', 'chip']: data_wave.wave2file(cvpj_plugindata, 'chipwave', wave_path)
+			if plugintype[1] in ['harmonics']: data_wave.harm2file(cvpj_plugindata, 'harmonics', wave_path)
 
 			cvpj_plugindata.replace('native-lmms', 'tripleoscillator')
 

plugin_plugconv/vst2__i_opl2.py

@@ -1,65 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import plugin_plugconv
-from functions_plugdata import plugin_adlplug
-
-def getparam(paramname):
-    global cvpj_plugindata_g
-    return cvpj_plugindata_g.param_get(paramname, 0)[0]
-
-opadltxt = ['m1', 'c1', 'm2', 'c2']
-
-class plugconv(plugin_plugconv.base):
-    def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['fm', 'opl2', None], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
-        print('[plug-conv] Converting OPL2 to ADLplug:',pluginid)
-
-        global cvpj_plugindata_g   
-        cvpj_plugindata_g = cvpj_plugindata
-
-        adlplug_data = plugin_adlplug.adlplug_data(cvpj_plugindata)
-
-        adlplug_data.set_param("four_op" ,0)  
-        adlplug_data.set_param("pseudo_four_op" ,0)   
-        adlplug_data.set_param("blank" ,0)    
-        adlplug_data.set_param("con12" ,getparam('fm'))
-        adlplug_data.set_param("con34" ,0)    
-        adlplug_data.set_param("note_offset1" ,0)
-        adlplug_data.set_param("note_offset2" ,0)
-        adlplug_data.set_param("fb12" ,getparam("feedback"))  
-        adlplug_data.set_param("fb34" ,0) 
-        adlplug_data.set_param("midi_velocity_offset" ,0) 
-        adlplug_data.set_param("second_voice_detune" ,0)  
-        adlplug_data.set_param("percussion_key_number" ,0)
-    
-        for opnplugopname, cvpjopname in [['m1', 'op1'], ['c1', 'op2'], ['m2', ''], ['c2', '']]:  
-            adlplug_data.set_param(opnplugopname+"attack" ,(getparam(cvpjopname+"_env_attack")*-1)+15)    
-            adlplug_data.set_param(opnplugopname+"decay" ,(getparam(cvpjopname+"_env_decay")*-1)+15)  
-            adlplug_data.set_param(opnplugopname+"sustain" ,(getparam(cvpjopname+"_env_sustain")*-1)+15)
-            adlplug_data.set_param(opnplugopname+"release" ,(getparam(cvpjopname+"_env_release")*-1)+15)  
-            adlplug_data.set_param(opnplugopname+"level" ,(getparam(cvpjopname+"_level")*-1)+63)  
-            adlplug_data.set_param(opnplugopname+"ksl" ,getparam(cvpjopname+"_ksl"))
-            adlplug_data.set_param(opnplugopname+"fmul" ,getparam(cvpjopname+"_freqmul")) 
-            adlplug_data.set_param(opnplugopname+"trem" ,getparam(cvpjopname+"_tremolo")) 
-            adlplug_data.set_param(opnplugopname+"vib" ,getparam(cvpjopname+"_vibrato"))  
-            adlplug_data.set_param(opnplugopname+"sus" ,getparam(cvpjopname+"_sustained"))
-            adlplug_data.set_param(opnplugopname+"env" ,getparam(cvpjopname+"_ksr"))
-            adlplug_data.set_param(opnplugopname+"wave" ,getparam(cvpjopname+"_waveform"))
-    
-        adlplug_data.set_param("delay_off_ms" ,160)   
-        adlplug_data.set_param("delay_on_ms" ,386)    
-        adlplug_data.set_param("bank" ,0) 
-        adlplug_data.set_param("program" ,0)  
-        adlplug_data.set_param("name" ,'')
-    
-        adlplug_data.add_selection(0, 0, 0)
-        adlplug_data.adlplug_chip(2, 2, 0)
-        adlplug_data.adlplug_global(0, getparam("tremolo_depth"), getparam("vibrato_depth"))
-    
-        adlplug_data.add_common('DawVert', 0, 1.0)
-    
-        adlplug_data.adlplug_to_cvpj_vst2()
-        return True

plugin_plugconv/vst2__i_opl3.py

@@ -1,65 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import plugin_plugconv
-from functions_plugdata import plugin_adlplug
-
-def getparam(paramname):
-    global cvpj_plugindata_g
-    return cvpj_plugindata_g.param_get(paramname, 0)[0]
-
-opadltxt = ['m1', 'c1', 'm2', 'c2']
-
-class plugconv(plugin_plugconv.base):
-    def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['fm', 'opl3', None], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
-        print('[plug-conv] Converting OPL3 to ADLplug:',pluginid)
-
-        global cvpj_plugindata_g   
-        cvpj_plugindata_g = cvpj_plugindata
-
-        adlplug_data = plugin_adlplug.adlplug_data(cvpj_plugindata)
-
-        adlplug_data.set_param("four_op" ,1)  
-        adlplug_data.set_param("pseudo_four_op" ,0)   
-        adlplug_data.set_param("blank" ,0)    
-        adlplug_data.set_param("con12" ,getparam('con_12'))
-        adlplug_data.set_param("con34" ,getparam('con_34'))
-        adlplug_data.set_param("note_offset1" ,0) 
-        adlplug_data.set_param("note_offset2" ,0) 
-        adlplug_data.set_param("fb12" ,getparam('feedback_12'))
-        adlplug_data.set_param("fb34" ,getparam('feedback_34'))
-        adlplug_data.set_param("midi_velocity_offset" ,0) 
-        adlplug_data.set_param("second_voice_detune" ,0)  
-        adlplug_data.set_param("percussion_key_number" ,0)
-    
-        for opnplugopname, cvpjopname in [['m1', 'op1'], ['c1', 'op2'], ['m2', 'op3'], ['c2', 'op4']]:  
-            adlplug_data.set_param(opnplugopname+"attack" ,(getparam(cvpjopname+"_env_attack")*-1)+15)    
-            adlplug_data.set_param(opnplugopname+"decay" ,(getparam(cvpjopname+"_env_decay")*-1)+15)  
-            adlplug_data.set_param(opnplugopname+"sustain" ,(getparam(cvpjopname+"_env_sustain")*-1)+15)
-            adlplug_data.set_param(opnplugopname+"release" ,(getparam(cvpjopname+"_env_release")*-1)+15)  
-            adlplug_data.set_param(opnplugopname+"level" ,(getparam(cvpjopname+"_level")*-1)+63)  
-            adlplug_data.set_param(opnplugopname+"ksl" ,getparam(cvpjopname+"_ksl"))
-            adlplug_data.set_param(opnplugopname+"fmul" ,getparam(cvpjopname+"_freqmul")) 
-            adlplug_data.set_param(opnplugopname+"trem" ,getparam(cvpjopname+"_tremolo")) 
-            adlplug_data.set_param(opnplugopname+"vib" ,getparam(cvpjopname+"_vibrato"))  
-            adlplug_data.set_param(opnplugopname+"sus" ,getparam(cvpjopname+"_sustained"))
-            adlplug_data.set_param(opnplugopname+"env" ,getparam(cvpjopname+"_ksr"))
-            adlplug_data.set_param(opnplugopname+"wave" ,getparam(cvpjopname+"_waveform"))
-    
-        adlplug_data.set_param("delay_off_ms" ,160)   
-        adlplug_data.set_param("delay_on_ms" ,386)    
-        adlplug_data.set_param("bank" ,0) 
-        adlplug_data.set_param("program" ,0)  
-        adlplug_data.set_param("name" ,'')
-    
-        adlplug_data.add_selection(0, 0, 0)
-        adlplug_data.adlplug_chip(2, 2, 1)
-        adlplug_data.adlplug_global(0, getparam("tremolo_depth"), getparam("vibrato_depth"))
-    
-        adlplug_data.add_common('DawVert', 0, 1.0)
-
-        adlplug_data.adlplug_to_cvpj_vst2()
-        return True

plugin_plugconv/vst2__i_opn2.py

@@ -1,60 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import plugin_plugconv
-from functions_plugdata import plugin_adlplug
-
-def getparam(paramname):
-    global cvpj_plugindata_g
-    return cvpj_plugindata_g.param_get(paramname, 0)[0]
-
-class plugconv(plugin_plugconv.base):
-    def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['fm', 'opn2', None], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
-        print('[plug-conv] OPN2 > OPNPlug:',pluginid)
-    
-        global cvpj_plugindata_g   
-        cvpj_plugindata_g = cvpj_plugindata
-
-        adlplug_data = plugin_adlplug.adlplug_data(cvpj_plugindata)
-  
-        adlplug_data.set_param("blank" ,0)    
-        adlplug_data.set_param("note_offset" ,0)  
-        adlplug_data.set_param("feedback" ,getparam('feedback'))  
-        adlplug_data.set_param("algorithm" ,getparam('algorithm'))    
-        adlplug_data.set_param("ams" ,getparam('ams'))    
-        adlplug_data.set_param("fms" ,getparam('fms'))    
-        adlplug_data.set_param("midi_velocity_offset" ,0) 
-        adlplug_data.set_param("percussion_key_number" ,0)
-    
-        for opnum in range(4):  
-            optxt = "op"+str(opnum+1)   
-            adlplug_data.set_param(optxt+"detune" ,getparam(optxt+"_detune")) 
-            adlplug_data.set_param(optxt+"fmul" ,getparam(optxt+"_freqmul"))  
-            adlplug_data.set_param(optxt+"level" ,getparam(optxt+"_level"))   
-            adlplug_data.set_param(optxt+"ratescale" ,getparam(optxt+"_ratescale"))   
-            adlplug_data.set_param(optxt+"attack" ,getparam(optxt+"_env_attack")) 
-            adlplug_data.set_param(optxt+"am" ,getparam(optxt+"_am")) 
-            adlplug_data.set_param(optxt+"decay1" ,getparam(optxt+"_env_decay"))  
-            adlplug_data.set_param(optxt+"decay2" ,getparam(optxt+"_env_decay2")) 
-            adlplug_data.set_param(optxt+"sustain" ,getparam(optxt+"_env_sustain"))   
-            adlplug_data.set_param(optxt+"release" ,getparam(optxt+"_env_release"))   
-            adlplug_data.set_param(optxt+"ssgenable" ,getparam(optxt+"_ssg_enable"))  
-            adlplug_data.set_param(optxt+"ssgwave" ,getparam(optxt+"_ssg_mode"))
-    
-        adlplug_data.set_param("delay_off_ms" ,120)   
-        adlplug_data.set_param("delay_on_ms" ,486)    
-        adlplug_data.set_param("bank" ,0) 
-        adlplug_data.set_param("program" ,0)  
-        adlplug_data.set_param("name" ,'DawVert')
-
-        adlplug_data.add_selection(0, 0, 0)
-        adlplug_data.opnplug_chip(0, 1, 0)
-        adlplug_data.opnplug_global(0, getparam("lfo_enable"), getparam("lfo_frequency"))
-
-        adlplug_data.add_common('DawVert', 0, 12.0)
-
-        adlplug_data.opnplug_to_cvpj_vst2()
-        return True

plugin_plugconv/vst2__i_soundfont2.py

@@ -1,20 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import plugin_plugconv
-
-from functions_plugdata import plugin_juicysfplugin
-
-class plugconv(plugin_plugconv.base):
-    def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['soundfont2', None, None], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
-        print('[plug-conv] SoundFont2 > juicysfplugin:',pluginid)
-        sf2_bank = cvpj_plugindata.dataval_get('bank', 0)
-        sf2_patch = cvpj_plugindata.dataval_get('patch', 0)
-        sf2_filename = cvpj_plugindata.dataval_get('file', 0)
-        jsf2data = plugin_juicysfplugin.juicysfplugin_data(cvpj_plugindata)
-        jsf2data.set_bankpatch(sf2_bank, sf2_patch, sf2_filename)
-        jsf2data.to_cvpj_vst2(cvpj_plugindata)
-        return True

plugin_plugconv/vst2__n_namco163_famistudio.py

@@ -1,30 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import plugin_plugconv
-from functions_plugdata import plugin_vital
-
-class plugconv(plugin_plugconv.base):
-    def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['namco163_famistudio', None, None], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
-        print('[plug-conv] N163-Famistudio > Vital:',pluginid)
-        vital_data = plugin_vital.vital_data(cvpj_plugindata)
-
-        vital_data.setvalue('volume', 4000)
-        vital_data.setvalue('osc_1_level', 0.5)
-        vital_data.setvalue('osc_1_on', 1)
-        vital_data.setvalue('osc_1_wave_frame', 128)
-        vital_data.setvalue_timed('env_1_release', 0)
-        vital_data.importcvpj_wavetable(cvpj_plugindata, 0, 1, None, smooth=False)
-        vital_data.set_lfo(1, 2, [0, 1, 1, 0], [0, 0], False, '')
-        vital_data.setvalue('lfo_1_frequency', 1.8)
-        vital_data.setvalue('lfo_1_sync', 0.0)
-        vital_data.setvalue('lfo_1_sync_type', 4.0)
-        vital_data.set_modulation(1, 'lfo_1', 'osc_1_wave_frame', 1, 0, 1, 0, 0)
-        ifvol = vital_data.importcvpj_env_block(cvpj_plugindata, 2, 'vol')
-        vital_data.setvalue('lfo_2_sync', 0.0)
-        if ifvol: vital_data.set_modulation(2, 'lfo_2', 'osc_1_level', 1, 0, 1, 0, 0)
-        vital_data.to_cvpj_vst2()
-        return True

plugin_plugconv/vst2__n_piyopiyo.py

@@ -1,25 +0,0 @@
-# SPDX-FileCopyrightText: 2023 SatyrDiamond
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import plugin_plugconv
-from functions_plugdata import plugin_vital
-
-class plugconv(plugin_plugconv.base):
-    def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['native-piyopiyo', None, 'piyopiyo'], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
-        plugtype = cvpj_plugindata.type_get()
-        if plugtype == ['native-piyopiyo', 'wave']:
-            print('[plug-conv] Converting PiyoPiyo to Vital:',pluginid)
-            vital_data = plugin_vital.vital_data(cvpj_plugindata)
-            vital_data.setvalue('osc_1_on', 1)
-            vital_data.setvalue('osc_1_level', 0.5)
-            vital_data.setvalue('volume', 4000)
-            vital_data.setvalue_timed('env_1_release', 20)
-            vital_data.importcvpj_wave(cvpj_plugindata, 1, None)
-            #vital_data.importcvpj_env_block(cvpj_plugindata, 1, 'vol')
-            vital_data.importcvpj_env_points(cvpj_plugindata, 1, 'vol')
-            vital_data.set_modulation(1, 'lfo_1', 'osc_1_level', 1, 0, 1, 0, 0)
-            vital_data.to_cvpj_vst2()
-            return True

plugin_plugconv_extern/__init__.py

@@ -0,0 +1,35 @@
+import os
+import traceback
+from importlib import util
+
+class base:
+    plugins = []
+
+    # For every class that inherits from the current,
+    # the class name will be added to plugins
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls.plugins.append(cls)
+
+
+# Small utility to automatically load modules
+def load_module(path):
+    name = os.path.split(path)[-1]
+    spec = util.spec_from_file_location(name, path)
+    module = util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+# Get current path
+path = os.path.abspath(__file__)
+dirpath = os.path.dirname(path)
+
+for fname in os.listdir(dirpath):
+    # Load only "real modules"
+    if not fname.startswith('.') and \
+       not fname.startswith('__') and fname.endswith('.py'):
+        try:
+            load_module(os.path.join(dirpath, fname))
+        except Exception:
+            traceback.print_exc()

plugin_plugconv_extern/i_opl2.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import plugin_plugconv_extern
+from functions_plugdata import plugin_adlplug
+
+def getparam(paramname):
+    global cvpj_plugindata_g
+    return cvpj_plugindata_g.param_get(paramname, 0)[0]
+
+opadltxt = ['m1', 'c1', 'm2', 'c2']
+
+class plugconv(plugin_plugconv_extern.base):
+    def __init__(self): pass
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['fm', 'opl2'], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
+        global cvpj_plugindata_g   
+        cvpj_plugindata_g = cvpj_plugindata
+
+        if extplugtype == 'vst2':
+            print('[plug-conv] Converting OPL2 to ADLplug:',pluginid)
+            adlplug_data = plugin_adlplug.adlplug_data(cvpj_plugindata)
+
+            adlplug_data.set_param("four_op" ,0)  
+            adlplug_data.set_param("pseudo_four_op" ,0)   
+            adlplug_data.set_param("blank" ,0)    
+            adlplug_data.set_param("con12" ,getparam('fm'))
+            adlplug_data.set_param("con34" ,0)    
+            adlplug_data.set_param("note_offset1" ,0)
+            adlplug_data.set_param("note_offset2" ,0)
+            adlplug_data.set_param("fb12" ,getparam("feedback"))  
+            adlplug_data.set_param("fb34" ,0) 
+            adlplug_data.set_param("midi_velocity_offset" ,0) 
+            adlplug_data.set_param("second_voice_detune" ,0)  
+            adlplug_data.set_param("percussion_key_number" ,0)
+    
+            for opnplugopname, cvpjopname in [['m1', 'op1'], ['c1', 'op2'], ['m2', ''], ['c2', '']]:  
+                adlplug_data.set_param(opnplugopname+"attack" ,(getparam(cvpjopname+"_env_attack")*-1)+15)    
+                adlplug_data.set_param(opnplugopname+"decay" ,(getparam(cvpjopname+"_env_decay")*-1)+15)  
+                adlplug_data.set_param(opnplugopname+"sustain" ,(getparam(cvpjopname+"_env_sustain")*-1)+15)
+                adlplug_data.set_param(opnplugopname+"release" ,(getparam(cvpjopname+"_env_release")*-1)+15)  
+                adlplug_data.set_param(opnplugopname+"level" ,(getparam(cvpjopname+"_level")*-1)+63)  
+                adlplug_data.set_param(opnplugopname+"ksl" ,getparam(cvpjopname+"_ksl"))
+                adlplug_data.set_param(opnplugopname+"fmul" ,getparam(cvpjopname+"_freqmul")) 
+                adlplug_data.set_param(opnplugopname+"trem" ,getparam(cvpjopname+"_tremolo")) 
+                adlplug_data.set_param(opnplugopname+"vib" ,getparam(cvpjopname+"_vibrato"))  
+                adlplug_data.set_param(opnplugopname+"sus" ,getparam(cvpjopname+"_sustained"))
+                adlplug_data.set_param(opnplugopname+"env" ,getparam(cvpjopname+"_ksr"))
+                adlplug_data.set_param(opnplugopname+"wave" ,getparam(cvpjopname+"_waveform"))
+    
+            adlplug_data.set_param("delay_off_ms" ,160)   
+            adlplug_data.set_param("delay_on_ms" ,386)    
+            adlplug_data.set_param("bank" ,0) 
+            adlplug_data.set_param("program" ,0)  
+            adlplug_data.set_param("name" ,'')
+    
+            adlplug_data.add_selection(0, 0, 0)
+            adlplug_data.adlplug_chip(2, 2, 0)
+            adlplug_data.adlplug_global(0, getparam("tremolo_depth"), getparam("vibrato_depth"))
+    
+            adlplug_data.add_common('DawVert', 0, 1.0)
+    
+            adlplug_data.adlplug_to_cvpj_vst2()
+            return True

plugin_plugconv_extern/i_opl3.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import plugin_plugconv_extern
+from functions_plugdata import plugin_adlplug
+
+def getparam(paramname):
+    global cvpj_plugindata_g
+    return cvpj_plugindata_g.param_get(paramname, 0)[0]
+
+opadltxt = ['m1', 'c1', 'm2', 'c2']
+
+class plugconv(plugin_plugconv_extern.base):
+    def __init__(self): pass
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['fm', 'opl3'], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
+        global cvpj_plugindata_g   
+        cvpj_plugindata_g = cvpj_plugindata
+
+        if extplugtype == 'vst2':
+            print('[plug-conv] Converting OPL3 to ADLplug:',pluginid)
+            adlplug_data = plugin_adlplug.adlplug_data(cvpj_plugindata)
+
+            adlplug_data.set_param("four_op" ,1)  
+            adlplug_data.set_param("pseudo_four_op" ,0)   
+            adlplug_data.set_param("blank" ,0)    
+            adlplug_data.set_param("con12" ,getparam('con_12'))
+            adlplug_data.set_param("con34" ,getparam('con_34'))
+            adlplug_data.set_param("note_offset1" ,0) 
+            adlplug_data.set_param("note_offset2" ,0) 
+            adlplug_data.set_param("fb12" ,getparam('feedback_12'))
+            adlplug_data.set_param("fb34" ,getparam('feedback_34'))
+            adlplug_data.set_param("midi_velocity_offset" ,0) 
+            adlplug_data.set_param("second_voice_detune" ,0)  
+            adlplug_data.set_param("percussion_key_number" ,0)
+    
+            for opnplugopname, cvpjopname in [['m1', 'op1'], ['c1', 'op2'], ['m2', 'op3'], ['c2', 'op4']]:  
+                adlplug_data.set_param(opnplugopname+"attack" ,(getparam(cvpjopname+"_env_attack")*-1)+15)    
+                adlplug_data.set_param(opnplugopname+"decay" ,(getparam(cvpjopname+"_env_decay")*-1)+15)  
+                adlplug_data.set_param(opnplugopname+"sustain" ,(getparam(cvpjopname+"_env_sustain")*-1)+15)
+                adlplug_data.set_param(opnplugopname+"release" ,(getparam(cvpjopname+"_env_release")*-1)+15)  
+                adlplug_data.set_param(opnplugopname+"level" ,(getparam(cvpjopname+"_level")*-1)+63)  
+                adlplug_data.set_param(opnplugopname+"ksl" ,getparam(cvpjopname+"_ksl"))
+                adlplug_data.set_param(opnplugopname+"fmul" ,getparam(cvpjopname+"_freqmul")) 
+                adlplug_data.set_param(opnplugopname+"trem" ,getparam(cvpjopname+"_tremolo")) 
+                adlplug_data.set_param(opnplugopname+"vib" ,getparam(cvpjopname+"_vibrato"))  
+                adlplug_data.set_param(opnplugopname+"sus" ,getparam(cvpjopname+"_sustained"))
+                adlplug_data.set_param(opnplugopname+"env" ,getparam(cvpjopname+"_ksr"))
+                adlplug_data.set_param(opnplugopname+"wave" ,getparam(cvpjopname+"_waveform"))
+    
+            adlplug_data.set_param("delay_off_ms" ,160)   
+            adlplug_data.set_param("delay_on_ms" ,386)    
+            adlplug_data.set_param("bank" ,0) 
+            adlplug_data.set_param("program" ,0)  
+            adlplug_data.set_param("name" ,'')
+    
+            adlplug_data.add_selection(0, 0, 0)
+            adlplug_data.adlplug_chip(2, 2, 1)
+            adlplug_data.adlplug_global(0, getparam("tremolo_depth"), getparam("vibrato_depth"))
+    
+            adlplug_data.add_common('DawVert', 0, 1.0)
+
+            adlplug_data.adlplug_to_cvpj_vst2()
+            return True

plugin_plugconv_extern/i_opn2.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import plugin_plugconv_extern
+from functions_plugdata import plugin_adlplug
+
+def getparam(paramname):
+    global cvpj_plugindata_g
+    return cvpj_plugindata_g.param_get(paramname, 0)[0]
+
+class plugconv(plugin_plugconv_extern.base):
+    def __init__(self): pass
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['fm', 'opn2'], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
+        global cvpj_plugindata_g   
+        cvpj_plugindata_g = cvpj_plugindata
+
+        if extplugtype == 'vst2':
+            print('[plug-conv] Converting OPN2 > OPNPlug:',pluginid)
+            adlplug_data = plugin_adlplug.adlplug_data(cvpj_plugindata)
+  
+            adlplug_data.set_param("blank" ,0)    
+            adlplug_data.set_param("note_offset" ,0)  
+            adlplug_data.set_param("feedback" ,getparam('feedback'))  
+            adlplug_data.set_param("algorithm" ,getparam('algorithm'))    
+            adlplug_data.set_param("ams" ,getparam('ams'))    
+            adlplug_data.set_param("fms" ,getparam('fms'))    
+            adlplug_data.set_param("midi_velocity_offset" ,0) 
+            adlplug_data.set_param("percussion_key_number" ,0)
+    
+            for opnum in range(4):  
+                optxt = "op"+str(opnum+1)   
+                adlplug_data.set_param(optxt+"detune" ,getparam(optxt+"_detune")) 
+                adlplug_data.set_param(optxt+"fmul" ,getparam(optxt+"_freqmul"))  
+                adlplug_data.set_param(optxt+"level" ,getparam(optxt+"_level"))   
+                adlplug_data.set_param(optxt+"ratescale" ,getparam(optxt+"_ratescale"))   
+                adlplug_data.set_param(optxt+"attack" ,getparam(optxt+"_env_attack")) 
+                adlplug_data.set_param(optxt+"am" ,getparam(optxt+"_am")) 
+                adlplug_data.set_param(optxt+"decay1" ,getparam(optxt+"_env_decay"))  
+                adlplug_data.set_param(optxt+"decay2" ,getparam(optxt+"_env_decay2")) 
+                adlplug_data.set_param(optxt+"sustain" ,getparam(optxt+"_env_sustain"))   
+                adlplug_data.set_param(optxt+"release" ,getparam(optxt+"_env_release"))   
+                adlplug_data.set_param(optxt+"ssgenable" ,getparam(optxt+"_ssg_enable"))  
+                adlplug_data.set_param(optxt+"ssgwave" ,getparam(optxt+"_ssg_mode"))
+    
+            adlplug_data.set_param("delay_off_ms" ,120)   
+            adlplug_data.set_param("delay_on_ms" ,486)    
+            adlplug_data.set_param("bank" ,0) 
+            adlplug_data.set_param("program" ,0)  
+            adlplug_data.set_param("name" ,'DawVert')
+
+            adlplug_data.add_selection(0, 0, 0)
+            adlplug_data.opnplug_chip(0, 1, 0)
+            adlplug_data.opnplug_global(0, getparam("lfo_enable"), getparam("lfo_frequency"))
+
+            adlplug_data.add_common('DawVert', 0, 12.0)
+
+            adlplug_data.opnplug_to_cvpj_vst2()
+            return True

plugin_plugconv_extern/i_soundfont2.py

@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import plugin_plugconv_extern
+
+from functions_plugdata import plugin_juicysfplugin
+
+class plugconv(plugin_plugconv_extern.base):
+    def __init__(self): pass
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['soundfont2', None], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
+        if extplugtype == 'vst2':
+            print('[plug-conv] SoundFont2 > juicysfplugin:',pluginid)
+            sf2_bank = cvpj_plugindata.dataval_get('bank', 0)
+            sf2_patch = cvpj_plugindata.dataval_get('patch', 0)
+            sf2_filename = cvpj_plugindata.dataval_get('file', 0)
+            jsf2data = plugin_juicysfplugin.juicysfplugin_data(cvpj_plugindata)
+            jsf2data.set_bankpatch(sf2_bank, sf2_patch, sf2_filename)
+            jsf2data.to_cvpj_vst2(cvpj_plugindata)
+            return True

plugin_plugconv_extern/n_flstudio.py

@@ -1,9 +1,8 @@
 # SPDX-FileCopyrightText: 2023 SatyrDiamond
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import plugin_plugconv
+import plugin_plugconv_extern
 
-import base64
 import struct
 import os
 import math
@@ -12,9 +11,11 @@ import lxml.etree as ET
 from functions import note_data
 from functions import data_bytes
 from functions import plugin_vst2
+from functions import xtramath
 from functions_tracks import auto_data
-from functions_plugparams import wave
+from functions_plugdata import data_wave
 
+from functions_plugdata import plugin_dragonfly_reverb
 from functions_plugdata import plugin_kickmess
 from functions_plugdata import plugin_vital
 from functions_plugdata import plugin_wolfshaper
@@ -71,11 +72,11 @@ nonfree_il_plugnames = {
 }
 
 
-class plugconv(plugin_plugconv.base):
+class plugconv(plugin_plugconv_extern.base):
     def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['native-flstudio', None, 'flp'], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['native-flstudio', None], ['vst2'], 'flp'
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
         global cvpj_plugindata_g
         cvpj_plugindata_g = cvpj_plugindata
 
@@ -85,7 +86,7 @@ class plugconv(plugin_plugconv.base):
         flpluginname = plugintype[1].lower()
 
         if 'nonfree-plugins' in extra_json:
-            if flpluginname == 'fruity blood overdrive':
+            if flpluginname == 'fruity blood overdrive' and extplugtype == 'vst2':
                 print("[plug-conv] FL Studio to VST2: Fruity Blood Overdrive > Blood Overdrive:",pluginid)
 
                 paramvals = [getparam('preband')/10000, getparam('color')/10000, getparam('preamp')/10000,
@@ -99,17 +100,14 @@ class plugconv(plugin_plugconv.base):
                 cvpj_plugindata.param_add('vst_param_5', paramvals[5], 'float', " PostGain ")
                 return True
 
-            print(flpluginname)
-
-            if flpluginname in nonfree_il_plugnames:
+            if flpluginname in nonfree_il_plugnames and extplugtype == 'vst2':
                 print("[plug-conv] FL Studio to VST2: "+plugintype[1]+":",pluginid)
 
-                chunkb64 = cvpj_plugindata.dataval_get('chunk', '')
-                ilchunk = base64.b64decode(chunkb64)
+                ilchunk = cvpj_plugindata.rawdata_get()
 
                 if flpluginname in ['equo', 'fruity delay 2', 'fruity delay bank', 'fruity flangus', 'fruity love philter'
                                     'fruity multiband compressor', 'fruity notebook', 'fruity parametric eq 2', 'fruity parametric eq',
-                                    'fruity spectroman','fruity stereo enhancer','fruity vocoder','fruity waveshaper', 'wave candy',
+                                    'fruity spectroman','fruity stereo enhancer','fruity vocoder','fruity waveshaper', 'wave candy'
                                     ]: 
 
                     subdata = il_vst_chunk(1, bytes([0xFF])*512)
@@ -120,26 +118,28 @@ class plugconv(plugin_plugconv.base):
                     headerpart = b'd\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 
                     dataout += il_headersize(il_vst_chunk(5, headerpart))
-                    dataout += il_vst_chunk('name', 'DawVert')
+                    dataout += il_vst_chunk('name', 'Defualt')
                     dataout += il_vst_chunk(1, subdata)
                     dataout += il_vst_chunk(0, ilchunk)
 
-                elif flpluginname in ['toxic biohazard', 'sawer', 'sakura', 'poizone', 'morphine', 'drumaxx']:
-                    dataout = b''
-                    for chunkdata in data_bytes.riff_read(ilchunk, 0):
-                        print(chunkdata)
-                        if chunkdata[0] == b'SSLF': dataout = chunkdata[1]
+                #elif flpluginname in ['toxic biohazard', 'sawer', 'sakura', 'poizone', 'morphine', 'drumaxx']:
+                #    dataout = b''
+                #    for chunkdata in data_bytes.riff_read(ilchunk, 0):
+                #        if chunkdata[0] == b'SSLF': dataout = chunkdata[1]
 
-                elif flpluginname in ['directwave']:
-                    dataout = ilchunk
+                #elif flpluginname in ['directwave']:
+                #    dataout = ilchunk
 
                 plugin_vst2.replace_data(cvpj_plugindata, 'name', 'win', nonfree_il_plugnames[flpluginname], 'chunk', dataout, None)
 
                 return True
 
 
+        if flpluginname not in [] and extplugtype == 'vst2':
+            auto_data.del_plugin(cvpj_l, pluginid)
+
         #---------------------------------------- Fruit Kick ----------------------------------------
-        if flpluginname == 'fruit kick':
+        if flpluginname == 'fruit kick' and extplugtype == 'vst2':
             print("[plug-conv] FL Studio to VST2: Fruit Kick > Kickmess:",pluginid)
             max_freq = note_data.note_to_freq((getparam('max_freq')/100)+12) #1000
             min_freq = note_data.note_to_freq((getparam('min_freq')/100)-36) #130.8128
@@ -164,7 +164,7 @@ class plugconv(plugin_plugconv.base):
             return True
 
         # ---------------------------------------- DX10 ----------------------------------------
-        elif flpluginname == 'fruity dx10':
+        elif flpluginname == 'fruity dx10' and extplugtype == 'vst2':
             print("[plug-conv] FL Studio to VST2: Fruity DX10 > mda DX10:",pluginid)
             param_amp_att = getparam('amp_att')/65536
             param_amp_dec = getparam('amp_dec')/65536
@@ -202,7 +202,7 @@ class plugconv(plugin_plugconv.base):
             return True
 
         # ---------------------------------------- SimSynth ----------------------------------------
-        elif flpluginname == 'simsynth':
+        elif flpluginname == 'simsynth' and extplugtype == 'vst2':
             print("[plug-conv] FL Studio to VST2: SimSynth > Vital:",pluginid)
             params_vital = plugin_vital.vital_data(cvpj_plugindata)
 
@@ -220,7 +220,7 @@ class plugconv(plugin_plugconv.base):
                 osc_warm = int(getparam(starttextparam+'_warm'))
 
                 vital_osc_shape = []
-                for num in range(2048): vital_osc_shape.append(wave.tripleoct(num/2048, simsynth_shapes[osc_shape], osc_pw, osc_o1, osc_o2))
+                for num in range(2048): vital_osc_shape.append(data_wave.tripleoct(num/2048, simsynth_shapes[osc_shape], osc_pw, osc_o1, osc_o2))
                 params_vital.replacewave(oscnum, vital_osc_shape)
                 params_vital.setvalue(starttextparam_vital+'_on', osc_on)
                 params_vital.setvalue(starttextparam_vital+'_transpose', (osc_crs-0.5)*48)
@@ -266,7 +266,7 @@ class plugconv(plugin_plugconv.base):
             params_vital.to_cvpj_vst2()
             return True
 
-        elif flpluginname == 'fruity bass boost':
+        elif flpluginname == 'fruity bass boost' and extplugtype == 'vst2':
             print("[plug-conv] FL Studio to VST2: Fruity Bass Boost > Airwindows Weight:",pluginid)
             param_freq = (getparam('freq')/1024)*0.8
             param_amount = (getparam('amount')/1024)*0.8
@@ -275,7 +275,7 @@ class plugconv(plugin_plugconv.base):
             cvpj_plugindata.param_add('vst_param_1', param_amount, 'float', "Weight")
             return True
 
-        elif flpluginname == 'fruity phaser':
+        elif flpluginname == 'fruity phaser' and extplugtype == 'vst2':
             print("[plug-conv] FL Studio to VST2: Fruity Phaser > SupaPhaser:",pluginid)
             param_sweep_freq = getparam('sweep_freq')/5000
             param_depth_min = getparam('depth_min')/1000
@@ -305,7 +305,7 @@ class plugconv(plugin_plugconv.base):
             cvpj_plugindata.param_add('vst_param_15', 0, 'float', "invert")
             return True
 
-        elif flpluginname == 'fruity spectroman':
+        elif flpluginname == 'fruity spectroman' and extplugtype == 'vst2':
             print("[plug-conv] FL Studio to VST2: Fruity Spectroman > SocaLabs's SpectrumAnalyzer:",pluginid)
             spectroman_mode = getparam('outputmode')
             data_socalabs = plugin_socalabs.socalabs_data(cvpj_plugindata)
@@ -314,7 +314,7 @@ class plugconv(plugin_plugconv.base):
             data_socalabs.to_cvpj_vst2(cvpj_plugindata, 1399874915)
             return True
 
-        elif flpluginname == 'fruity waveshaper':
+        elif flpluginname == 'fruity waveshaper' and extplugtype == 'vst2':
             print("[plug-conv] FL Studio to VST2: Fruity Waveshaper > Wolf Shaper:",pluginid)
             data_wolfshaper = plugin_wolfshaper.wolfshaper_data()
             data_wolfshaper.set_param('pregain', ((getparam('preamp')/128)-0.5)*2)
@@ -327,6 +327,79 @@ class plugconv(plugin_plugconv.base):
             data_wolfshaper.to_cvpj_vst2(cvpj_plugindata)
             return True
 
+        elif flpluginname == 'fruity stereo enhancer' and extplugtype == 'vst2':
+            print("[plug-conv] FL Studio to VST2: Fruity Stereo Enhancer > SocaLabs's StereoProcessor:",pluginid)
+            data_socalabs = plugin_socalabs.socalabs_data(cvpj_plugindata)
+            data_socalabs.set_param("width1", 0.5)
+            data_socalabs.set_param("center1", (getparam('stereo')/(256))+0.5)
+            data_socalabs.set_param("pan1", 0.0)
+            data_socalabs.set_param("rotation", 0.5)
+            data_socalabs.set_param("pan2", getparam('pan')/128)
+            data_socalabs.set_param("center2", 0.5)
+            data_socalabs.set_param("width2", 0.5)
+            data_socalabs.set_param("output", getparam('vol')/640)
+            data_socalabs.to_cvpj_vst2(cvpj_plugindata, 1282634853)
+            return True
+
+        elif flpluginname == 'fruity reeverb' and extplugtype == 'vst2':
+            print("[plug-conv] FL Studio to VST2: Fruity Reeverb > Dragonfly Hall Reverb:",pluginid)
+            data_dragonfly = plugin_dragonfly_reverb.dragonfly_hall_data()
+            flr_lowcut = getparam('lowcut')
+            flr_lowcut = xtramath.between_from_one(20, 3000, flr_lowcut/65536) if flr_lowcut != 0 else 0
+            data_dragonfly.set_param('low_cut', xtramath.clamp(flr_lowcut, 0, 200))
+            flr_highcut = getparam('highcut')
+            flr_highcut = xtramath.between_from_one(500, 22050, flr_highcut/65536)
+            data_dragonfly.set_param('high_cut', xtramath.clamp(flr_highcut, 0, 16000))
+            flr_room_size = getparam('room_size')
+            flr_room_size = xtramath.between_from_one(1, 100, flr_room_size/65536)
+            data_dragonfly.set_param('delay', xtramath.clamp(getparam('predelay'), 0, 100))
+            data_dragonfly.set_param('size', int(xtramath.clamp(flr_room_size, 10, 60)))
+            data_dragonfly.set_param('diffuse', (getparam('diffusion')/65536)*100)
+            flr_decay = xtramath.between_from_one(0.1, 20, getparam('decay')/65536)
+            data_dragonfly.set_param('decay', xtramath.clamp(flr_decay, 0.1, 10))
+            flr_hidamping = xtramath.between_from_one(500, 22050, getparam('hidamping')/65536)
+            data_dragonfly.set_param('high_xo', xtramath.clamp(flr_hidamping, 0, 16000))
+            data_dragonfly.set_param('dry_level', (getparam('dry')/65536)*100)
+            data_dragonfly.set_param('late_level', (getparam('reverb')/65536)*100)
+            data_dragonfly.to_cvpj_vst2(cvpj_plugindata)
+            return True
+
+        elif flpluginname == 'fruity reeverb 2' and extplugtype == 'vst2':
+            print("[plug-conv] FL Studio to VST2: Fruity Reeverb 2 > Dragonfly Hall Reverb:",pluginid)
+            data_dragonfly = plugin_dragonfly_reverb.dragonfly_hall_data()
+            data_dragonfly.set_param('low_cut', xtramath.clamp(getparam('lowcut'), 0, 200))
+            data_dragonfly.set_param('high_cut', xtramath.clamp(getparam('highcut')*100, 0, 16000))
+            data_dragonfly.set_param('delay', xtramath.clamp((getparam('predelay')/384)*1000, 0, 100))
+            data_dragonfly.set_param('size', int(xtramath.clamp(getparam('room_size'), 10, 60)))
+            data_dragonfly.set_param('diffuse', getparam('diffusion'))
+            data_dragonfly.set_param('decay', xtramath.clamp(getparam('decay')/10, 0.1, 10))
+            data_dragonfly.set_param('high_xo', xtramath.clamp(getparam('hidamping')*100, 0, 16000))
+            data_dragonfly.set_param('low_mult', xtramath.clamp(getparam('bass')/100, 0.5, 2.5))
+            data_dragonfly.set_param('high_mult', 0.7)
+            data_dragonfly.set_param('dry_level', xtramath.clamp((getparam('dry')/128)*100, 0, 100))
+            #data_dragonfly.set_param('early_level', xtramath.clamp((getparam('er')/128)*100, 0, 100))
+            data_dragonfly.set_param('late_level', xtramath.clamp((getparam('wet')/128)*100, 0, 100))
+            data_dragonfly.to_cvpj_vst2(cvpj_plugindata)
+            return True
+
+        elif flpluginname == 'fruity phase inverter' and extplugtype == 'vst2':
+            print("[plug-conv] FL Studio to VST2: Fruity Phase Inverter > Airwindows Flipity:",pluginid)
+            stateval = int((getparam('state')/1024)*3)
+            flipstate = 0
+            if stateval == 1: flipstate = 1
+            if stateval == 2: flipstate = 2
+            plugin_vst2.replace_data(cvpj_plugindata, 'name', 'any', 'Flipity', 'chunk', struct.pack('<f', (flipstate/8)+0.01), 0)
+            return True
+
+        #elif flpluginname == 'fruity free filter':
+        #    fff_type = getparam('type')
+        #    fff_freq = getparam('freq')
+        #    fff_q = getparam('q')
+        #    fff_gain = getparam('gain')
+        #    fff_center = getparam('center')/512
+        #    print(fff_type, fff_freq, fff_q, fff_gain, fff_center)
+        #    exit()
+
         #elif flpluginname == 'fruity compressor':  
         #    print('[plug-conv] FL Studio to VST2: Fruity Compressor > Compressor:',pluginid)
         #    auto_data.del_plugin(cvpj_l, pluginid)

plugin_plugconv_extern/n_lmms.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023 SatyrDiamond
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import plugin_plugconv
+import plugin_plugconv_extern
 
 import base64
 import struct
@@ -11,12 +11,13 @@ from functions import plugin_vst2
 from functions import plugins
 from functions import xtramath
 
+from functions_plugdata import data_nullbytegroup
 from functions_plugdata import plugin_vital
 from functions_plugdata import plugin_socalabs
 from functions_plugdata import plugin_kickmess
 from functions_plugdata import plugin_wolfshaper
 
-from functions_plugparams import wave
+from functions_plugdata import data_wave
 
 def sid_shape(lmms_sid_shape):
     if lmms_sid_shape == 0: return 3 #squ
@@ -25,21 +26,21 @@ def sid_shape(lmms_sid_shape):
     if lmms_sid_shape == 3: return 4 #noise
 
 def getparam(paramname):
-    global cvpj_plugindata_g
+    global cvpj_plugindata_gav
     paramval = cvpj_plugindata_g.param_get(paramname, 0)
     return paramval[0]
 
-class plugconv(plugin_plugconv.base):
+class plugconv(plugin_plugconv_extern.base):
     def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['native-lmms', None, 'lmms'], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['native-lmms', None], ['vst2'], 'lmms'
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
         global cvpj_plugindata_g
         cvpj_plugindata_g = cvpj_plugindata
 
         plugintype = cvpj_plugindata.type_get()
 
-        if plugintype[1] == 'tripleoscillator':
+        if plugintype[1] == 'tripleoscillator' and extplugtype == 'vst2':
             print('[plug-conv] LMMS to VST2: Triple Oscillator > Vital:',pluginid)
             params_vital = plugin_vital.vital_data(cvpj_plugindata)
 
@@ -65,12 +66,12 @@ class plugconv(plugin_plugconv.base):
 
                 soscwave = int(getparam('wavetype'+str_oscnum))
                 vital_shape = None
-                if soscwave == 0: vital_shape = wave.create_wave('sine', 0, None)
-                if soscwave == 1: vital_shape = wave.create_wave('triangle', 0, None)
-                if soscwave == 2: vital_shape = wave.create_wave('saw', 0, None)
-                if soscwave == 3: vital_shape = wave.create_wave('square', 0, 0.5)
-                if soscwave == 4: vital_shape = wave.create_wave('mooglike', 0, None)
-                if soscwave == 5: vital_shape = wave.create_wave('exp', 0, None)
+                if soscwave == 0: vital_shape = data_wave.create_wave('sine', 0, None)
+                if soscwave == 1: vital_shape = data_wave.create_wave('triangle', 0, None)
+                if soscwave == 2: vital_shape = data_wave.create_wave('saw', 0, None)
+                if soscwave == 3: vital_shape = data_wave.create_wave('square', 0, 0.5)
+                if soscwave == 4: vital_shape = data_wave.create_wave('mooglike', 0, None)
+                if soscwave == 5: vital_shape = data_wave.create_wave('exp', 0, None)
                 if vital_shape != None: params_vital.replacewave(oscnum, vital_shape)
 
             modalgo1 = int(getparam('modalgo1'))
@@ -92,7 +93,7 @@ class plugconv(plugin_plugconv.base):
             params_vital.to_cvpj_vst2()
             return True
 
-        if plugintype[1] == 'bitinvader':
+        if plugintype[1] == 'bitinvader' and extplugtype == 'vst2':
             print('[plug-conv] LMMS to VST2: BitInvader > Vital:',pluginid)
             interpolation = getparam('interpolation')
             params_vital = plugin_vital.vital_data(cvpj_plugindata)
@@ -105,7 +106,7 @@ class plugconv(plugin_plugconv.base):
             params_vital.to_cvpj_vst2()
             return True
 
-        if plugintype[1] == 'papu':
+        if plugintype[1] == 'papu' and extplugtype == 'vst2':
             print("[plug-conv] LMMS to VST2: Freeboy > SocaLabs's PAPU:",pluginid)
             data_socalabs = plugin_socalabs.socalabs_data(cvpj_plugindata)
 
@@ -154,7 +155,7 @@ class plugconv(plugin_plugconv.base):
             data_socalabs.set_param("param", 8.0)
             data_socalabs.to_cvpj_vst2(cvpj_plugindata, 1348563061)
 
-        if plugintype[1] == 'sid':
+        if plugintype[1] == 'sid' and extplugtype == 'vst2':
             print("[plug-conv] LMMS to VST2: SID > SocaLabs's SID:",pluginid)
             data_socalabs = plugin_socalabs.socalabs_data(cvpj_plugindata)
             data_socalabs.set_param("a1", getparam('attack0'))
@@ -203,7 +204,7 @@ class plugconv(plugin_plugconv.base):
             #cvpj_plugindata.dataval_get('middlenotefix', -12)
             return True
 
-        if plugintype[1] == 'kicker':
+        if plugintype[1] == 'kicker' and extplugtype == 'vst2':
             print("[plug-conv] LMMS to VST2: Kicker > Kickmess:",pluginid)
             data_kickmess = plugin_kickmess.kickmess_data()
             data_kickmess.set_param('pub', 'freq_start', getparam('startfreq'))
@@ -221,21 +222,21 @@ class plugconv(plugin_plugconv.base):
             data_kickmess.to_cvpj_vst2(cvpj_plugindata)
             return True
 
-        if plugintype[1] == 'lb302':
+        if plugintype[1] == 'lb302' and extplugtype == 'vst2':
             print("[plug-conv] LMMS to VST2: LB302 > Vital:",pluginid)
             params_vital = plugin_vital.vital_data(cvpj_plugindata)
             lb302_shape = getparam('shape')
-            if lb302_shape == 0: vital_shape = wave.create_wave('saw', 0, None)
-            if lb302_shape == 1: vital_shape = wave.create_wave('triangle', 0, None)
-            if lb302_shape == 2: vital_shape = wave.create_wave('square', 0, 0.5)
-            if lb302_shape == 3: vital_shape = wave.create_wave('square_roundend', 0, None)
-            if lb302_shape == 4: vital_shape = wave.create_wave('mooglike', 0, None)
-            if lb302_shape == 5: vital_shape = wave.create_wave('sine', 0, None)
-            if lb302_shape == 6: vital_shape = wave.create_wave('exp', 0, None)
-            if lb302_shape == 8: vital_shape = wave.create_wave('saw', 0, None)
-            if lb302_shape == 9: vital_shape = wave.create_wave('square', 0, 0.5)
-            if lb302_shape == 10: vital_shape = wave.create_wave('triangle', 0, None)
-            if lb302_shape == 11: vital_shape = wave.create_wave('mooglike', 0, None)
+            if lb302_shape == 0: vital_shape = data_wave.create_wave('saw', 0, None)
+            if lb302_shape == 1: vital_shape = data_wave.create_wave('triangle', 0, None)
+            if lb302_shape == 2: vital_shape = data_wave.create_wave('square', 0, 0.5)
+            if lb302_shape == 3: vital_shape = data_wave.create_wave('square_roundend', 0, None)
+            if lb302_shape == 4: vital_shape = data_wave.create_wave('mooglike', 0, None)
+            if lb302_shape == 5: vital_shape = data_wave.create_wave('sine', 0, None)
+            if lb302_shape == 6: vital_shape = data_wave.create_wave('exp', 0, None)
+            if lb302_shape == 8: vital_shape = data_wave.create_wave('saw', 0, None)
+            if lb302_shape == 9: vital_shape = data_wave.create_wave('square', 0, 0.5)
+            if lb302_shape == 10: vital_shape = data_wave.create_wave('triangle', 0, None)
+            if lb302_shape == 11: vital_shape = data_wave.create_wave('mooglike', 0, None)
             if lb302_shape != 7: 
                 params_vital.setvalue('osc_1_on', 1)
                 params_vital.replacewave(0, vital_shape)
@@ -265,7 +266,7 @@ class plugconv(plugin_plugconv.base):
             #cvpj_plugindata.dataval_get('middlenotefix', -12)
             return True
 
-        if plugintype[1] == 'zynaddsubfx':
+        if plugintype[1] == 'zynaddsubfx' and extplugtype == 'vst2':
             print("[plug-conv] LMMS to VST2: ZynAddSubFX > ZynAddSubFX/Zyn-Fusion:",pluginid)
             zasfxdata = cvpj_plugindata.dataval_get('data', '')
             zasfxdatastart = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE ZynAddSubFX-data>' 
@@ -273,7 +274,18 @@ class plugconv(plugin_plugconv.base):
             plugin_vst2.replace_data(cvpj_plugindata, 'name','any', 'ZynAddSubFX', 'chunk', zasfxdatafixed, None)
             return True
 
-        if plugintype[1] == 'spectrumanalyzer':
+        if plugintype[1] == 'reverbsc' and extplugtype == 'vst2':
+            print("[plug-conv] LMMS to VST2: ReverbSC > Castello Reverb:",pluginid)
+            value_size = getparam('size')
+            value_color = getparam('color')
+            plugin_vst2.replace_data(cvpj_plugindata, 'name', 'any', 'Castello Reverb', 'chunk', 
+                data_nullbytegroup.make(
+                    [{'ui_size': ''}, 
+                    {'mix': '1', 'size': str(value_size), 'brightness': str(value_color/15000)}]), 
+                None)
+            return True
+
+        if plugintype[1] == 'spectrumanalyzer' and extplugtype == 'vst2':
             print("[plug-conv] LMMS to VST2: Spectrum Analyzer > SocaLabs's SpectrumAnalyzer:",pluginid)
             data_socalabs = plugin_socalabs.socalabs_data(cvpj_plugindata)
             data_socalabs.set_param("mode", 0.0)
@@ -281,11 +293,11 @@ class plugconv(plugin_plugconv.base):
             data_socalabs.to_cvpj_vst2(cvpj_plugindata, 1399874915)
             return True
 
-        if plugintype[1] == 'waveshaper':
+        if plugintype[1] == 'waveshaper' and extplugtype == 'vst2':
             print("[plug-conv] LMMS to VST2: Wave Shaper > Wolf Shaper:",pluginid)
             data_wolfshaper = plugin_wolfshaper.wolfshaper_data()
             waveshapebytes = base64.b64decode(cvpj_plugindata.dataval_get('waveShape', ''))
             waveshapepoints = [struct.unpack('f', waveshapebytes[i:i+4]) for i in range(0, len(waveshapebytes), 4)]
-            for pointnum in range(50): data_wolfshaper.add_point(pointnum/49,waveshapepoints[pointnum*4][0],0.5,0)
+            for pointnum in range(50): data_wolfshaper.add_point(pointnum/49,waveshapepoints[pointnum*4][0],0.0,0)
             data_wolfshaper.to_cvpj_vst2(cvpj_plugindata)
             return True

plugin_plugconv_extern/n_namco163_famistudio.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import plugin_plugconv_extern
+from functions_plugdata import plugin_vital
+
+class plugconv(plugin_plugconv_extern.base):
+    def __init__(self): pass
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['namco163_famistudio', None], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
+        print('[plug-conv] N163-Famistudio > Vital:',pluginid)
+        vital_data = plugin_vital.vital_data(cvpj_plugindata)
+
+        if extplugtype == 'vst2':
+            vital_data.setvalue('volume', 4000)
+            vital_data.setvalue('osc_1_level', 0.5)
+            vital_data.setvalue('osc_1_on', 1)
+            vital_data.setvalue('osc_1_wave_frame', 128)
+            vital_data.setvalue_timed('env_1_release', 0)
+            vital_data.importcvpj_wavetable(cvpj_plugindata, 0, 1, None, smooth=False)
+            vital_data.set_lfo(1, 2, [0, 1, 1, 0], [0, 0], False, '')
+            vital_data.setvalue('lfo_1_frequency', 1.8)
+            vital_data.setvalue('lfo_1_sync', 0.0)
+            vital_data.setvalue('lfo_1_sync_type', 4.0)
+            vital_data.set_modulation(1, 'lfo_1', 'osc_1_wave_frame', 1, 0, 1, 0, 0)
+            ifvol = vital_data.importcvpj_env_block(cvpj_plugindata, 2, 'vol')
+            vital_data.setvalue('lfo_2_sync', 0.0)
+            if ifvol: vital_data.set_modulation(2, 'lfo_2', 'osc_1_level', 1, 0, 1, 0, 0)
+            vital_data.to_cvpj_vst2()
+            return True

plugin_plugconv_extern/n_onlineseq.py

@@ -1,19 +1,19 @@
 # SPDX-FileCopyrightText: 2023 SatyrDiamond
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import plugin_plugconv
+import plugin_plugconv_extern
 
 import struct
 from functions import plugin_vst2
 
-class plugconv(plugin_plugconv.base):
+class plugconv(plugin_plugconv_extern.base):
     def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['native-onlineseq', None, 'onlineseq'], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['native-onlineseq', None], ['vst2']
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
         plugintype = cvpj_plugindata.type_get()
         
-        if plugintype[1] == 'distort':
+        if plugintype[1] == 'distort' and extplugtype == 'vst2':
             print('[plug-conv] Online Sequencer to VST2: Distortion > Airwindows Density2:',pluginid)
             distlevel = 0.5
             distort_type = cvpj_plugindata.param_get('distort_type', 0)[0]
@@ -21,7 +21,7 @@ class plugconv(plugin_plugconv.base):
             plugin_vst2.replace_data(cvpj_plugindata, 'name','any', 'Density2', 'chunk', struct.pack('<ffff', distlevel, 0, 1, 1), None)
             return True
 
-        elif plugintype[1] == 'eq':
+        elif plugintype[1] == 'eq' and extplugtype == 'vst2':
             print('[plug-conv] Online Sequencer to VST2: EQ > 3 Band EQ:',pluginid)
             eq_high = cvpj_plugindata.param_get('eq_high', 0)[0]
             eq_mid = cvpj_plugindata.param_get('eq_mid', 0)[0]

plugin_plugconv_extern/v_retro.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023 SatyrDiamond
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import plugin_plugconv
+import plugin_plugconv_extern
 
 from functions import audio_wav
 from functions import plugin_vst2
@@ -10,13 +10,13 @@ from functions import plugins
 from functions_plugdata import plugin_m8bp
 from functions_plugdata import plugin_vital
 
-from functions_plugparams import wave
+from functions_plugdata import data_wave
 
-class plugconv(plugin_plugconv.base):
+class plugconv(plugin_plugconv_extern.base):
     def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['retro', None, None], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['retro', None], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
         plugintype = cvpj_plugindata.type_get()
         
         blk_env_pitch = cvpj_plugindata.env_blocks_get('pitch')
@@ -27,7 +27,7 @@ class plugconv(plugin_plugconv.base):
         if blk_env_vol != None:
             if blk_env_vol['max'] != 15: m8bp_out = False
 
-        if plugintype[1] in ['square', 'triangle', 'noise', 'pulse'] and m8bp_out == True:
+        if plugintype[1] in ['square', 'triangle', 'noise', 'pulse'] and m8bp_out == True and extplugtype == 'vst2':
             retroplug_data = plugin_m8bp.m8bp_data(cvpj_plugindata)
 
             a_predelay, a_attack, a_hold, a_decay, a_sustain, a_release, a_amount = cvpj_plugindata.asdr_env_get('vol')
@@ -64,7 +64,7 @@ class plugconv(plugin_plugconv.base):
 
             retroplug_data.to_cvpj_vst2()
             return True
-        else:
+        elif extplugtype == 'vst2':
             params_vital = plugin_vital.vital_data(cvpj_plugindata)
             params_vital.setvalue('osc_1_on', 1)
             params_vital.setvalue('osc_1_level', 1)
@@ -75,12 +75,12 @@ class plugconv(plugin_plugconv.base):
             if r_duty == 1: vital_duty = 0.25
             if r_duty == 2: vital_duty = 0.125
 
-            if plugintype[1] == 'sine': vital_shape = wave.create_wave('sine', 0, None)
-            if plugintype[1] == 'square': vital_shape = wave.create_wave('square', 0, vital_duty)
-            if plugintype[1] == 'pulse': vital_shape = wave.create_wave('square', 0, vital_duty)
-            if plugintype[1] == 'triangle': vital_shape = wave.create_wave('triangle', 0, None)
-            if plugintype[1] == 'saw': vital_shape = wave.create_wave('saw', 0, None)
-            if plugintype[1] == 'wavetable': vital_shape = wave.cvpjwave2wave(cvpj_plugindata, None)
+            if plugintype[1] == 'sine': vital_shape = data_wave.create_wave('sine', 0, None)
+            if plugintype[1] == 'square': vital_shape = data_wave.create_wave('square', 0, vital_duty)
+            if plugintype[1] == 'pulse': vital_shape = data_wave.create_wave('square', 0, vital_duty)
+            if plugintype[1] == 'triangle': vital_shape = data_wave.create_wave('triangle', 0, None)
+            if plugintype[1] == 'saw': vital_shape = data_wave.create_wave('saw', 0, None)
+            if plugintype[1] == 'wavetable': vital_shape = data_wave.cvpjwave2wave(cvpj_plugindata, None)
 
             params_vital.replacewave(0, vital_shape)
 

plugin_plugconv_extern/v_simple.py

@@ -1,44 +1,44 @@
 # SPDX-FileCopyrightText: 2023 SatyrDiamond
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import plugin_plugconv
+import plugin_plugconv_extern
 
 import struct
 from functions import plugin_vst2
 
-class plugconv(plugin_plugconv.base):
+class plugconv(plugin_plugconv_extern.base):
     def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['simple', None, None], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['simple', None], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
         plugintype = cvpj_plugindata.type_get()
         fx_on, fx_wet = cvpj_plugindata.fxdata_get()
 
-        if plugintype[1] == 'reverb': 
+        if plugintype[1] == 'reverb' and extplugtype == 'vst2':
             print('[plug-conv] SimpleFX to VST2: Reverb > Airwindows Reverb:',pluginid)
             cvpj_plugindata.fxdata_add(fx_on, 1)
             plugin_vst2.replace_data(cvpj_plugindata, 'name','any', 'Reverb', 'chunk', struct.pack('<ff', 0.5, fx_wet), None)
             return True
 
-        elif plugintype[1] == 'chorus': 
+        elif plugintype[1] == 'chorus' and extplugtype == 'vst2':
             cvpj_plugindata.fxdata_add(fx_on, 1)
             print('[plug-conv] SimpleFX to VST2: Chorus > Airwindows ChorusEnsemble:',pluginid)
             plugin_vst2.replace_data(cvpj_plugindata, 'name','any', 'ChorusEnsemble', 'chunk', struct.pack('<fff', 0.5, 0.5, fx_wet), None)
             return True
     
-        elif plugintype[1] == 'tremelo': 
+        elif plugintype[1] == 'tremelo' and extplugtype == 'vst2':
             print('[plug-conv] SimpleFX to VST2: Tremelo > Airwindows Tremolo:',pluginid)
             plugin_vst2.replace_data(cvpj_plugindata, 'name','any', 'Tremolo', 'chunk', struct.pack('<ff', 0.5, 0.5), None)
             return True
 
-        elif plugintype[1] == 'distortion': 
+        elif plugintype[1] == 'distortion' and extplugtype == 'vst2':
             cvpj_plugindata.fxdata_add(fx_on, 1)
             amount = cvpj_plugindata.param_get('amount', 0)[0]
             print('[plug-conv] SimpleFX to VST2: Tremelo > Airwindows Drive:',pluginid)
             plugin_vst2.replace_data(cvpj_plugindata, 'name','any', 'Drive', 'chunk', struct.pack('<ffff', amount, 0, 1-(amount/2), fx_wet), None)
             return True
 
-        elif plugintype[1] == 'bassboost': 
+        elif plugintype[1] == 'bassboost' and extplugtype == 'vst2':
             print('[plug-conv] SimpleFX to VST2: BassBoost > Airwindows Weight:',pluginid)
             plugin_vst2.replace_data(cvpj_plugindata, 'name','any', 'Weight', 'param', None, 2)
             cvpj_plugindata.param_add('vst_param_0', 1, 'float', "Freq")

plugin_plugconv_extern/v_synth_nonfree.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2023 SatyrDiamond
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import plugin_plugconv_extern
+
+from functions import data_dataset
+from functions import plugin_vst2
+from functions_plugdata import data_vc2xml
+import lxml.etree as ET
+
+class plugconv(plugin_plugconv_extern.base):
+    def __init__(self): pass
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['synth-nonfree', None], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
+        plugintype = cvpj_plugindata.type_get()
+        dataset_synth_nonfree = data_dataset.dataset('./data_dset/synth_nonfree.dset')
+
+        plugname = plugintype[1]
+
+        if plugname == 'Europa' and extplugtype == 'vst2':
+            europa_patch = ET.Element("JukeboxPatch")
+            europa_patch.set('patchname', "DawVert")
+            europa_samp = ET.SubElement(europa_patch, "Samples")
+            europa_prop = ET.SubElement(europa_patch, "Properties")
+            europa_obj = ET.SubElement(europa_prop, "Object")
+            europa_obj.set('name', "custom_properties")
+            paramlist = dataset_synth_nonfree.params_list('plugin', 'europa')
+            for paramname in paramlist:
+                dset_paramdata = dataset_synth_nonfree.params_i_get('plugin', 'europa', paramname)
+                eur_value_name = dset_paramdata[5]
+                if dset_paramdata[0] == False:
+                    eur_value_type = 'number'
+                    eur_value_value = cvpj_plugindata.param_get(paramname, 1)[0]
+                else:
+                    eur_value_type = 'string'
+                    eur_value_value = cvpj_plugindata.dataval_get(paramname, 1)
+                    if paramname in ['Curve1','Curve2','Curve3','Curve4','Curve']: 
+                        eur_value_value = bytes(eur_value_value).hex().upper()
+
+                europa_value_obj = ET.SubElement(europa_obj, "Value")
+                europa_value_obj.set('property',eur_value_name)
+                europa_value_obj.set('type',eur_value_type)
+                europa_value_obj.text = str(eur_value_value)
+
+            plugin_vst2.replace_data(cvpj_plugindata, 'name', 'any', 'Europa by Reason', 'chunk', data_vc2xml.make(europa_patch), None)
+            return True

plugin_plugconv_extern/v_universal.py

@@ -1,14 +1,14 @@
 # SPDX-FileCopyrightText: 2023 SatyrDiamond
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import plugin_plugconv
+import plugin_plugconv_extern
 
 import lxml.etree as ET
 from functions_tracks import auto_data
 from functions_plugdata import plugin_socalabs
 from functions_plugdata import plugin_m8bp
 from functions_plugdata import plugin_vital
-from functions_plugparams import wave
+from functions_plugdata import data_wave
 
 def getthree(cvpj_plugindata, env_name):
     env_blocks = cvpj_plugindata.env_blocks_get(env_name)
@@ -23,16 +23,14 @@ def blocks_minmax(env_blocks):
         if 'max' in env_blocks: blk_max = env_blocks['max']
     return blk_max
 
-class plugconv(plugin_plugconv.base):
+class plugconv(plugin_plugconv_extern.base):
     def __init__(self): pass
-    def is_dawvert_plugin(self): return 'plugconv'
-    def getplugconvinfo(self): return ['universal', None, None], ['vst2', None, None], True, False
-    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json):
+    def is_dawvert_plugin(self): return 'plugconv_ext'
+    def getplugconvinfo(self): return ['universal', None], ['vst2'], None
+    def convert(self, cvpj_l, pluginid, cvpj_plugindata, extra_json, extplugtype):
         plugintype = cvpj_plugindata.type_get()
 
-        fxtype = plugintype[1]
-
-        if fxtype == 'compressor':
+        if plugintype[1] == 'compressor' and extplugtype == 'vst2':
             print('[plug-conv] UniV to VST2: Compressor > Compressor:',pluginid)
             auto_data.del_plugin(cvpj_l, pluginid)
 
@@ -47,7 +45,7 @@ class plugconv(plugin_plugconv.base):
             data_socalabs.to_cvpj_vst2(cvpj_plugindata, 1397515120)
             return True
 
-        if fxtype == 'expander':
+        if plugintype[1] == 'expander' and extplugtype == 'vst2':
             print('[plug-conv] UniV to VST2: Expander > Expander:',pluginid)
             auto_data.del_plugin(cvpj_l, pluginid)
 
@@ -62,7 +60,7 @@ class plugconv(plugin_plugconv.base):
             data_socalabs.to_cvpj_vst2(cvpj_plugindata, 1397515640)
             return True
 
-        if fxtype == 'synth-osc':
+        if plugintype[1] == 'synth-osc' and extplugtype == 'vst2':
             if 'osc' in cvpj_plugindata.cvpjdata:
                 oscops = cvpj_plugindata.cvpjdata['osc']
 
@@ -130,14 +128,14 @@ class plugconv(plugin_plugconv.base):
                         params_vital.setvalue('volume', 4000)
 
                         r_duty = cvpj_plugindata.dataval_get('duty', 0)
-                        if osc_shape == 'sine': vital_shape = wave.create_wave('sine', 0, None)
-                        if osc_shape == 'square': vital_shape = wave.create_wave('square', 0, pulse_width)
-                        if osc_shape == 'pulse': vital_shape = wave.create_wave('square', 0, pulse_width)
-                        if osc_shape == 'triangle': vital_shape = wave.create_wave('triangle', 0, None)
-                        if osc_shape == 'saw': vital_shape = wave.create_wave('saw', 0, None)
+                        if osc_shape == 'sine': vital_shape = data_wave.create_wave('sine', 0, None)
+                        if osc_shape == 'square': vital_shape = data_wave.create_wave('square', 0, pulse_width)
+                        if osc_shape == 'pulse': vital_shape = data_wave.create_wave('square', 0, pulse_width)
+                        if osc_shape == 'triangle': vital_shape = data_wave.create_wave('triangle', 0, None)
+                        if osc_shape == 'saw': vital_shape = data_wave.create_wave('saw', 0, None)
                         if osc_shape == 'custom_wave': 
                             wave_name = s_osc['wave_name'] if 'wave_name' in s_osc else None
-                            vital_shape = wave.cvpjwave2wave(cvpj_plugindata, wave_name)
+                            vital_shape = data_wave.cvpjwave2wave(cvpj_plugindata, wave_name)
 
                         params_vital.replacewave(0, vital_shape)