/*


------------------- T O P   S E C R E T   C O D E   S T A R T S . . .   H E R E !


ATT FIXA:

ta bort all skum debug!

r det inte nn puka (flatulence ass) som fortfarande inte tajmar rtt? (kolla floor tomen...)

gr en fadeout/fade d en sampling mste ersttas av en annan s det inte klickar (eller lt DrumReaplacer vlja hur mnga rster som ska anvndas...)
-- typ s hr: lt det finnas en rst mer n vad fadern sger och skapa en voice_strength buffer (en fr varje rst) och nr det blir fler samplingar n rster brjar man minska (fort!) voice_strength 
fr den ldsta samplingen, och nr den r 0 stnger man av voicen och stter strength till 1 (100%) igen

g igenom "hitta samplingar" och kolla om alla variabler verkligen mste finnas med (skriv om frn scratch?)

borde man matcha transient peak mot transient peak istllet fr den skumma "starten" jag hittat p? knns mer logiskt men om det jag har funkar s...

(gr en ny strength grej)
Ska velocity stretch vara en egen slider? (i procent 0-100%)



gr en verfringstabell ver hur samplingarna sorteras om, s "rtt" sampling kan visas p slider (och som frberedelse fr GUI...)

rensa koden p variabler som inte behvs
ta bort all debug

borde den randoma lite d den varierar vlken sample det ska bli? s det inte blir ett mnster i't (typ 1,2,3,1,2,3 osv)

testa att ndra pdc istllet fr prelay (ev i kombination med en max_prelay s den inte knns saggig)

en smartare laddgrej (s den inte lser hela reaper) 

frigr minne ifall man laddar en mindre sampling efter en strre
se till att anvndaren inte kan ndra No of samples found och Status

Gr en effektivare downsampling
Stealth mode (skriv samplingarna till en variabel istllet fr till spl0 och 1 och gr typ en kompressor i slutet)
Ska den automatiskt strcka ut dynamiken ifall den starkaste samplingen inte r srskilt stark?

gr det till ett val att splitta med thresholds x

 



FIXAT:

Testa alla samplinga
- en p floor tom r knasig (6), den ha 0 i prelay - vad hade den innan jag nollade alla som var p minus?
- ah den var jttemyket minus...
- tjohoo! jag hade sskrivit == oistllet fr = s om samplingsstarten fanns i mode2 vntan s kom den inte med!


Nu funkar spl_prelay (den flyttas inte runt i minnet lngre
- Varfr r det s lng prelay?
- funkar alignmenten?
- den hittar starten perfekt... vnta nu, spl_start r nu vid samplingsstarten...
varfr funkar inte mid tomen? fr att den r mono? och r det relaterat till att ljudkvaliteten suger?
- jag har testat att bara spela upp ur minnet alla samplingarna och d nollar det helt om man lgger samplingen p ett annat spr och fasvnder, s det r inget fel p inlsningen frn fil till minne
- nollar ven nr jag spelar upp sampling fr sampling
-- kan det ha med strength att gra?
- ven om man kar global_pdc till nt jttehgt s missar DR starten p hi_tom samplingarna (efter starten funkar den som den ska)
- och det gller ven om man tar bort funktionen som kortar prelayen om den r fr lng
- filen ser bra ut?
- kolla om det r nt fel p hitta samplingarna
- testa att spela upp hela minnet och markera samplingsstarterna (fr att se om felet ligger i 'hitta samplingarna' eller i 'uppspelningen'
- ja det gr den (nu funkar spl_start, men kolla s at tden verkligen hittar hgsta peaken om den ligger inom min_silence, ass just i brjan)
- kom ihg att snka global_pdc
- sl p sorteringen av samplingarna
-- sl p pdc kollen (eller gr en bttre dr pdc:n anpassas till prelayen...)
(- testa om det funkar (kom ihg att du mste gra en /nch*2 i prelayen i triggern))
(-- varfr funkar fortfarande inte hi-tomen?)
(-- kolla om det inte gr att f spl_start senare nd (s det inte blir s lng prelay))
-- nu hittar den "starten" av samplingarna i triggern, gr samma i "Hitta samplingarna"


problemet r att den inte hittar rtt peak
- ta bort RMS:en och lgg in en envfollower istllet
- nu hittar den rtt peak men prelayen verkar vara t fanders
- ndradee ngra env till in i Hitta samplingarna vilket (kanske?) fixade prelayen
- ytterligare ett problem var hysterisis som ju blir rtt beroende av releasen p env, kanske bara ska ta bort hysterisen helt och hllet? Eller minska den rejlt?


(- verkar vara det, peaken blir p samma stlle varje gng
ls det problemet
- testar att snka rmsen till en sampling, dvs man skulle inte behva nn rms egentligen 
funkar med vissa samplingar, men inte med alla t ex (hi tom...))


Fr att fixa nedan fulndrar den bara prelayen utan hnsyn till hur det lter. Men det fubnkar:
kolla s att prelayen inte r lngre n pdc:n (+ vad det nu r) och i s fall ndra pdc:n
- (ID! Man skulle kunna gra en max tid frn start till max_pos)

Varfr blir det tyst ibland nr man drar upp Dynamics?
- fr att sampling no 1 fick en toklng prelay som inte rymdes inom pdcn


ndra s att threshold startar p 0 db istllet fr -18 db
ndra skalan p opriginal signal och replaced till 0-200%

Lgg in en sprr s man inte kan ladda fr stora samplingar (max = 8388607 vrden)

testa hur hg max_wait ska va 30ms 50ms?

Kalibrerat max_wait (gjort den lgre) hysterisis (kat den) och rms fnstret (gjort det lite mindre) s den stter samplingarna mycket bttre

Kolla hur stora filer man kan ladda (8388607 vrden)

lgg slajdrarna i rtt ordning

En dynamics slider

fixa s den inte hittar fr mnga samplingar d man laddar en liten efter en stor - ndrade slut villkoret frn buf_size till conv_nnting_end

Bygg ihop m trigger och samplingshittar-delen

KOlla att kollen att srate inte r 0 (s den inte hnger sig om man laddar en sampling d srate r = 0) funkar

Gr en bra SRC... hur? Gr den nr samplingarna tankas in iaf (och mste lsas in igen om srate ndr as)

Titta ver (skriv om?) samplingsseparatorn, kolla p den som redan finns

separera max_wait och retrigger (ass gr en riktig retrigger)

Fixa minnesanvndningen: lgge variabler i botten och ljude ovanfr
Lgg max waiten p slider
Gr en slider fr samplingarnas styrka (som original mix), typ replaced signal

Gr Round robin
Kirrat, gjorde en buffer fr voice_strength - Gr s den anpassar samplingens styrka efer slagets
Verkar inte vara s lngre - Varfr hittar den olika spl_max om man laddar samma sampling flera gnger? (spelar det nn roll, ass hur stor r skillnaden?)Kolla att valet av sampling stmmer
Nu funka auto-spliten med digital tystnad
Gr s den vljer rtt sampling att erstta med
Gr sortera samplingarna grejen

gR EN RETRIGGER INTERVAL - kade bara max_waiten, borde den ligga p slider?

Se till att prelayen funkar lt den slumpa en samplin och triga den rtt


BL! Det var fr att jag hade dragit ut en sampling som loopade, nr jag Glueade den s funkar allt som vntat...
Kolla varfr detectorn ibland missat slag som r identiska som andra slag den hittar...
- det r trigger som missar, inte uppspelaren
- olika vrden p olika slag oavsett rms - ska man gra en open/close grej... fler trig_mode ass

OK
- det verkar som att prelayen funkar rtt (fast den r hlften s lng som slider visar... men s ska det nog vara)
- d mste det ju vara spl_prelay vrdena p spl 2 och uppt som r p tok
LST! Det blev helt bisarrt stora prelayvrden, stre n global_pdc och d funknar det ju int. nu har jag ndrat global PDC till 1 sekund och d funkar det
ID! Man skulle kunna gra en max tid frn start till max_pos

delaya ljudet och fixa pdc
Gr hit detection svngen p input
Gr ytterligare en rms i sample detect svngen, en som  har samma storlek som den i hit detection (kolla i gamla replacern)
det var kvar skrp i buffrarna - Nu hittar den rtt antal samplingar, men visar (ibland) fel tills man trycker play
Kolla att alla samplingar lter (verkar s nu...)
flyttade slutpunkten till mellan de tv RMS:erna som jmfrs > KOlla varfr det kommer ett litet klick i slutet av samplingarna (ibland?)
ext_noinit=1 fixade det > Varfr blir det MAX ksrp nr man frtsa gngen stter p play och triggar en sampling? Byt till en annan och byt tbka s funkar det...
Stmmer latencyn eller mste den omrknas ifall samplingsfrekvenserna inte stmmer? Rkna om tror jag, gngra med srate / file_srate



fil

threshold
replaced signal
original signal
dynamics
retrig
force variation

stealth

meter - no of samples found
meter - Output sample
status

1-1 fil
2
7-3 threshold
9-4 retrig
10-5 dynamics
8-6 force variation
3-7 no of voices
8
4-9 original signal
5-10 replaced signal
--11 stealth

6-13 meter - no of samples found
12-14 meter - Output sample
--15 status


11-6
12-7
5-9
6-11
7-12
9-14
10-15
13-17
14-18
15-19


*/





desc:DrumReaplacer 1.095
slider1:/DrumReaplacer:none:Sample source file

slider3:0<-80,0,0.1>Threshold (dB)
slider4:80<0,200,1>Retrigger interval (ms)

slider6:-12<-80,0,0.1>Solidify above (dB)
slider7:-6<-80,0,0.1>Solidify below (dB)
slider8:0<0,100,1>Solidify (%)
slider9:100<0,200,1>Velocity (%)

slider11:20<0,100,1>Force variation (%)
slider12:2<1,5,1>Voices

slider14:0<0,200,1>Original signal (%)
slider15:100<0,200,1>Replaced signal (%)

slider17:0<1,64,1>Meter: Samples found
slider18:0<0,64,1>Meter: Output sample
slider19:1<1,3,1{File loaded OK,No file loaded,File too large,Loading file...}>Status



@init

rms_comp_thres = 0.002;



rms_window_size = ( 10 / 1000 ) * srate;    //storlek p rms fnstret
rms_pos = 0;            //nollstller rknaren


//debug
tmptmp = 0;
tmptmp2 = 0;
debug = 0;
splplaying = 0;

max_memory = 8388607;    //max antal vrden i det lokala minnet
safety_margin = 1000;    //skerhetsmarginal 
max_memory -= safety_margin;

ext_noinit = 1;

next_voice = 1;
max_no_of_voices = 16;

scale = log( 10.0 ) * 0.05;   // precalculate this once

hysterisis = 1.5;

trig_mode = 0;

max_wait = 10 * 0.001 * srate;  //sk hgsta peak X ms efter att threshold passerats



min_silence = ceil( srate / 20 );  //hur lngt det mste vara mellan samplingarna

rel_db = 25;      //envelope release i dB per sekund
rel = exp( rel_db  * scale ) / srate;



//-------------------------- S L I D E R
@slider

dynamics = ( slider9 ) / 100;

threshold = exp( slider3 * scale );

cl_threshold = exp( ( slider3 - hysterisis ) * scale );

retrig_interval = slider4 * 0.001 * srate;  //sk hgsta peak X ms efter att threshold passerats

no_of_voices = slider12;
original_signal = slider14 / 100;
replaced_signal = slider15 / 100;

solidify_max = exp( slider7 * scale );
solidify_min = exp( slider6 * scale );
solidify_amount = 1 - ( slider8 / 100 );

tmpslider = slider1|0;    //ska det vara |0?

tmpslider != prev_slider1 ?
(
  load_file = 1;
);
prev_slider1 = slider1 ;

//Round robin - se till att man inte kan stta den slider hgre n antalet samplingar - 1

old_rr = ceil( ( no_of_samples - 1 ) * ( slider11 / 100 ) );

rr_buf_size = old_rr - 1;  

//Nollstll rr_buffer om man ndrar slidern (s den inte "fastnar" p fel sampling)
tmpslider = slider11;
tmpslider != prev_slider11 ?
(
  tmp_counter = 1;
  loop( no_of_samples,
    spl_max[ tmp_counter ] < 0 ? spl_max[ tmp_counter ] += 10;
    tmp_counter += 1;  
  );
  memset( rr_buf, 0, 16 );  //nolla rr-buffern
);
prev_slider11 = tmpslider;







@block

prev_srate != srate ? load_file = 1;
prev_srate = srate;

load_file == 1 || global_pdc == 0 ?
(
  global_pdc = floor( srate * 0.200 + max_wait );  //frdrj allting en stund och kompensera fr det

  pdc_delay = global_pdc;

  pdc_bot_ch = 0;
  pdc_top_ch = 2;        //kompensera bara ljudkanal 1 o 2
  
  audio_bufsize = global_pdc * 2;    //*2 fr att det ju r stereo
);

load_file == 1 ?
(

  load_file = 0;

  filehandle = file_open(slider1);
  filehandle > 0 && srate != 0 ?
  (

    file_riff( filehandle, nch, file_srate );    //kolla srate & antal kanaler
    nch ? buf_size = file_size = file_avail( filehandle ) ;   //kolla hur stor den r

    nch_add = floor( nch / 2 ); 



//-------------------------- G E   P L A T S   I   M I N N E T 

    audio_buf = 1000;
    trig_buf = audio_buf + audio_bufsize + 2;
    memset( trig_buf, 0, audio_bufsize );

    bufpos = trig_buf + audio_bufsize + 2;            //en per rst, hller reda p var den rsten r i buffern
    voice_on = bufpos + max_no_of_voices + 1;

    //den nya rmsen (fr att hitta transienter o drmed samplingsstarten)

    rms_buf = voice_on + max_no_of_voices + 1;    //hr brjar rms buffern
    rms_archive = rms_buf + rms_window_size + 2;  //o hr brjar buffern fr rms_total

    //slut p den nya rmsen 

    spl_start = rms_archive + rms_window_size + 2;
    spl_end = spl_start + 64 + 1;  //stdjer upp till 64 samplingar m andra ord
    spl_max = spl_end + 64 + 1;
    spl_prelay = spl_max + 64 + 1;

    voice_sample = spl_prelay + 64 + 1;
    voice_strength = voice_sample + max_no_of_voices + 1;

    rr_buf = voice_strength + max_no_of_voices + 1;  
    memset( rr_buf, 0, max_no_of_voices );


//------------------------------ M e m o r y   c h e c k

    file_too_large = 0;
    file_srate > srate && ( rr_buf + 16 + 1 + 80 + file_size * ( srate / file_srate ) ) > max_memory ? file_too_large = 1;  //Downsampling MC
    file_srate == srate && ( rr_buf + 16 + 1 + file_size ) > max_memory ? file_too_large = 1;          //No resampling MC
    file_srate < srate && ( rr_buf + 16 + 1 + file_size * ( srate / file_srate ) ) > max_memory ? file_too_large = 1;    //Upsampling MC

    file_too_large == 0 && slider1 == 0 ? ( slider19 = 1; sliderchange( slider19 ); no_of_samples = 0;);  //om frsta filen (choose file...) r vald, skriv no file loaded och speal inte upp nt
//  file_too_large == 0 && slider1 != 0 ? ( slider19 = 3; sliderchange( slider19 ); );        //om filen inte r fr stor och det inte r frsta filen, skriv File loaded OK

    file_too_large == 1 ? 
    ( 
      slider19 = 2; sliderchange( slider19 );   //skriver file too large
      no_of_samples = 0;       //ser till att det inte spelas upp nt
      slider17 = 0; sliderchange( slider17 );  //skriver samples found 0
    );


file_too_large != 1 ?
(

//------------------------------ S R C

//Nersampling i mono och stereo funkar nu bra men tar jttelng tid. Var den snabbare frut?
//Samma srate funkar finfint
//Uppsampling funkar finfint



//------------------------------ D o w n s a m p l i n g

    file_srate > srate ?
    (
  
      temp_start_pos = rr_buf + 16 + 1;      //hr brjar ljudfilssnuttarna i minnet
      start_pos = temp_start_pos + 80;      //utrymme fr temp... sen brjar den konverterade ljudfilen
      last_read_pos = conv_pos = tmp_total = tmp_total_R = exact_pos = 0 ;
      step = file_srate / srate ;



      while
      (
        while
        (

    exact_pos += step;
    file_mem( filehandle, temp_start_pos, ( ceil( exact_pos ) - last_read_pos ) * nch );  //ls in en snutt  
          samples_read = ( ceil( exact_pos ) - last_read_pos ) * nch;        //s mycket lste jag in

          last_read_pos = ceil( exact_pos );            //spara senast inlsta position i last_read_pos


    //Hr lser man in alla "hela" samplingar (utom den sista) 
    tmp_pos = 0;
    samples_read > nch ?
    (
            loop( ( ( samples_read - nch ) / nch ) , 
        tmp_total += temp_start_pos[ tmp_pos ];
              nch > 1 ? tmp_total_R += temp_start_pos[ tmp_pos + 1 ];
        tmp_pos += nch;
      );
    );

     part = exact_pos - floor( exact_pos );            //S stor del av den sista inlsta samplingen som ska med i den konverterade samplingen
    tmp_total += temp_start_pos[ tmp_pos ] * part;          //lgg till det i tmp_total
    nch > 1 ? tmp_total_R += temp_start_pos[ tmp_pos + 1 ] * part;      //lgg till det i tmp_total_R (hger kanal) om det r stereo

      start_pos[ conv_pos ] = tmp_total / step;          //och skriv till den konverterade samplingen
          nch > 1 ? start_pos[ conv_pos + 1 ] = tmp_total_R / step;

          conv_pos += nch;  

    tmp_total = temp_start_pos[ tmp_pos ] * ( 1 - part );        //flytta det som "blev ver" till tmp_total s det kommer med i nsta konverterade sampling
          tmp_total_R = temp_start_pos[ tmp_pos + 1 ] * ( 1 - part );

          last_read_pos + step < file_size ;            //egentligen en fuling, den kan ju missa lite, lite information i slutet
        );

        last_read_pos + step < file_size ;            //dubbla while fr att filen kan vara strre n max fr en while (typ en miljon)
      );

      conv_file_end = conv_pos;
      file_close(filehandle);        //och stnger filen


    );    //sluter downsamplingen




//-------------------------------- U p s a m p l i n g

    file_srate < srate ?
    (

      start_pos = rr_buf + 16 + 1;  //hr brjar den konverterade filen s smningom
      temp_start_pos = ceil( ( ( srate / file_srate ) * buf_size ) + start_pos - buf_size ) ;  //lgger temp_pos s den okonverterade filen slutar p samma stlle som den konverterade sen ska gra

      file_mem( filehandle, temp_start_pos, buf_size );  //lser in filen

      step = file_srate / srate;
      conv_pos = exact_pos = 0;


      //mono 
      nch == 1 ?
      (

        while
        (
          while
          (
  
            tmp = exact_pos - floor( exact_pos );
            start_pos[ conv_pos ] = ( temp_start_pos[ floor( exact_pos ) ] * ( 1 - tmp ) ) + ( temp_start_pos[ ceil( exact_pos ) ] * tmp );            //lgg ihop dem
  
            exact_pos += step;
            conv_pos += 1;

            exact_pos < buf_size;  
          );
    
        exact_pos < buf_size;
        );

      ):(

        //stereo
        buf_size_div_by_2 = buf_size / 2;

        while
        (
          while
          (
  
            tmp = exact_pos - floor( exact_pos );
            start_pos[ conv_pos ] = ( temp_start_pos[ floor( exact_pos ) * 2 ] * ( 1 - tmp ) ) + ( temp_start_pos[ ceil( exact_pos ) * 2 ] * tmp );                //lgg ihop dem
            start_pos[ conv_pos + 1 ] = ( temp_start_pos[ ( floor( exact_pos ) * 2 ) + 1 ] * ( 1 - tmp ) ) + ( temp_start_pos[ ( ceil( exact_pos ) * 2 ) + 1 ] * tmp );                //lgg ihop dem
 
            exact_pos += step;
            conv_pos += 2;

            exact_pos < buf_size_div_by_2 ;  
          );
    
          exact_pos < buf_size_div_by_2 ;
        );

      );


      conv_file_end = conv_pos - 1;
      file_close(filehandle);        //och stnger filen

    );  //sluter upsamplingen

//----------------------------------- N o   r e s a m p l i n g

    file_srate == srate ?
    (
      start_pos = rr_buf + 16 + 1;
      file_mem( filehandle, start_pos, buf_size );  //ls in filen  
      file_close(filehandle);      //och stng filen
      conv_file_end = buf_size;  

    );  //sluter ingen resampling




//--------------------------------- T H E   E N D   O F   S R C   ( a s   w e   k n o w   i t ) 











//-------------------------- H I T T A   S A M P L I N G A R N A --------------------------------------------

// Allt det hr borde dras in tv steg till vnster men...


    spldet_read_pos = spldet_since_new = spldet_z_in_row = time_in_mode_1 = 0;

    no_of_samples = 0;
    spl_start[ 1 ] = 0;
    spl_end[ 1 ] = buf_size;
    spl_max[ 1 ] = 0;
    tmp_hit_start_pos = -1; 
    rms_pos = 0;    //nollstller rknaren

    //hr borde spl_max nollas (eftersom vrdena jmfrs med tidigare fr att hitta max)
    memset( spl_max, 0, 64 );

    find_mode = 0;  //0 = bara i brjan, vntar p nt annat n noll, 1 = vntar p X antal nollor, 2 = vntar p nt annat n noll


    //dubbla while fr att grnsen fr en while r typ 1 miljon och filerna kan ju ha fler samples n s
    while(
      while( 

        //Envelope
        in = max( abs( start_pos[ spldet_read_pos ] ), abs( start_pos[ spldet_read_pos + nch_add ] ) );
  env = in > env ? in : max( env - rel, in );

  //RMS
  rms_total = rms_total - rms_buf[ rms_pos ] + env;
  rms_buf[ rms_pos ] = env;
  rms_this_spl = rms_total / rms_window_size;

  rms_archive[ rms_pos ] = rms_this_spl;    //spara rmsen s man kan jmfra hur stor den var i brjan med hur stor den r i slutet av fnstret

  rms_pos += 1;
  rms_pos > rms_window_size ? rms_pos = 0;
  
  prev_rms_comp = rms_comp;
  rms_comp = rms_this_spl - rms_archive[ rms_pos ];

  prev_rms_comp <= rms_comp_thres && rms_comp > rms_comp_thres ? tmp_hit_start_pos = spldet_read_pos;  //om den var negativ och har blivit positiv kan det vara starten p en sampling


        find_mode == 0 ? 
        (
          //de tv sista ("spldet_since_new = 0; spl_start [ 1 ] = spldet_read_pos;") nedan fr att spl no 1 annars fr jttelng prelay (lngre n pdc)
          in != 0 ? 
          ( 
      find_mode = 1; 
      no_of_samples += 1; 
      spldet_since_new = 0; 
      spl_start [ 1 ] = max( ( spldet_read_pos - nch ), 0 ); 
            spl_prelay[ 1 ] = -1;
          );
        );

        find_mode == 1 ?
        (

    tmp_hit_start_pos != -1 && spl_prelay[ no_of_samples ] == - 1 ? spl_prelay[ no_of_samples ] = tmp_hit_start_pos - spl_start[ no_of_samples ] ;  //den frsta transienten i en sampling r samplingsstarten (det r tesen iaf)

          env > spl_max[ no_of_samples ] ? 
          ( 
            spl_max[ no_of_samples ] = env; 
          );

          in == 0 ? spldet_z_in_row += 1 : spldet_z_in_row = 0;

          spldet_z_in_row > min_silence ?
          (
            spl_end[ no_of_samples ] = spldet_read_pos - min_silence * nch;  // - min_silence fr att samplingen egentligen tar slut dr raden av nollor brjar

            find_mode = 2;

            tmp_start = -1;
            spl_max[ no_of_samples + 1 ] = 0;    //bara ifall det kommer en sampling till
            spl_prelay[ no_of_samples + 1 ] = -1;  //bara ifall det kommer en sampling till
      tmp_hit_start_pos = -1;      //bara s man vet att den inte anvnts
            hit_start_pos = -1;
            could_be = 0;

            time_in_mode_2 = 0;
            spldet_z_in_row = 0;

          );

          time_in_mode_1 += 1;

        );            //sluter find_mode == 1

        find_mode == 2 ?
        (
          in != 0 ? could_be = 1;

          could_be == 1 ? 
          (
            tmp_start == -1 ? tmp_start = spldet_read_pos;

            tmp_hit_start_pos != -1 && hit_start_pos == -1 ? hit_start_pos = tmp_hit_start_pos ;  //ifall den frsta transienten ligger tidigt (inom min_silence)

      env > spl_max[ no_of_samples + 1 ] ? 
            ( 
              spl_max[ no_of_samples + 1 ] = env; 
            );

            time_in_mode_2 > min_silence ?
            (

              find_mode = 1;
              time_in_mode_1 = 0;  //nollar den infr nsta sample

              no_of_samples += 1;

              spl_start[ no_of_samples ] = tmp_start ;
              tmp_hit_start_pos != -1 ? spl_prelay[ no_of_samples ] = hit_start_pos - tmp_start ; 

              spl_end[ no_of_samples ] = buf_size;  //ifall inget slut hittas
              //spl_max[ no_of_samples ] = 0;
              spldet_since_new = 0;
            );

          );

          time_in_mode_2 += 1;

        );            //sluter find_mode == 2

        spldet_since_new += 1;
        spldet_read_pos += ( 1 + nch_add );

        spldet_read_pos < conv_file_end;  //brukade vara buf_size - sluter frsta whilen
      );

      spldet_read_pos < conv_file_end;    //brukade vara buf_size - sluter andra whilen
    );



//--- DEBUG stter markrer p spl_start och samplinggsstarten (ass prelayen) och skriver prelay till gmem

/*
    tmp = 1;

    loop( no_of_samples,

      start_pos[ spl_start[ tmp ] ] = -1;
      start_pos[ spl_start[ tmp ] + spl_prelay[ tmp ] ] = 1;

      //spl_prelay[ tmp ] = tmp;
      gmem[ 665 + tmp ] = spl_prelay[ tmp ];

      tmp += 1;

    );
*/

//--------------- Kollar s att prelayen inte r strre n pdcn och justerar i s fall prelayen (man skulle ju kunna ndra pdcn istllet men...) OCH tar bort negativ prelay

    tmp = 1;

    loop( no_of_samples,

      spl_prelay[ tmp ] < 0 ? spl_prelay[ tmp ] = 0;

      //kollar s att prelayen p samplingen som just hittats inte r fr stor
      ( spl_prelay[ tmp ] / nch ) > global_pdc ? 
      (
        spl_start[ tmp ] = spl_start[ tmp ] + spl_prelay[ tmp ] - ( global_pdc * nch ) ;
        spl_prelay[ tmp ] = ( global_pdc * nch ) ;
      );

      tmp += 1;

    );



//--------------- Sortera samplingarna

// DEBUG

    tmplap = 1;

    loop( no_of_samples,

      tmp = 1;
      tmpmax = 0;
      tmpmaxsplno = 0;

      loop( no_of_samples,
  spl_max[ tmp ] > tmpmax ? 
  (
    tmpmax = spl_max[ tmp ];
          tmpmaxsplno = tmp;
  );

      tmp += 1;
      );

      tmpmaxsplno != tmplap ? 
      (
        //flytta det som ligger i den hr vndans nummer (1, 2 osv) till tmp    
        tmp_start = spl_start[ tmplap ];
        tmp_end = spl_end[ tmplap ];
        tmp_max = spl_max[ tmplap ];
        tmp_prelay = spl_prelay[ tmplap ];

        //flytta vrdena fr det starkaste slaget till vndans nummer
        spl_start[ tmplap] = spl_start[ tmpmaxsplno ];
        spl_end[ tmplap] = spl_end[ tmpmaxsplno ];
        spl_max[ tmplap] = spl_max[ tmpmaxsplno ] * -1;  //negativt s det inte ska bli starkast nsta varv x
        spl_prelay[ tmplap] = spl_prelay[ tmpmaxsplno ];

        //flytta det som tidigare lg i vndans nummer till det nummer dr det starkaste slaget tidigare lg
        spl_start[ tmpmaxsplno ] = tmp_start ;
        spl_end[ tmpmaxsplno ] = tmp_end ;
        spl_max[ tmpmaxsplno ] = tmp_max ;
        spl_prelay[ tmpmaxsplno ] = tmp_prelay ;

      ):(
        spl_max[ tmplap ] *= -1;
      );

      tmplap += 1;

    );

    //gra spl_max positivt igen 
    tmp = 1;
    loop( no_of_samples,
      spl_max[tmp] = ( spl_max[tmp] * -1 )  ;
      tmp += 1;
    );

    //visa hur mnga samplingar du hittat p slider
    slider17 = no_of_samples;
    sliderchange( slider17 );

    //Visa File loaded OK
    file_size > 3 && no_of_samples > 0 ? ( slider19 = 0; sliderchange( slider19 ); );

    );  //sluter file_too_large != 1...  


  );

);










//-------------------------------------- S A M P L E ------------------------------------------------------------------
@sample

slider16 = debug666;
sliderchange( slider16 );

debug == 0 ? (


//Delay
audio_buf[ audio_buf_pos ] = spl0;
audio_buf[ audio_buf_pos + 1 ] = spl1;

trig_buf[ audio_buf_pos ] = trig_buf[ audio_buf_pos + 1 ] = -1;


//Envelope
in = max( abs( spl0 ), abs( spl1 ) );
env = in > env ? in : max( env - rel, in );



//RMS
rms_total = rms_total - rms_buf[ rms_pos ] + env;
rms_buf[ rms_pos ] = env;
rms_this_spl = rms_total / rms_window_size;

rms_archive[ rms_pos ] = rms_this_spl;    //spara rmsen s man kan jmfra hur stor den var i brjan med hur stor den r i slutet av fnstret

rms_pos += 1;
rms_pos > rms_window_size ? rms_pos = 0;

prev_rms_comp = rms_comp;
rms_comp = rms_this_spl - rms_archive[ rms_pos ];

prev_rms_comp <= rms_comp_thres && rms_comp > rms_comp_thres ? ( time_since_rms_zx = 0; tmp_hit_start_pos = audio_buf_pos; );  //om den var negativ och har blivit positiv kan det vara starten p en sampling



spl0 = spl1 = 0;



//Trigger
trig_mode == 0 && env > threshold ? 
(
  trig_mode = 1; 
  wait_for_higher = max_peak = th_close = 0; 
);

trig_mode == 1 ?
(
  env > max_peak ? 
  (
    max_peak = env ;
    max_peak_pos = audio_buf_pos;
    tsrzxampp = time_since_rms_zx;  //tsrzxampp betyder time_since_rms_zx_a_max_peak_pos
    hit_start_pos = tmp_hit_start_pos ;
    time_since_maxpeak = 0;
  );

  env < cl_threshold ? th_close = 1;

  wait_for_higher > max_wait && th_close == 1 ? 
  (

    max_peak < solidify_max && max_peak > solidify_min ? max_peak = solidify_max - ( solidify_max - max_peak) * solidify_amount ;	//om den r inom solidify grnserna, ndra tmpstrength;

    //hitta den sampling som bst matchar den det inkommande slaget

    tmpfind = 1;
    tmpclosest = 10000000;  //bara nt som r strre n strsta skillnaden
    loop( no_of_samples,
      abs( max_peak * dynamics - spl_max[ tmpfind ]) < tmpclosest ?
      (
        tmpclosest = abs( max_peak * dynamics - spl_max[ tmpfind ]);
        tmpstrength = max_peak * ( dynamics / spl_max[ tmpfind ] );
        tmp_spl = tmpfind;
      );
    tmpfind += 1;        
    );      

    tmp_pos = hit_start_pos - ( ( spl_prelay[ tmp_spl ] / nch ) * 2 );
    tmp_pos < 0 ? tmp_pos = audio_bufsize + tmp_pos ;

    trig_buf[ tmp_pos ] = tmp_spl;
    trig_buf[ tmp_pos + 1 ] = tmpstrength ;

    //DEBUG
    //trig_buf[ tmp_pos + 1 ] = 1 ;   //ingen strength   

    //visa vilken sampling som spelas p slider18
    slider18 = tmp_spl;
    sliderchange( slider18 );

    //DEBUG
    //slider16 = spl_prelay[ tmp_spl ]; sliderchange( slider16 );


    //Round robin v2
    rr_buf_size >= 0 ?
    (
      spl_max[ rr_buf[ rr_bufpos ] ] += 10;
      spl_max[ tmp_spl ] -= 10;
      rr_buf[ rr_bufpos ] = tmp_spl;
      rr_bufpos += 1; rr_bufpos > rr_buf_size ? rr_bufpos = 0;
    );

    trig_mode = 2;
    retrig_left = max( 0, ( retrig_interval - time_since_maxpeak ) );
  );
);

trig_mode == 2 ?
(
  retrig_left < 1 ? trig_mode = 0;
);

wait_for_higher += 1;
time_since_maxpeak += 1;
retrig_left -= 1;



//Delay
audio_buf_pos += 2;           //flyttar fram ett snpp s de ldsta vrden ligger p audio_buf_pos-platsen
audio_buf_pos > audio_bufsize ? audio_buf_pos = 0;  

spl0 += audio_buf[ audio_buf_pos ] * original_signal ;
spl1 += audio_buf[ audio_buf_pos + 1] * original_signal ;

//Check trig and manage voices
tmp_trig = trig_buf[ audio_buf_pos ] ;
tmp_trig != -1 && no_of_samples > 0 ? 
(
  voice_sample[next_voice] = tmp_trig ;
  voice_strength[next_voice] = trig_buf[ audio_buf_pos + 1 ];
  bufpos[next_voice] = spl_start[ tmp_trig ];
  voice_on[next_voice] = 1;
  next_voice += 1; next_voice > no_of_voices ? next_voice = 1;   
);



//Play samples
voice = 1;

loop( no_of_voices,

  voice_on[voice] == 1 ?
  (
    spl0 += start_pos[ bufpos[voice] ] * voice_strength[ voice ] * replaced_signal ;
    spl1 += start_pos[ bufpos[voice] + nch_add ] * voice_strength[ voice ] * replaced_signal ;  //nch_add = 0 om det r mono, = 1 om det r stereo

    bufpos[voice] += 1 + nch_add;
    bufpos[voice] > spl_end [ voice_sample[ voice ] ] ? voice_on[voice] = 0;
  );

  voice += 1;
);

//debug
//time_since_rms_zx == 0 ? spl1 = 1;
//tmp_trig != -1 ? spl1 = 1;

time_since_rms_zx += 1;    //rknar hur lngt det var sendan rms skillnaden passerade nollan (fr att hitta samplingsstarter)

/*
//DEBUG
    tmp = 1;

    loop( no_of_samples,
  
      gmem[ 999 + tmp ] = spl_prelay[ tmp ];

      tmp += 1;

    );
*/


);  //sluter debug == 0


























debug == 1 ?
(

  play_state != prev_play_state ? splplaying = 0;
  prev_play_state = play_state;

  splplaying == 0 ? ( tmppos = spl_start[ 1 ]; splplaying = 1; splssincenewspl = 0 );
  spl0 = start_pos[ tmppos ];
  spl1 = start_pos[ tmppos + nch_add ];

  splssincenewspl == 0 ? ( spl0 = 1; spl1 = 1; );
  //splssincenewspl == spl_prelay[ splplaying ] ? ( spl0 = 1; spl1 = 1; );

  tmppos = tmppos + 1 + nch_add;
  splssincenewspl += 1 ;

  tmppos > spl_end[ splplaying ] ? 
  (
    splplaying += 1;
    splssincenewspl = 0;
    tmppos = spl_start[ splplaying ];
    splplaying > no_of_samples ? 
    ( 
      splplaying = 1; 
      //spl0 = -1; 
      //spl1 = -1; 
    );
  );

);  //sluter debug == 1



debug == 2 ?
(

  play_state != prev_play_state ? tmptmp = tmptmp2 = 0;
  prev_play_state = play_state;

  spl0 = start_pos[ tmptmp ];
  spl1 = start_pos[ tmptmp + nch_add ];

  bla = 1;
  loop( no_of_samples,
    tmptmp == spl_start[ bla ] || ( tmptmp + 1) == spl_start[ bla ] ? spl0 = 1;
    tmptmp == floor( spl_start[ bla ] + spl_prelay[ bla ] ) || ( tmptmp + 1) == floor( spl_start[ bla ] + spl_prelay[ bla ] ) ? ( spl1 = 1; slider16 = spl_prelay[ bla ]; sliderchange(slider16); ); 
    bla += 1;
  );



  tmptmp = tmptmp + 1 + nch_add;

  tmptmp2 += 1;


  tmptmp > conv_file_end ? (tmptmp = tmptmp2 = 0; );

  slider16 = spl_start[ 1 ]; sliderchange( slider16 );

);


debug == 3 ?
(
  slider16 = spl_prelay[ tmp ];
  sliderchange( slider16 );
  tmptmp > 44100 ? 
  (
    tmptmp = 0;
    tmp += 1;
  );
  tmp > no_of_samples ? tmp = 1;
  tmptmp += 1;

);

debug == 4 ?
(
  tmp < conv_file_end ?
  (
  spl0 = start_pos[ tmp ];
  spl1 = start_pos[ tmp + nch_add ];
  ):(
  spl0 = ( rand( 200 ) / 100 ) - 1;
  spl1 = 0;
  );

  tmp = tmp + 1 + nch_add;
  tmp > ( conv_file_end + 44100 ) ? tmp = 0;
);
