non
/
paulstretch_cpp
mirror of https://github.com/original-male/paulstretch_cpp
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
119KB
Tree: 29d28c1dc6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '29d28c1dc6'
${ noResults }
paulstretch_cpp/GUI.fl

967 lines
30KB
Raw Blame History 

  1. # data file for the Fltk User Interface Designer (fluid)

  2. version 1.0110 

  3. header_name {.h} 

  4. code_name {.cxx}

  5. decl {//Copyright (c) Nasca Octavian Paul. Released under GNU General Public License version 2} {public

  6. } 

  7. 

  8. decl {\#include <FL/Fl_File_Chooser.H>} {} 

  9. 

  10. decl {\#include <FL/Fl_Box.H>} {public

  11. } 

  12. 

  13. decl {\#include <FL/Fl_Group.H>} {public

  14. } 

  15. 

  16. decl {\#include <FL/Fl_Box.H>} {public

  17. } 

  18. 

  19. decl {\#include <FL/fl_draw.H>} {public

  20. } 

  21. 

  22. decl {\#include <FL/Fl_Value_Input.H>} {public

  23. } 

  24. 

  25. decl {\#include <FL/fl_ask.H>} {public

  26. } 

  27. 

  28. decl {\#include<sys/stat.h>} {} 

  29. 

  30. decl {\#include <stdio.h>} {} 

  31. 

  32. decl {\#include <string>} {} 

  33. 

  34. decl {\#include <math.h>} {} 

  35. 

  36. decl {\#include "Control.h"} {public

  37. } 

  38. 

  39. decl {\#include "FreeEditUI.h"} {public

  40. } 

  41. 

  42. decl {\#include "version.h"} {public

  43. } 

  44. 

  45. Function {hex4n(char c)} {return_type int

  46. } {

  47.   code {if (c>96) c-=32;

  48. if ((c>='0')||(c<='9')) return (c-'0');

  49. if ((c>='A')||(c<='F')) return (c-'A')+10;

  50. 

  51. return 0;} {}

  52. } 

  53. 

  54. Function {unescape(std::string s)} {return_type {std::string}

  55. } {

  56.   code {std::string result;

  57. int slen=s.size();

  58. s+="    ";

  59. int sk=0;

  60. while (sk<slen){

  61. 	char c=s[sk];

  62. 	if (c=='%'){

  63. 		char c1=s[++sk];

  64. 		char c2=s[++sk];

  65. 		result+=(char)(16*hex4n(c1)+hex4n(c2));

  66. 		sk++;

  67. 	}else{

  68. 		result+=c;

  69. 		sk++;

  70. 	};

  71. };

  72. 

  73. 

  74. //printf("%s\\n%s\\n",s.c_str(),result.c_str());

  75. return result;} {}

  76. } 

  77. 

  78. class DDBox {: {public Fl_Box}

  79. } {

  80.   Function {DDBox(int x, int y, int w, int h, const char *label = 0):Fl_Box(x,y,w,h,label)} {open

  81.   } {

  82.     code {new_drag_file=false;} {}

  83.   }

  84.   Function {handle(int event)} {open return_type int

  85.   } {

  86.     code {if ((event==FL_DND_ENTER)||(event==FL_DND_DRAG)||(event==FL_DND_RELEASE)) return 1;

  87. if (event==FL_PASTE){

  88. 	const char *url=Fl::event_text();

  89. 	if (strstr(url,"file://")!=url) return 0;//is not a file

  90. 	std::string filename=url+7;

  91. 	for (int i=0;i<filename.size();i++) if (filename[i]<32) filename[i]=0;

  92. 	drag_file=unescape(filename);

  93. 	new_drag_file=true;

  94. 	return 1;

  95. };

  96. return Fl_Box::handle(event);} {}

  97.   }

  98.   decl {std::string drag_file;} {public

  99.   }

  100.   decl {bool new_drag_file;} {public

  101.   }

  102. } 

  103. 

  104. class GUI {open

  105. } {

  106.   decl {enum Mode {STOP,PLAY,PAUSE,FREEZE};} {}

  107.   Function {GUI()} {} {

  108.     code {playing_for_button=false;

  109. eof_for_button=false;

  110. rendering=false;

  111. make_window();

  112. tick(this);

  113. refresh();

  114. set_mode(STOP);} {}

  115.   }

  116.   Function {~GUI()} {} {

  117.     code {Fl::remove_timeout(tick,this);} {}

  118.   }

  119.   Function {open_input_file(const char *filename)} {open

  120.   } {

  121.     code {const char *ext=fl_filename_ext(filename);

  122. FILE_TYPE intype=FILE_WAV;

  123. if ((strcmp(ext,".ogg")==0)||(strcmp(ext,".OGG")==0)||(strcmp(ext,".Ogg")==0)) intype=FILE_VORBIS;

  124. if ((strcmp(ext,".mp3")==0)||(strcmp(ext,".MP3")==0)||(strcmp(ext,".Mp3")==0)) intype=FILE_MP3;

  125. bool result=control.set_input_filename(filename,intype);

  126. if (result) {

  127. 	infilename_output->copy_label(control.get_input_filename_and_info().c_str());

  128. } else {

  129. 	infilename_output->copy_label("");

  130. 	fl_alert("Error: Could not open audio file:\\n%s",filename);

  131. };

  132. refresh();} {}

  133.   }

  134.   Function {render()} {open

  135.   } {

  136.     code {render_button->deactivate();

  137. rendering=true;

  138. render_percent_slider->value(0);

  139. render_percent_slider->activate();

  140. cancel_render_button->activate();

  141. //char defaultfile[FL_PATH_MAX];

  142. //fl_filename_absolute(defaultfile,control.get_recommanded_output_filename().c_str());

  143. Fl_File_Chooser *fc=new Fl_File_Chooser(NULL,"Wave files (*.wav)\\tOgg Vorbis (*.ogg)",Fl_File_Chooser::CREATE,"Render to audio file...");

  144. 

  145. fc->preview(0);

  146. fc->filter_value(0);

  147. fc->ok_label("Render");

  148. fc->show();

  149. while (fc->visible()){

  150. 	Fl::wait();

  151. };

  152. 

  153. const char *newfile = fc->value();

  154.   if (newfile != NULL) {  	

  155.   	if (file_exists(newfile)){

  156.   		if (!fl_choice("The file exists. \\nOverwrite it?","No","Yes",NULL)) return;

  157.   	};

  158. 

  159. 	FILE_TYPE type=FILE_WAV;

  160. 	if (fc->filter_value()==1)  type=FILE_VORBIS;

  161. 	const char *ext=fl_filename_ext(newfile);

  162. 	std::string outfilename=newfile;

  163. 	if (strlen(ext)==0){

  164. 		if (type==FILE_VORBIS) outfilename+=".ogg";

  165. 			else outfilename+=".wav";

  166. 	};

  167. 	render_percent_slider->copy_label(outfilename.c_str());

  168. 	FILE_TYPE intype=FILE_WAV;

  169. 	{

  170. 		const char *ext=fl_filename_ext(control.get_input_filename().c_str());

  171.  		if ((strcmp(ext,".ogg")==0)||(strcmp(ext,".OGG")==0)||(strcmp(ext,".Ogg")==0)) intype=FILE_VORBIS;

  172.  		if ((strcmp(ext,".MP3")==0)||(strcmp(ext,".mp3")==0)||(strcmp(ext,".Mp3")==0)) intype=FILE_MP3;

  173.   	};

  174. 	const char *outstr=control.Render(control.get_input_filename(),outfilename,type,intype,

  175. 		selection_pos1->value()/100.0,selection_pos2->value()/100.0).c_str();

  176. 	if (strlen(outstr)!=0) fl_alert("%s",outstr);

  177.   };

  178. 

  179. delete fc;

  180. render_button->activate();

  181. render_percent_slider->value(0);

  182. render_percent_slider->deactivate();

  183. render_percent_slider->label("");

  184. cancel_render_button->deactivate();

  185. rendering=false;} {}

  186.   }

  187.   Function {make_window()} {open private

  188.   } {

  189.     Fl_Window window {

  190.       label {Paul's Extreme Sound Stretch} open

  191.       xywh {192 131 995 550} type Double resizable

  192.       code0 {if(strlen(VERSION)<2) {o->color(FL_BLUE); o->label("VERSION NOT SET!!!!!!!!!!!!");};} visible

  193.     } {

  194.       Fl_Menu_Bar {} {open

  195.         xywh {0 0 1015 20}

  196.       } {

  197.         Submenu {} {

  198.           label File open

  199.           xywh {0 0 63 20}

  200.         } {

  201.           MenuItem {} {

  202.             label {Open audio file...}

  203.             callback {char *newfile = fl_file_chooser("Open Audio(ogg,wav,mp3) File?", NULL, NULL);

  204.   if (newfile != NULL) {

  205.   	open_input_file(newfile);

  206.   	

  207.   };

  208.   selection_pos1->value(0.0);

  209.   selection_pos2->value(100.0);

  210. 

  211.   refresh();}

  212.             xywh {0 0 30 20}

  213.           }

  214.           MenuItem render_menu {

  215.             label {Render and save audio file...}

  216.             callback {selection_pos1->value(0.0);

  217. selection_pos2->value(100.0);

  218. tabs_widget->value(write_to_file_group);

  219. render();}

  220.             xywh {10 10 30 20} deactivate divider

  221.           }

  222.           MenuItem {} {

  223.             label {Open Parameters...}

  224.             callback {char *newfile = fl_file_chooser("Open Parameter File?", "PaulStretch XML (*.psx)\\tAll Files (*)", NULL);

  225.   if (newfile != NULL) {

  226. 	set_mode(STOP);

  227. 	control.stopplay();

  228.  

  229.   	if (!control.load_parameters(newfile)){

  230.   		fl_alert("Error: Could not load parameter file:\\n%s",newfile);

  231.   	};

  232.   };

  233.   refreshgui();

  234.   refresh();}

  235.             xywh {10 10 30 20}

  236.           }

  237.           MenuItem {} {

  238.             label {Save Parameters...}

  239.             callback {char *newfile = fl_file_chooser("Save Parameters(paulstretch) File?", "PaulStretch XML (*.psx)\\tAll Files (*)", NULL);

  240.   if (newfile != NULL) {

  241.   	if (file_exists(newfile)){

  242.   		if (!fl_choice("The file exists. \\nOverwrite it?","No","Yes",NULL)) return;

  243.   	};

  244.   	control.save_parameters(newfile);

  245.   };

  246.   refresh();}

  247.             xywh {20 20 30 20} divider

  248.           }

  249.           MenuItem {} {

  250.             label Exit

  251.             callback {window->hide();}

  252.             xywh {0 0 30 20}

  253.           }

  254.         }

  255.         Submenu {} {

  256.           label About

  257.           xywh {15 15 63 20}

  258.         } {

  259.           MenuItem {} {

  260.             label {About...}

  261.             callback {aboutwindow->show();}

  262.             xywh {15 15 30 20}

  263.           }

  264.         }

  265.       }

  266.       Fl_Tabs tabs_widget {open

  267.         xywh {5 50 985 420} box BORDER_BOX

  268.       } {

  269.         Fl_Group {} {

  270.           label Parameters open

  271.           xywh {5 70 985 400}

  272.         } {

  273.           Fl_Slider stretch_slider {

  274.             label {Stretch:}

  275.             callback {refresh();

  276. control.update_player_stretch();}

  277.             xywh {10 89 975 15} type {Horz Knob} box FLAT_BOX align 6 value 0.29

  278.           }

  279.           Fl_Slider fftsize_slider {

  280.             label {Window Size:}

  281.             callback {refresh();

  282. o->labelcolor(FL_BLUE);}

  283.             xywh {10 155 975 15} type {Horz Knob} box FLAT_BOX align 6 value 0.47

  284.           }

  285.           Fl_Choice mode_choice {

  286.             label {Mode:}

  287.             callback {refresh();}

  288.             xywh {850 110 135 20} down_box BORDER_BOX

  289.           } {

  290.             MenuItem {} {

  291.               label Stretch

  292.               xywh {10 10 30 20}

  293.             }

  294.             MenuItem {} {

  295.               label HyperStretch

  296.               xywh {20 20 30 20}

  297.             }

  298.             MenuItem {} {

  299.               label Shorten

  300.               xywh {0 0 30 20}

  301.             }

  302.           }

  303.           Fl_Choice window_choice {

  304.             label {Type:}

  305.             callback {FFTWindow w=W_RECTANGULAR;

  306. switch(o->value()){

  307. 	case 0:

  308. 	   w=W_RECTANGULAR;

  309. 	   break;

  310. 	case 1:

  311. 	   w=W_HAMMING;

  312. 	   break;

  313. 	case 2:

  314. 	   w=W_HANN;

  315. 	   break;

  316. 	case 3:

  317. 	   w=W_BLACKMAN;

  318. 	   break;

  319. 	case 4:

  320. 	   w=W_BLACKMAN_HARRIS;

  321. 	   break;

  322. };

  323. 

  324. control.set_window_type(w);

  325. refresh();}

  326.             xywh {850 185 135 20} down_box BORDER_BOX when 1

  327.             code0 {o->value(2);}

  328.           } {

  329.             MenuItem {} {

  330.               label Rectangular

  331.               xywh {40 40 30 20}

  332.             }

  333.             MenuItem {} {

  334.               label Hamming

  335.               xywh {30 30 30 20}

  336.             }

  337.             MenuItem {} {

  338.               label Hann

  339.               xywh {10 10 30 20}

  340.             }

  341.             MenuItem {} {

  342.               label Blackman

  343.               xywh {20 20 30 20}

  344.             }

  345.             MenuItem {} {

  346.               label BlackmanHarris

  347.               xywh {30 30 30 20}

  348.             }

  349.           }

  350.           Fl_Button {} {

  351.             label S

  352.             callback {char tmp[100];

  353. snprintf(tmp,100,"%g",control.get_stretch());

  354. const char *result=fl_input("Enter the stretch value",tmp);

  355. if (!result) return;

  356. 

  357. double str=atof(result);

  358. if (str<1e-4) return;

  359. 

  360. double stc=control.get_stretch_control(str,mode_choice->value());

  361. 

  362. if ((stc<1e-4)||(stc>1.0)) return;

  363. stretch_slider->value(stc);

  364. stretch_slider->do_callback();}

  365.             tooltip {set the stretch to a value} xywh {780 110 20 20}

  366.           }

  367.           Fl_Box resolution_box {

  368.             xywh {10 187 790 18} box FLAT_BOX color 52 align 20

  369.           }

  370.           Fl_Group {} {

  371.             label {Stretch Multiplier} open

  372.             xywh {10 245 975 220} box THIN_UP_BOX labeltype ENGRAVED_LABEL

  373.           } {

  374.             Fl_Box stretch_free_edit {

  375.               label Graph

  376.               xywh {105 250 875 210} box FLAT_BOX color 17

  377.               code0 {o->init(&control.ppar.stretch_multiplier,&control);}

  378.               class FreeEditUI

  379.             }

  380.             Fl_Group stretch_multiplier_control {open

  381.               xywh {15 250 85 210} box BORDER_FRAME color 0 align 208

  382.               code0 {o->init(stretch_free_edit,FE_LINEAR,0,100.0,FE_LOG,0.1,50.0,1.0);}

  383.               class FreeEditControls

  384.             } {}

  385.           }

  386.         }

  387.         Fl_Group {} {

  388.           label Process open

  389.           xywh {5 70 985 400} hide

  390.         } {

  391.           Fl_Group {} {open

  392.             xywh {165 75 105 65} box BORDER_BOX

  393.           } {

  394.             Fl_Check_Button pitch_shift_enabled {

  395.               label {Pitch Shift}

  396.               callback {control.ppar.pitch_shift.enabled=o->value();

  397. control.update_process_parameters();}

  398.               xywh {170 80 90 15} down_box DOWN_BOX labelfont 1

  399.             }

  400.             Fl_Counter pitch_shift_cents {

  401.               label cents

  402.               callback {control.ppar.pitch_shift.cents=(int)o->value();

  403. control.update_process_parameters();}

  404.               xywh {170 100 90 20} minimum -3600 maximum 3600 step 1

  405.               code0 {o->lstep(100);}

  406.             }

  407.           }

  408.           Fl_Group {} {open

  409.             xywh {275 75 135 100} box BORDER_BOX

  410.           } {

  411.             Fl_Check_Button octave_enabled {

  412.               label {Octave Mixer}

  413.               callback {control.ppar.octave.enabled=o->value();

  414. control.update_process_parameters();}

  415.               xywh {280 80 110 15} down_box DOWN_BOX labelfont 1

  416.             }

  417.             Fl_Slider octave_om2 {

  418.               label {-2}

  419.               callback {control.ppar.octave.om2=pow(o->value(),2.0);

  420. control.update_process_parameters();}

  421.               tooltip {2 octaves below} xywh {280 100 15 55} type {Vert Knob} minimum 1 maximum 0

  422.             }

  423.             Fl_Slider octave_om1 {

  424.               label {-1}

  425.               callback {control.ppar.octave.om1=pow(o->value(),2.0);

  426. control.update_process_parameters();}

  427.               tooltip {1 octave below} xywh {300 100 15 55} type {Vert Knob} minimum 1 maximum 0

  428.             }

  429.             Fl_Slider octave_o0 {

  430.               label 0

  431.               callback {control.ppar.octave.o0=pow(o->value(),2.0);

  432. control.update_process_parameters();}

  433.               tooltip {original (dry)} xywh {320 100 15 55} type {Vert Knob} minimum 1 maximum 0 value 1

  434.             }

  435.             Fl_Slider octave_o1 {

  436.               label 1

  437.               callback {control.ppar.octave.o1=pow(o->value(),2.0);

  438. control.update_process_parameters();}

  439.               tooltip {1 octave above} xywh {340 100 15 55} type {Vert Knob} minimum 1 maximum 0

  440.             }

  441.             Fl_Slider octave_o15 {

  442.               label {1.5}

  443.               callback {control.ppar.octave.o15=pow(o->value(),2.0);

  444. control.update_process_parameters();}

  445.               tooltip {3rd harmonic} xywh {360 100 15 55} type {Vert Knob} minimum 1 maximum 0

  446.             }

  447.             Fl_Slider octave_o2 {

  448.               label 2

  449.               callback {control.ppar.octave.o2=pow(o->value(),2.0);

  450. control.update_process_parameters();}

  451.               tooltip {2 octaves above} xywh {380 100 15 55} type {Vert Knob} minimum 1 maximum 0

  452.             }

  453.           }

  454.           Fl_Group {} {open

  455.             xywh {165 140 105 65} box BORDER_BOX

  456.           } {

  457.             Fl_Check_Button freq_shift_enabled {

  458.               label {Freq Shift}

  459.               callback {control.ppar.freq_shift.enabled=o->value();

  460. control.update_process_parameters();}

  461.               xywh {170 145 90 15} down_box DOWN_BOX labelfont 1

  462.             }

  463.             Fl_Counter freq_shift_Hz {

  464.               label Hz

  465.               callback {control.ppar.freq_shift.Hz=(int)o->value();

  466. control.update_process_parameters();}

  467.               xywh {170 165 90 20} minimum -10000 maximum 10000 step 1

  468.               code0 {o->lstep(100);}

  469.             }

  470.           }

  471.           Fl_Group {} {open

  472.             xywh {750 75 120 65} box BORDER_BOX

  473.           } {

  474.             Fl_Check_Button compressor_enabled {

  475.               label Compress

  476.               callback {control.ppar.compressor.enabled=o->value();

  477. control.update_process_parameters();}

  478.               xywh {755 80 90 15} down_box DOWN_BOX labelfont 1

  479.             }

  480.             Fl_Slider compressor_power {

  481.               label Power

  482.               callback {control.ppar.compressor.power=o->value();

  483. control.update_process_parameters();}

  484.               xywh {755 100 110 15} type {Horz Knob}

  485.             }

  486.           }

  487.           Fl_Slider {} {

  488.             label Volume

  489.             callback {REALTYPE x=o->value();

  490. x=pow(10.0,pow(x,1.5)-1.0)-0.1;

  491. control.set_volume(x);}

  492.             xywh {750 155 120 40} type {Horz Knob} labelfont 1 minimum 0.3 maximum 1.6 value 1

  493.           }

  494.           Fl_Group {} {open

  495.             xywh {415 75 185 100} box BORDER_BOX

  496.           } {

  497.             Fl_Check_Button filter_enabled {

  498.               label Filter

  499.               callback {control.ppar.filter.enabled=o->value();

  500. control.update_process_parameters();}

  501.               xywh {420 80 70 15} down_box DOWN_BOX labelfont 1

  502.             }

  503.             Fl_Value_Input filter_low {

  504.               label {Freq1(Hz)}

  505.               callback {control.ppar.filter.low=o->value();

  506. control.update_process_parameters();}

  507.               xywh {420 101 100 24} align 8 maximum 10000

  508.             }

  509.             Fl_Value_Input filter_high {

  510.               label {Freq2(Hz)}

  511.               callback {control.ppar.filter.high=o->value();

  512. control.update_process_parameters();}

  513.               xywh {420 126 100 24} align 8 maximum 25000 value 22000

  514.             }

  515.             Fl_Check_Button filter_stop {

  516.               label BandStop

  517.               callback {control.ppar.filter.stop=o->value();

  518. control.update_process_parameters();}

  519.               tooltip {band-stop filter} xywh {500 80 90 15} down_box DOWN_BOX

  520.             }

  521.             Fl_Slider filter_hdamp {

  522.               label DHF

  523.               callback {control.ppar.filter.hdamp=o->value();

  524. control.update_process_parameters();}

  525.               tooltip {Damp High Frequency} xywh {420 155 140 15} type {Horz Knob} align 8

  526.             }

  527.           }

  528.           Fl_Group {} {open

  529.             xywh {10 75 150 120} box BORDER_BOX

  530.           } {

  531.             Fl_Check_Button harmonics_enabled {

  532.               label Harmonics

  533.               callback {control.ppar.harmonics.enabled=o->value();

  534. control.update_process_parameters();}

  535.               xywh {15 80 95 15} down_box DOWN_BOX labelfont 1

  536.             }

  537.             Fl_Value_Input harmonics_freq {

  538.               label {F.Freq(Hz)}

  539.               callback {control.ppar.harmonics.freq=o->value();

  540. control.update_process_parameters();}

  541.               tooltip {fundamental frequency} xywh {15 101 65 24} align 8 minimum 1 maximum 20000 value 440

  542.             }

  543.             Fl_Value_Input harmonics_bandwidth {

  544.               label {BW(cents)}

  545.               callback {control.ppar.harmonics.bandwidth=o->value();

  546. control.update_process_parameters();}

  547.               tooltip {bandwidth (cents)} xywh {15 126 65 24} align 8 minimum 0.1 maximum 200 value 25

  548.             }

  549.             Fl_Check_Button harmonics_gauss {

  550.               label Gauss

  551.               callback {control.ppar.harmonics.gauss=o->value();

  552. control.update_process_parameters();}

  553.               tooltip {smooth the harmonics} xywh {85 155 65 15} down_box DOWN_BOX

  554.             }

  555.             Fl_Counter harmonics_nharmonics {

  556.               label {no.hrm.}

  557.               callback {control.ppar.harmonics.nharmonics=(int)o->value();

  558. control.update_process_parameters();}

  559.               tooltip {number of harmonics} xywh {15 155 56 20} type Simple minimum 1 maximum 100 step 1 value 10

  560.             }

  561.           }

  562.           Fl_Group {} {open

  563.             xywh {275 180 325 40} box BORDER_BOX

  564.           } {

  565.             Fl_Check_Button spread_enabled {

  566.               label Spread

  567.               callback {control.ppar.spread.enabled=o->value();

  568. control.update_process_parameters();}

  569.               xywh {280 185 90 15} down_box DOWN_BOX labelfont 1

  570.             }

  571.             Fl_Slider spread_bandwidth {

  572.               label Bandwidth

  573.               callback {control.ppar.spread.bandwidth=o->value();

  574. control.update_process_parameters();}

  575.               xywh {360 185 230 15} type {Horz Knob} value 0.3

  576.             }

  577.           }

  578.           Fl_Group {} {

  579.             label ArbitraryFilter

  580.             xywh {10 245 975 220} box THIN_UP_BOX labeltype ENGRAVED_LABEL

  581.           } {

  582.             Fl_Box filter_free_edit {

  583.               label Graph

  584.               xywh {105 250 875 210} box FLAT_BOX color 206 selection_color 0

  585.               code0 {o->init(&control.ppar.free_filter,&control);}

  586.               class FreeEditUI

  587.             }

  588.             Fl_Group arbitrary_filter_control {open

  589.               xywh {15 250 85 210} box BORDER_FRAME color 0 align 208

  590.               code0 {o->init(filter_free_edit,FE_LOG,20.0,25000.0,FE_DB,-60,20,0.0);}

  591.               class FreeEditControls

  592.             } {}

  593.           }

  594.           Fl_Group {} {open

  595.             xywh {605 75 140 105} box BORDER_BOX

  596.           } {

  597.             Fl_Check_Button tonal_vs_noise_enabled {

  598.               label {Tonal/Noise}

  599.               callback {control.ppar.tonal_vs_noise.enabled=o->value();

  600. control.update_process_parameters();}

  601.               xywh {610 80 115 20} down_box DOWN_BOX labelfont 1

  602.             }

  603.             Fl_Slider tonal_vs_noise_bandwidth {

  604.               label Bandwidth

  605.               callback {control.ppar.tonal_vs_noise.bandwidth=o->value();

  606. control.update_process_parameters();}

  607.               xywh {610 141 130 15} type {Horz Knob} minimum 0.75 value 0.9

  608.             }

  609.             Fl_Slider tonal_vs_noise_preserve {

  610.               label {noise <-->tonal}

  611.               callback {control.ppar.tonal_vs_noise.preserve=o->value();

  612. control.update_process_parameters();}

  613.               xywh {610 105 130 15} type {Horz Knob} minimum -1 value 0.5

  614.             }

  615.           }

  616.         }

  617.         Fl_Group {} {

  618.           label {Binaural beats}

  619.           xywh {5 70 985 400} box THIN_UP_BOX hide

  620.         } {

  621.           Fl_Box binaural_free_edit {

  622.             label Graph

  623.             xywh {135 75 845 390} box FLAT_BOX color 135

  624.             code0 {o->init(&control.bbpar.free_edit,&control);}

  625.             class FreeEditUI

  626.           }

  627.           Fl_Slider bbpar_mono {

  628.             label Pow

  629.             callback {control.bbpar.mono=o->value();

  630. control.update_process_parameters();}

  631.             xywh {105 75 20 190} type {Vert Knob} labelfont 1 minimum 1 maximum 0 value 0.5

  632.           }

  633.           Fl_Group binaural_beats_control {

  634.             label {FreeEdit Controls}

  635.             xywh {10 75 80 205} box BORDER_FRAME color 47 align 208

  636.             code0 {o->init(binaural_free_edit,FE_LINEAR,0,100.0,FE_LOG,0.1,50.0,8.0);}

  637.             class FreeEditControls

  638.           } {}

  639.           Fl_Choice bbpar_stereo_mode {

  640.             label {Stereo Mode}

  641.             callback {control.bbpar.stereo_mode=(BB_STEREO_MODE)o->value();

  642. control.update_process_parameters();}

  643.             xywh {10 305 110 20} down_box BORDER_BOX align 5

  644.           } {

  645.             MenuItem {} {

  646.               label LeftRight

  647.               xywh {10 10 36 21} labelfont 1

  648.             }

  649.             MenuItem {} {

  650.               label RightLeft

  651.               xywh {20 20 36 21} labelfont 1

  652.             }

  653.             MenuItem {} {

  654.               label Symmetric

  655.               xywh {30 30 36 21} labelfont 1

  656.             }

  657.           }

  658.         }

  659.         Fl_Group write_to_file_group {

  660.           label {Write to file} open

  661.           xywh {5 70 985 400} hide

  662.         } {

  663.           Fl_Button render_button {

  664.             label {Render selection...}

  665.             callback {render();}

  666.             xywh {250 95 320 30} labelfont 1 labelsize 22

  667.           }

  668.           Fl_Value_Slider render_percent_slider {

  669.             label { }

  670.             xywh {15 245 970 65} type {Horz Fill} selection_color 4 align 70 maximum 100 step 0.1 textsize 14

  671.           }

  672.           Fl_Button cancel_render_button {

  673.             label Cancel

  674.             callback {if (fl_choice("Cancel audio rendering?","No","Yes",NULL)) control.info.cancel_render=true;}

  675.             xywh {400 365 145 25} deactivate

  676.           }

  677.           Fl_Button {} {

  678.             label {selection pos1}

  679.             callback {selection_pos1->value(seek_slider->value());}

  680.             tooltip {set selection start from Player's position} xywh {20 85 110 20} align 20

  681.           }

  682.           Fl_Button {} {

  683.             label {selection pos2}

  684.             callback {selection_pos2->value(seek_slider->value());}

  685.             tooltip {set selection end from Player's position} xywh {20 110 110 20} align 20

  686.           }

  687.           Fl_Button {} {

  688.             label {select all}

  689.             callback {selection_pos1->value(0.0);

  690. selection_pos2->value(100.0);}

  691.             tooltip {select the whole sound} xywh {20 135 110 20}

  692.           }

  693.           Fl_Value_Output selection_pos1 {

  694.             label {%}

  695.             xywh {135 85 70 20} align 72 maximum 100 step 0.01 textfont 1

  696.           }

  697.           Fl_Value_Output selection_pos2 {

  698.             label {%}

  699.             xywh {135 111 70 18} align 72 maximum 100 step 0.01 value 100 textfont 1

  700.           }

  701.           Fl_Check_Button {} {

  702.             label 32bit

  703.             callback {control.wav32bit=o->value();}

  704.             xywh {250 135 100 15} down_box DOWN_BOX

  705.           }

  706.         }

  707.       }

  708.       Fl_Box infilename_output {

  709.         tooltip {drag audio file here to open it} xywh {5 24 1005 22} box FLAT_BOX color 17 align 84

  710.         class DDBox

  711.       }

  712.       Fl_Group {} {

  713.         xywh {5 475 985 70} box BORDER_BOX

  714.       } {

  715.         Fl_Group {} {open

  716.           xywh {10 490 190 40} box THIN_UP_BOX color 16

  717.         } {

  718.           Fl_Button play_button {

  719.             label {@>}

  720.             callback {if (control.playing_eof()&&(seek_slider->value()>99.0)){

  721. 	seek_slider->value(0.0);

  722. 	seek_slider->do_callback();

  723. };

  724. set_mode(PLAY);

  725. playing_for_button=true;

  726. eof_for_button=true;

  727. 

  728. bool bypass=false;

  729. if (Fl::event_button()==FL_RIGHT_MOUSE) bypass=true;

  730. 

  731. control.startplay(bypass);}

  732.             tooltip Play xywh {20 500 40 20} box PLASTIC_UP_BOX

  733.           }

  734.           Fl_Button freeze_button {

  735.             label {@<-> F}

  736.             callback {control.freezeplay();

  737. set_mode(FREEZE);}

  738.             tooltip Freeze xywh {65 500 40 20} box PLASTIC_UP_BOX

  739.           }

  740.           Fl_Button {} {

  741.             label {@||}

  742.             callback {set_mode(PAUSE);

  743. control.pauseplay();}

  744.             tooltip Pause xywh {110 500 40 20} box PLASTIC_UP_BOX

  745.           }

  746.           Fl_Button {} {

  747.             label {@square}

  748.             callback {set_mode(STOP);

  749. control.stopplay();}

  750.             tooltip Stop xywh {155 500 40 20} box PLASTIC_UP_BOX

  751.           }

  752.         }

  753.         Fl_Value_Slider seek_slider {

  754.           label Percents

  755.           callback {control.set_seek_pos(o->value()/o->maximum());}

  756.           xywh {205 490 780 20} type {Horz Knob} box THIN_UP_BOX color 16 selection_color 4 align 6 maximum 100 textsize 14

  757.         }

  758.       }

  759.     }

  760.     Fl_Window aboutwindow {

  761.       label {About...}

  762.       xywh {274 354 300 170} type Double color 7 hide modal

  763.     } {

  764.       Fl_Button {} {

  765.         label OK

  766.         callback {aboutwindow->hide();}

  767.         xywh {110 140 64 20}

  768.       }

  769.       Fl_Box {} {

  770.         label {Copyright (c) 2006-2011 Nasca Octavian PAUL, Tg. Mures, Romania}

  771.         xywh {10 93 280 37} align 128

  772.       }

  773.       Fl_Box {} {

  774.         label {This is a software for extreme time stretching of the audio.}

  775.         xywh {5 53 290 32} align 128

  776.       }

  777.       Fl_Box {} {

  778.         label {Paul's Extreme Sound Stretch}

  779.         xywh {20 6 255 21} labelfont 1 align 128

  780.       }

  781.       Fl_Box {} {

  782.         label version

  783.         xywh {20 26 255 19} labelfont 1 align 128

  784.         code0 {o->label(VERSION);}

  785.       }

  786.     }

  787.   }

  788.   Function {set_mode(Mode mode)} {private

  789.   } {

  790.     code {switch (mode){

  791. 	case STOP:

  792. 		play_button->labelcolor(FL_BLACK);

  793. 		mode_choice->activate();

  794. 		freeze_button->deactivate();

  795. 	break;

  796. 

  797. 	case PAUSE:

  798. 		play_button->labelcolor(FL_BLACK);

  799. 		mode_choice->activate();

  800. 	break;

  801. 	

  802. 	case PLAY:

  803. 		play_button->labelcolor(FL_RED);

  804. 		mode_choice->deactivate();

  805. 		fftsize_slider->labelcolor(FL_BLACK);

  806. 		freeze_button->activate();

  807. 	break;

  808. 	

  809. 	case FREEZE:

  810. 		if (control.is_freeze()) freeze_button->labelcolor(FL_GREEN);

  811. 			else freeze_button->labelcolor(FL_BLACK);

  812. 	break;

  813. };

  814. window->redraw();} {}

  815.   }

  816.   Function {refresh()} {open

  817.   } {

  818.     code {double stretch_s=stretch_slider->value()/stretch_slider->maximum();

  819. 

  820. int mode=mode_choice->value();

  821. double resolution_s=fftsize_slider->value()/fftsize_slider->maximum();

  822. 

  823. control.set_stretch_controls(stretch_s,mode,resolution_s);

  824. 

  825. stretch_slider->copy_label(control.get_stretch_info().c_str());

  826. fftsize_slider->copy_label(control.get_fftsize_info().c_str());

  827. resolution_box->copy_label(control.get_fftresolution_info().c_str());

  828. 

  829. bool may_render=false;

  830. if (infilename_output->label()!=NULL){

  831. 	if (strlen(infilename_output->label())!=0)  

  832. 	  may_render=true;

  833. };

  834. if (!rendering){//do not change the status of render button while rendering

  835. 	if (may_render) {

  836. 		render_button->activate();

  837. 		render_menu->activate();

  838. 	} else {

  839. 		render_button->deactivate();

  840. 		render_menu->deactivate();

  841. 	};

  842. };} {}

  843.   }

  844.   Function {refreshgui()} {open

  845.   } {

  846.     code {stretch_slider->value(control.gui_sliders.stretch_s);

  847. fftsize_slider->value(control.gui_sliders.fftsize_s);

  848. mode_choice->value(control.gui_sliders.mode_s);

  849. window_choice->value(control.window_type);

  850. 

  851. 

  852. 

  853. pitch_shift_enabled->value(control.ppar.pitch_shift.enabled);

  854. pitch_shift_cents->value(control.ppar.pitch_shift.cents);

  855. 

  856. octave_enabled->value(control.ppar.octave.enabled);

  857. octave_om2->value(control.ppar.octave.om2);

  858. octave_om1->value(control.ppar.octave.om1);

  859. octave_o0->value(control.ppar.octave.o0);

  860. octave_o1->value(control.ppar.octave.o1);

  861. octave_o15->value(control.ppar.octave.o15);

  862. octave_o2->value(control.ppar.octave.o2);

  863. 

  864. freq_shift_enabled->value(control.ppar.freq_shift.enabled);

  865. freq_shift_Hz->value(control.ppar.freq_shift.Hz);

  866. 

  867. compressor_enabled->value(control.ppar.compressor.enabled);

  868. compressor_power->value(control.ppar.compressor.power);

  869. 

  870. filter_enabled->value(control.ppar.filter.enabled);

  871. filter_stop->value(control.ppar.filter.stop);

  872. filter_low->value(control.ppar.filter.low);

  873. filter_high->value(control.ppar.filter.high);

  874. filter_hdamp->value(control.ppar.filter.hdamp);

  875. 

  876. harmonics_enabled->value(control.ppar.harmonics.enabled);

  877. harmonics_freq->value(control.ppar.harmonics.freq);

  878. harmonics_bandwidth->value(control.ppar.harmonics.bandwidth);

  879. harmonics_nharmonics->value(control.ppar.harmonics.nharmonics);

  880. harmonics_gauss->value(control.ppar.harmonics.gauss);

  881. 

  882. spread_enabled->value(control.ppar.spread.enabled);

  883. spread_bandwidth->value(control.ppar.spread.bandwidth);

  884. 

  885. 

  886. tonal_vs_noise_enabled->value(control.ppar.tonal_vs_noise.enabled);

  887. tonal_vs_noise_preserve->value(control.ppar.tonal_vs_noise.preserve);

  888. tonal_vs_noise_bandwidth->value(control.ppar.tonal_vs_noise.bandwidth);

  889. 

  890. bbpar_mono->value(control.bbpar.mono);

  891. bbpar_stereo_mode->value(control.bbpar.stereo_mode);

  892. 

  893. 

  894. stretch_multiplier_control->refresh();

  895. arbitrary_filter_control->refresh();

  896. binaural_beats_control->refresh();} {}

  897.   }

  898.   Function {tickrefresh()} {} {

  899.     code {seek_slider->value(seek_slider->maximum()*control.get_seek_pos());

  900. 

  901. if (playing_for_button&&control.playing()){

  902. 	play_button->labelcolor(FL_GREEN);

  903. 	window->redraw();

  904. 	playing_for_button=false;

  905. };

  906. if (eof_for_button&&control.playing_eof()){

  907. 	play_button->labelcolor(FL_BLACK);

  908. 	window->redraw();

  909. 	eof_for_button=false;

  910. };

  911. 

  912. if (control.info.render_percent>0.0){

  913. 	render_percent_slider->value(control.info.render_percent);

  914. };

  915. if (infilename_output->new_drag_file){

  916.     open_input_file(infilename_output->drag_file.c_str());

  917.     infilename_output->new_drag_file=false;

  918. };} {}

  919.   }

  920.   Function {tickdraw(GUI *o)} {return_type {static void}

  921.   } {

  922.     code {o->tickrefresh();} {}

  923.   }

  924.   Function {tick(void *v)} {return_type {static void}

  925.   } {

  926.     code {tickdraw((GUI *) v);

  927. Fl::add_timeout(1.0/3.0,tick,v);//3 fps} {}

  928.   }

  929.   decl {Control control;} {}

  930.   decl {bool playing_for_button;} {}

  931.   decl {bool rendering;} {}

  932.   decl {bool eof_for_button;} {}

  933. } 

  934. 

  935. Function {file_exists(const char *filename)} {return_type bool

  936. } {

  937.   code {struct stat buf;

  938. int i = stat ( filename, &buf );

  939. // File exists

  940. if ( i == 0 ) return true;

  941.   else  return false;} {}

  942. } 

  943. 

  944. Function {main(int argc, char *argv[])} {open return_type int

  945. } {

  946.   code {GUI *gui=new GUI();

  947. 

  948. 

  949. if (argc>1){

  950. 	const char *filename=argv[1];

  951. 	if (filename[0]=='-'){

  952. 		if (argc>2) filename=argv[2];

  953. 		else filename=NULL;

  954. 	};

  955. 	if (filename) gui->open_input_file(filename);

  956. };

  957. gui->window->show();

  958. 

  959. 

  960. Fl::run();

  961. 

  962. delete gui;

  963. 

  964. return 0;} {selected

  965.   }

  966. }