Subversion Repositories pentevo

Rev

Rev 796 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "bass.h"
  6. #include "snd_bass.h"
  7. #include "gshle.h"
  8. #include "gs.h"
  9. #include "sndrender/sndcounter.h"
  10. #include "sound.h"
  11. #include "util.h"
  12.  
  13. #ifdef MOD_GSBASS
  14. void GSHLE::set_busy(unsigned char newval)
  15. {
  16.    busy = chan[0].busy = chan[1].busy = chan[2].busy = chan[3].busy = newval;
  17. }
  18.  
  19. void GSHLE::reset()
  20. {
  21. //    printf("%s, speed=6\n", __FUNCTION__);
  22.    fxvol = modvol = 0x3F;
  23.    speed = 6;
  24.    make_gs_volume(fxvol);
  25.    to_ptr = data_in; mod_playing = 0;
  26.    used = 0; mod = nullptr; modsize = 0; set_busy(0);
  27.    resetmod(); total_fx = 1;
  28.    memset(sample, 0, sizeof sample);
  29.    memset(chan,  0, sizeof chan);
  30.    memset(&DebugCh, 0, sizeof(DebugCh));
  31.    out(0xBB, 0x23); // send 'get pages' command
  32. }
  33.  
  34. void GSHLE::applyconfig()
  35. {
  36.     // ╧хЁхёўхЄ эюЄ т ухЁЎ√ фы  ЁртэюьхЁэю ЄхьяхЁшЁютрээюую ёЄЁю 
  37.     // https://ru.wikipedia.org/wiki/╨ртэюьхЁэю_ЄхьяхЁшЁютрээ√щ_ёЄЁющ
  38.     // f = f0 * 2^(i/12)
  39.     // f0 = 440Hz (A4) - ┴рчютр  ўрёЄюЄр (i=0)
  40.     // ═юЄр | ╚эфхъё ёЄхяхэш | ═юЄр GS
  41.     // -----+----------------+---------
  42.     // C0:  | i=-9-4*12=-57  | 0
  43.     // C1:  | i=-9-3*12=-45  | 12
  44.     // C2:  | i=-9-2*12=-33  | 24
  45.     // C3:  | i=-9-1*12=-21  | 36
  46.     // C4:  | i=-9+0*12=-9   | 48
  47.     // C5:  | i=-9+1*12=3    | 60 // ▌Єющ эюЄх ёююЄтхЄёЄтєхЄ ёЄрэфрЁЄэр  ёъюЁюёЄ№ яЁюшуЁ√трэш  214 яхЁшюфют ухэхЁрЄюЁр эр Amiga
  48.     // C6:  | i=-9+2*12=15   | 72
  49.     // C7:  | i=-9+3*12=27   | 84
  50.  
  51.  
  52.     // ╨рёўхЄ ўрёЄюЄ тёхї эюЄ
  53.     int i;
  54.     for(i = -57; i <= 27; i++)
  55.     {
  56.         note2rate[i + 57] = float(440.0 * pow(2.0, double(i) / 12.0));
  57.     }
  58.     for(; i + 57 < int(_countof(note2rate)); i++)
  59.     {
  60.         note2rate[i + 57] = note2rate[57+27];
  61.     }
  62.  
  63.     const double C5 = double(note2rate[60]);
  64.  
  65.     // ╧ххЁёўхЄ ўрёЄюЄ т sample rate юЄэюёшЄхы№эю ёЄрэфрЁЄэющ эюЄ√ C5 ё шэфхъёюь 60
  66.     for(i = 0; i < int(_countof(note2rate)); i++)
  67.     {
  68.         // 7093789.2 / 2 - clock rate PAL Amiga
  69.         // 214.0 (яхЁшюфют тэєЄЁхээхую ухэхЁрЄюЁр) - ╤3 эр Amiga (ёююЄтхЄёЄтєхЄ C5 эр GS)
  70.         note2rate[i] *= float(7093789.2 / (2.0 * 214.0 * C5));
  71.     }
  72.     setmodvol(modvol);
  73. }
  74.  
  75. unsigned char GSHLE::in(unsigned char port)
  76. {
  77.    if (port == 0xBB) return gsstat;
  78.    if (!resptr) return 0xFF; // no data available
  79.    unsigned char byte = *resptr;
  80.    if(resmode)
  81.    {
  82.        resptr++;
  83.        resmode--;
  84.    } // goto next byte
  85.    return byte;
  86. }
  87.  
  88. void GSHLE::out(unsigned char port, unsigned char byte)
  89. {
  90.    if (port == 0xB3) {
  91.       if (!load_stream) {
  92.          *to_ptr = byte;
  93.          if(resmod2)
  94.          {
  95.              to_ptr++;
  96.              resmod2--;
  97.          }
  98.          if (!resmod2) {
  99.             if ((gscmd & 0xF8) == 0x88) start_fx(data_in[0], gscmd & 3, 0xFF, data_in[1]);
  100.             if ((gscmd & 0xF8) == 0x90) start_fx(data_in[0], gscmd & 3, data_in[1], 0xFF);
  101.             if ((gscmd & 0xF8) == 0x98) start_fx(data_in[0], gscmd & 3, data_in[2], data_in[1]);
  102.             to_ptr = data_in;
  103.          }
  104.       } else {
  105.          if (load_stream == 4) { // covox
  106.             flush_dig_snd();
  107.             covFB_vol = byte*conf.sound.gs_vol/0x100;
  108.             return;
  109.          }
  110.          streamstart[streamsize++] = byte;
  111.          if (load_stream == 1) loadmod = 1;
  112.          else loadfx = u8(cur_fx);
  113.       }
  114.       return;
  115.    }
  116.    // else command
  117.    unsigned i;
  118.    gsstat = 0x7E; resmode = 0; // default - 1 byte ready
  119.    resptr = gstmp; to_ptr = data_in; resmod2 = 0;
  120.    gscmd = byte;
  121.    if (load_stream == 4) load_stream = 0; // close covox mode
  122.    switch (byte) {
  123.       case 0x0E: // LPT covox
  124.          load_stream = 4;
  125.          break;
  126.       case 0xF3: case 0xF4: // reset
  127.          reset_gs();
  128.          break;
  129.       case 0xF5:
  130.          set_busy(1); break;
  131.       case 0xF6:
  132.          set_busy(0); break;
  133.       case 0x20: // get total memory
  134.          *(unsigned*)gstmp = conf.gs_ramsize*1024-32768-16384;
  135.          resmode = 2; gsstat = 0xFE;
  136.          break;
  137.       case 0x21: // get free memory
  138.          *(unsigned*)gstmp = (conf.gs_ramsize*1024-32768-16384) - used;
  139.          resmode = 2; gsstat = 0xFE;
  140.          break;
  141.       case 0x23: // get pages
  142.          *gstmp = u8(((conf.gs_ramsize*1024)/32768)-1);
  143.           gsstat = 0xFE;
  144.          break;
  145.       case 0x2A: // set module vol
  146.       case 0x35:
  147.          *gstmp = u8(modvol);
  148.          modvol = *data_in;
  149.          setmodvol(modvol);
  150.          break;
  151.       case 0x2B: // set FX vol
  152.       case 0x3D:
  153.          *gstmp = u8(fxvol);
  154.          fxvol = *data_in;
  155.          make_gs_volume(fxvol);
  156.          break;
  157.       case 0x2E: // set FX
  158.           // printf("%u: %s, set fx = %u\n", unsigned(rdtsc()), __FUNCTION__, *data_in);
  159.           if(*data_in == 0)
  160.           { // COM_H.a80, COM2E
  161.               cur_fx = total_fx - 1;
  162.           }
  163.           else
  164.           {
  165.               if(*data_in > total_fx - 1)
  166.               {
  167.                   cur_fx = 0;
  168.               }
  169.               else
  170.               {
  171.                   cur_fx = *data_in;
  172.               }
  173.           }
  174.          break;
  175.       case 0x30: // load MOD
  176.          resetmod();
  177.          streamstart = mod = GSRAM_M + used;
  178.          streamsize = 0;
  179.          *gstmp = 1; load_stream = 1;
  180.          break;
  181.       case 0x31: // play MOD
  182.          restart_mod(0,0);
  183.          break;
  184.       case 0x32: // stop MOD
  185.          mod_playing = 0;
  186.          stop_mod();
  187.          break;
  188.       case 0x33: // continue MOD
  189.          if (mod)
  190.          {
  191.              mod_playing = 1;
  192.              cont_mod();
  193.          }
  194.          break;
  195.       case 0x36: // data = #FF
  196.          *gstmp = 0xFF;
  197.          break;
  198.       case 0x38: // load FX (unsigned samples)
  199.       case 0x3E: // (signed samples)
  200.           if(total_fx >= 64)
  201.           {
  202.               cur_fx = 0; // COM_H.a80, COM38_9
  203.               break;
  204.           }
  205.          cur_fx = *gstmp = total_fx;
  206.          load_stream = (byte == 0x38) ? 2 : 3;
  207.          streamstart = GSRAM_M + used;
  208.          sample[total_fx].start = streamstart;
  209.          streamsize = 0;
  210.          break;
  211.       case 0x39: // play FX
  212.           // printf("%u: %s, start fx = %u\n", unsigned(rdtsc()), __FUNCTION__, *data_in);
  213.          start_fx(*data_in, 0xFF, 0xFF, 0xFF);
  214.          break;
  215.       case 0x3A: // stop fx
  216.           // printf("%u: %s, stop fx = %u\n", unsigned(rdtsc()), __FUNCTION__, *data_in);
  217.           for(i = 0; i < 4; i++)
  218.           {
  219.               if(*data_in & (1 << i))
  220.               {
  221.                   chan[i].start = nullptr;
  222.               }
  223.           }
  224.          break;
  225.       case 0x40: // set note
  226.           if(cur_fx == 0)
  227.           {
  228.               break;
  229.           }
  230.          sample[cur_fx].note = *data_in <= 95 ? *data_in : 95;
  231.          break;
  232.       case 0x41: // set vol
  233.          sample[cur_fx].volume = *data_in;
  234.          break;
  235.       case 0x42: // Set FX Sample Finetune
  236.           sample[cur_fx].FineTune = *data_in;
  237.           break;
  238.       case 0x45: // set fx priority
  239.           sample[cur_fx].Priority = *data_in;
  240.           break;
  241.       case 0x46: // Set FX Sample Seek First parameter
  242.           sample[cur_fx].SeekFirst = *data_in;
  243.           break;
  244.       case 0x47: // Set FX Sample Seek Last parameter
  245.           sample[cur_fx].SeekLast = *data_in;
  246.           break;
  247.       case 0x48: // set loop start
  248.          resmod2 = 2;
  249.          *(unsigned char*)&sample[cur_fx].loop = *data_in;
  250.          to_ptr = 1+(unsigned char*)&sample[cur_fx].loop;
  251.          break;
  252.       case 0x49: // set loop end
  253.          resmod2 = 2;
  254.          *(unsigned char*)&sample[cur_fx].end = *data_in;
  255.          to_ptr = 1+(unsigned char*)&sample[cur_fx].end;
  256.          break;
  257.       case 0x60: // get song pos
  258.          *gstmp = (unsigned char)modgetpos();
  259.          break;
  260.       case 0x61: // get pattern pos
  261.          *gstmp = (unsigned char)(modgetpos() >> 16);
  262.          break;
  263.       case 0x62: // get mixed pos
  264.          i = modgetpos();
  265.          *gstmp = u8(((i>>16) & 0x3F) | (i << 6));
  266.          break;
  267.       case 0x63: // get module notes
  268.         resmode = 3; gsstat = 0xFE;
  269.         break;
  270.       case 0x64: // get module vols
  271.         *(unsigned*)gstmp = 0;
  272.         resmode = 3; gsstat = 0xFE;
  273.         break;
  274.      case 0x65: // jmp to pos
  275.         restart_mod(*data_in,0);
  276.         break;
  277.      case 0x66: // Set speed/tempo
  278.          if(*data_in <= 0x1F)
  279.          {
  280.              speed = *data_in;
  281.              //printf("%s, speed=%u\n", __FUNCTION__, speed);
  282.              SetModSpeed();
  283.          }
  284.          else
  285.          {
  286.              tempo = *data_in;
  287.          }
  288.          break;
  289.      case 0x67:
  290.          // Get speed value
  291.          *gstmp = speed;
  292.          break;
  293.      case 0x68: // Get tempo value
  294.          *gstmp = tempo;
  295.          break;
  296.      case 0x80: // direct play 1
  297.      case 0x81:
  298.      case 0x82:
  299.      case 0x83:
  300.         start_fx(*data_in, byte & 3, 0xFF, 0xFF);
  301.         break;
  302.      case 0x88: // direct play 2
  303.      case 0x89:
  304.      case 0x8A:
  305.      case 0x8B:
  306.      case 0x90: // direct play 3
  307.      case 0x91:
  308.      case 0x92:
  309.      case 0x93:
  310.         resmod2 = 1; to_ptr++;
  311.         break;
  312.      case 0x98: // direct play 4
  313.      case 0x99:
  314.      case 0x9A:
  315.      case 0x9B:
  316.         resmod2 = 2; to_ptr++;
  317.         break;
  318.  
  319.       case 0xD2: // close stream
  320.          if (!load_stream) break;
  321.          // bug?? command #3E loads unsigned samples (REX 1,2)
  322. //         if (load_stream == 3) // unsigned sample -> convert to unsigned
  323. //            for (unsigned ptr = 0; ptr < streamsize; sample[total_fx].start[ptr++] ^= 0x80);
  324.          if(load_stream == 1)
  325.          {
  326.              modsize = streamsize;
  327.              init_mod();
  328.          }
  329.          else {
  330.             sample[total_fx].end = streamsize;
  331.             sample[total_fx].loop = 0xFFFFFF;
  332.             sample[total_fx].volume = 0x40;
  333.             sample[total_fx].note = 60;
  334.             sample[total_fx].Priority = 0x80;
  335.             sample[total_fx].SeekFirst = 0x0F;
  336.             sample[total_fx].SeekLast = 0x0F;
  337.             sample[total_fx].FineTune = 0;
  338.             //{char fn[200];sprintf(fn,"s-%d.raw",total_fx); FILE*ff=fopen(fn,"wb");fwrite(sample[total_fx].start,1,streamsize,ff);fclose(ff);}
  339.             total_fx++;
  340.          }
  341.          used += streamsize;
  342.          load_stream = 0;
  343.          break;
  344.  
  345.       case 0x00: // reset flags - already done
  346.       case 0x08:
  347.       case 0xD1: // start stream
  348.          break;
  349.       default:
  350.          badgs[byte] = 1;
  351.          break;
  352.    }
  353. }
  354.  
  355. void GSHLE::start_fx(unsigned fx, unsigned ch, unsigned char vol, unsigned char note)
  356. {  
  357.    unsigned i; //Alone Coder 0.36.7
  358.    if (!fx) fx = cur_fx; // fx=0 - use default
  359.    if (vol == 0xFF) vol = sample[fx].volume;
  360.    if (note == 0xFF) note = sample[fx].note;
  361.    if(ch == 0xFF) // find free channel
  362.    {
  363.        unsigned SeekFirst = sample[fx].SeekFirst;
  364.        for(/*unsigned*/ i = 0; i < 4; i++)
  365.        {
  366.            if((SeekFirst & (1 << i)) && !chan[i].start)
  367.            {
  368.                ch = i;
  369.            }
  370.        }
  371.  
  372.        if(ch == 0xFF)
  373.        {
  374.            unsigned SeekLast = sample[fx].SeekLast;
  375.            for(i = 0; i < 4; i++)
  376.            {
  377.                if((SeekLast & (1 << i)) && !chan[i].start)
  378.                {
  379.                    ch = i;
  380.                }
  381.            }
  382.        }
  383.  
  384.        if(ch == 0xFF)
  385.        { // ╬сЁрсюЄър яЁшюЁшЄхЄют
  386.            unsigned SeekLast = sample[fx].SeekLast;
  387.            unsigned MinPrio = 0xFF;
  388.            unsigned MinPrioIdx = 0xFF;
  389.            for(i = 0; i < 4; i++)
  390.            {
  391.                if((SeekLast & (1 << i)) && (chan[i].Priority < MinPrio))
  392.                {
  393.                    MinPrio = chan[i].Priority;
  394.                    MinPrioIdx = i;
  395.                }
  396.            }
  397.  
  398.            if(MinPrioIdx == 0xFF)
  399.            {
  400.                return;
  401.            }
  402.  
  403.            if(sample[fx].Priority >= MinPrio)
  404.            {
  405.                ch = MinPrioIdx;
  406.            }
  407.        }
  408.    }
  409.  
  410.    if(ch == 0xFF) // ╧юфїюф ∙шщ ётюсюфэ√щ ърэры эх эрщфхэ
  411.    {
  412.        return;
  413.    }
  414.    chan[ch].volume = vol;
  415.    chan[ch].start = sample[fx].start;
  416.    chan[ch].loop = sample[fx].loop;
  417.    chan[ch].end = sample[fx].end;
  418.    chan[ch].Priority = sample[fx].Priority;
  419.    chan[ch].FineTune = sample[fx].FineTune;
  420.    chan[ch].ptr = 0;
  421.    chan[ch].freq = note2rate[note];
  422.    // ch0,1 - left, ch2,3 - right
  423.    startfx(&chan[ch], (ch & 2)? 1.0f : -1.0f);
  424. }
  425.  
  426. DWORD CALLBACK gs_render(HSTREAM handle, void *buffer, DWORD length, void *user);
  427.  
  428. DWORD CALLBACK gs_render(HSTREAM handle, void *buffer, DWORD length, void *user)
  429. {
  430.     (void)handle;
  431.  
  432.    GSHLE::CHANNEL *ch = (GSHLE::CHANNEL*)user;
  433.  
  434.    if (!ch->start)
  435.        return BASS_STREAMPROC_END;
  436.    if (ch->busy)
  437.    {
  438.        memset(buffer, 0, length);
  439.        return length;
  440.    }
  441.    for (unsigned i = 0; i < length; i++)
  442.    {
  443.       ((BYTE*)buffer)[i] = ch->start[ch->ptr++];
  444.       if (ch->ptr >= ch->end)
  445.       {
  446.          if (ch->end < ch->loop)
  447.          {
  448.              ch->start = nullptr;
  449.              return i + BASS_STREAMPROC_END;
  450.          }
  451.          else
  452.              ch->ptr = ch->loop;
  453.       }
  454.    }
  455.    return length;
  456. }
  457. #endif
  458.