Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. #include "std.h"
  2.  
  3. #include <io.h>
  4. #include <fcntl.h>
  5. #include <sys/stat.h>
  6.  
  7. #include "emul.h"
  8. #include "vars.h"
  9. #include "bass.h"
  10. #include "snd_bass.h"
  11. #include "gshle.h"
  12. #include "gs.h"
  13. #include "init.h"
  14. #include "util.h"
  15.  
  16. #ifdef MOD_GSBASS
  17.  
  18. //=============================================================================
  19. void GSHLE::reportError(const char *err, bool fatal)
  20. {
  21.     color(CONSCLR_ERROR);
  22.     printf("BASS library reports error in %s\n", err);
  23.     color(CONSCLR_ERRCODE);
  24.     printf("error code is 0x%04X\n", BASS::ErrorGetCode());
  25.     //-------------------------------------------------------------------------
  26.     if (fatal)
  27.     {
  28.         exit();
  29.     }
  30.     //-------------------------------------------------------------------------
  31. }
  32. //=============================================================================
  33.  
  34.  
  35. //=============================================================================
  36. void GSHLE::runBASS()
  37. {
  38.     //-------------------------------------------------------------------------
  39.     if (BASS::Initialized)
  40.         return;
  41.     //-------------------------------------------------------------------------
  42.     if (BASS::Init(-1, conf.sound.fq, BASS_DEVICE_LATENCY, wnd, nullptr))
  43.     {
  44.         DWORD len = BASS::GetConfig(BASS_CONFIG_UPDATEPERIOD);
  45.         BASS_INFO info;
  46.         BASS::GetInfo(&info);
  47.         BASS::SetConfig(BASS_CONFIG_BUFFER, len + info.minbuf);
  48.         color(CONSCLR_HARDITEM);
  49.         printf("BASS device latency is ");
  50.         color(CONSCLR_HARDINFO);
  51.         printf("%lums\n", len + info.minbuf);
  52.     }
  53.     //-------------------------------------------------------------------------
  54.     else
  55.     {
  56.         color(CONSCLR_WARNING);
  57.         reportError("warning: can't use default BASS device, trying silence\n", false);
  58.         //---------------------------------------------------------------------
  59.         if (!BASS::Init(-2, 11025, 0, wnd, nullptr))
  60.             errexit("can't init BASS");
  61.         //---------------------------------------------------------------------
  62.     }
  63.     //-------------------------------------------------------------------------
  64.     BASS::Initialized = true;
  65.     hmod = 0;
  66.     //-------------------------------------------------------------------------
  67.     for (int ch = 0; ch < 4; ch++)
  68.         chan[ch].bass_ch = 0;
  69.     //-------------------------------------------------------------------------
  70.     DebugCh.bass_ch = 0;
  71. }
  72. //=============================================================================
  73.  
  74.  
  75. //=============================================================================
  76. void GSHLE::reset_sound()
  77. {
  78.   // runBASS();
  79.   // BASS_Stop(); // todo: move to silent state?
  80. }
  81. //=============================================================================
  82.  
  83.  
  84. DWORD CALLBACK gs_render(HSTREAM handle, void *buffer, DWORD length, void *user);
  85.  
  86.  
  87. //=============================================================================
  88. void GSHLE::initChannels()
  89. {
  90.     //-------------------------------------------------------------------------
  91.     if (chan[0].bass_ch)
  92.         return;
  93.     //-------------------------------------------------------------------------
  94.     for (int ch = 0; ch < 4; ch++)
  95.     {
  96.         chan[ch].bass_ch = BASS::StreamCreate(conf.sound.fq, 1, BASS_SAMPLE_8BITS, gs_render, &chan[ch]);
  97.         //---------------------------------------------------------------------
  98.         if (!chan[ch].bass_ch)
  99.             reportError("BASS_StreamCreate()");
  100.         //---------------------------------------------------------------------
  101.     }
  102.     //-------------------------------------------------------------------------
  103.     DebugCh.bass_ch = BASS::StreamCreate(conf.sound.fq, 1, BASS_SAMPLE_8BITS, gs_render, &DebugCh);
  104.     //-------------------------------------------------------------------------
  105.     if (!DebugCh.bass_ch)
  106.         reportError("BASS_StreamCreate()");
  107.     //-------------------------------------------------------------------------
  108. }
  109. //=============================================================================
  110.  
  111.  
  112. //=============================================================================
  113. void GSHLE::setmodvol(unsigned vol)
  114. {
  115.     //-------------------------------------------------------------------------
  116.     if (!hmod)
  117.         return;
  118.     //-------------------------------------------------------------------------
  119.     runBASS();
  120.     float v = (int(vol) * conf.sound.bass_vol) / float(8192 * 64);
  121.     assert(v <= 1.0f);
  122.     //-------------------------------------------------------------------------  
  123.     if (!BASS::ChannelSetAttribute(hmod, BASS_ATTRIB_VOL, v))
  124.         reportError("BASS_ChannelSetAttribute() [music volume]");
  125.     //-------------------------------------------------------------------------
  126. }
  127. //=============================================================================
  128.  
  129.  
  130. //=============================================================================
  131. void GSHLE::SetModSpeed()
  132. {
  133.    
  134. // ╘єэъЎш  эх юЄырцхэр, эхшчтхёЄэю т ъръшї яЁюуЁрььрї фрээр  ъюьрэфр шёяюы№чєхЄё 
  135.  
  136.     //-------------------------------------------------------------------------
  137.     if (!hmod)
  138.         return;
  139.     //-------------------------------------------------------------------------
  140.     runBASS();
  141.  
  142.     // printf("%s, speed=%u\n", __FUNCTION__, speed);
  143.     //-------------------------------------------------------------------------
  144.     if (!BASS::ChannelSetAttribute(hmod, BASS_ATTRIB_MUSIC_SPEED, speed))
  145.         reportError("BASS_ChannelSetAttribute() [music speed]");
  146.     //-------------------------------------------------------------------------
  147. }
  148. //=============================================================================
  149.  
  150.  
  151. //=============================================================================
  152. void GSHLE::init_mod()
  153. {
  154.     runBASS();
  155.     //-------------------------------------------------------------------------
  156.     if (hmod)
  157.         BASS::MusicFree(hmod);
  158.     //-------------------------------------------------------------------------
  159.     hmod = 0;
  160.     hmod = BASS::MusicLoad(1, mod, 0, modsize, BASS_MUSIC_LOOP | BASS_MUSIC_POSRESET | BASS_MUSIC_RAMP, 0);
  161.     //-------------------------------------------------------------------------
  162.     if (!hmod)
  163.         reportError("BASS_MusicLoad()", false);
  164.     //-------------------------------------------------------------------------
  165.     setmodvol(modvol); // ╙ёЄрэютър эрўры№эющ уЁюьъюёЄш
  166. }
  167. //=============================================================================
  168.  
  169.  
  170. //=============================================================================
  171. void GSHLE::restart_mod(unsigned order, unsigned row)
  172. {
  173.     //-------------------------------------------------------------------------
  174.     if (!hmod)
  175.         return;
  176.     //-------------------------------------------------------------------------
  177.     SetModSpeed();
  178.     //-------------------------------------------------------------------------
  179.     if (!BASS::ChannelSetPosition(hmod, QWORD(MAKELONG(order,row)), BASS_POS_MUSIC_ORDER))
  180.         reportError("BASS_ChannelSetPosition() [music]");
  181.     //-------------------------------------------------------------------------
  182.     if (!BASS::ChannelFlags(hmod, BASS_MUSIC_LOOP | BASS_MUSIC_POSRESET | BASS_MUSIC_RAMP, -1U))
  183.         reportError("BASS_ChannelFlags() [music]");
  184.     //-------------------------------------------------------------------------
  185.     BASS::Start();
  186.     //-------------------------------------------------------------------------
  187.     if (!BASS::ChannelPlay(hmod, FALSE/*TRUE*/))
  188.         reportError("BASS_ChannelPlay() [music]");      //molodcov_alex 0.36.2
  189.     //-------------------------------------------------------------------------
  190.     mod_playing = 1;
  191. }
  192. //=============================================================================
  193.  
  194.  
  195. //=============================================================================
  196. void GSHLE::resetmod()
  197. {
  198.     //-------------------------------------------------------------------------
  199.     if (hmod)
  200.         BASS::MusicFree(hmod);
  201.     //-------------------------------------------------------------------------
  202.     hmod = 0;
  203. }
  204. //=============================================================================
  205.  
  206.  
  207. //=============================================================================
  208. void GSHLE::resetfx()
  209. {
  210.     runBASS();
  211.     //-------------------------------------------------------------------------
  212.     for (int i = 0; i < 4; i++)
  213.     {
  214.         if (chan[i].bass_ch)
  215.         {
  216.             BASS::StreamFree(chan[i].bass_ch);
  217.             chan[i].bass_ch = 0;
  218.         }
  219.     }
  220.     //-------------------------------------------------------------------------
  221. }
  222. //=============================================================================
  223.  
  224.  
  225. //=============================================================================
  226. DWORD GSHLE::modgetpos()
  227. {
  228.     runBASS();
  229.     return (DWORD)BASS::ChannelGetPosition(hmod, BASS_POS_MUSIC_ORDER);
  230. //  return BASS_MusicGetOrderPosition(hmod);
  231. }
  232. //=============================================================================
  233.  
  234.  
  235. //=============================================================================
  236. void GSHLE::stop_mod()
  237. {
  238.     runBASS();
  239.     //-------------------------------------------------------------------------
  240.     if (!hmod)
  241.         return;
  242.     //-------------------------------------------------------------------------
  243.     if (BASS::ChannelIsActive(hmod) != BASS_ACTIVE_PLAYING)
  244.         return;
  245.     //-------------------------------------------------------------------------
  246.     if (!BASS::ChannelPause(hmod))
  247.        reportError("BASS_ChannelPause() [music]");
  248. }
  249. //=============================================================================
  250.  
  251.  
  252. //=============================================================================
  253. void GSHLE::pause_mod()                         // [NS]
  254. {
  255.     BASS::Pause();
  256.  
  257. //  їч тююс∙х ўЄю ¤Єю чр ю°шсъш
  258.     //-------------------------------------------------------------------------
  259.     if (!hmod)
  260.         return;
  261.     //-------------------------------------------------------------------------
  262.     if (BASS::ChannelIsActive(hmod) != BASS_ACTIVE_PLAYING)
  263.         return;
  264.     //-------------------------------------------------------------------------
  265. //    if (!BASS::ChannelPause(hmod))
  266. //       reportError("BASS_ChannelPause() [music]");
  267. }
  268. //=============================================================================
  269. void GSHLE::play_mod()                          // [NS]
  270. {                       // фюыцхэ эртхЁэю эрч√трЄёю resume_mod !!!!
  271.     BASS::Start();
  272.    
  273. //  їч тююс∙х ўЄю ¤Єю чр ю°шсъш
  274.     //-------------------------------------------------------------------------
  275.     if (!hmod)
  276.         return;
  277.     //-------------------------------------------------------------------------
  278.     if (BASS::ChannelIsActive(hmod) != BASS_ACTIVE_PLAYING)
  279.         return;
  280.     //-------------------------------------------------------------------------
  281. //    if (!BASS::ChannelPause(hmod))
  282. //       reportError("BASS_ChannelPause() [music]");
  283. }
  284. //=============================================================================
  285.  
  286.    
  287. //=============================================================================
  288. void GSHLE::cont_mod()
  289. {
  290.     runBASS();
  291.     //-------------------------------------------------------------------------
  292.     if (!hmod)
  293.         return;
  294.     //-------------------------------------------------------------------------
  295.     if (!BASS::ChannelPlay(hmod, TRUE))
  296.         reportError("BASS_ChannelPlay() [music]");
  297.     //-------------------------------------------------------------------------
  298. }
  299. //=============================================================================
  300.  
  301.  
  302.  
  303. //=============================================================================
  304. void GSHLE::startfx(CHANNEL *ch, float pan)
  305. {
  306.     initChannels();
  307.  
  308.     float vol = (int(ch->volume) * conf.sound.gs_vol) / float(8192*64);
  309.     assert(vol <= 1.0f);
  310.     //-------------------------------------------------------------------------
  311.     if (BASS::ChannelIsActive(ch->bass_ch) == BASS_ACTIVE_PLAYING)
  312.     {
  313.         if (!BASS::ChannelStop(ch->bass_ch))
  314.             reportError("BASS_ChannelStop()");
  315.     }
  316.     //-------------------------------------------------------------------------
  317.     if (!BASS::ChannelSetAttribute(ch->bass_ch, BASS_ATTRIB_VOL, vol))
  318.         reportError("BASS_ChannelSetAttribute() [vol]");
  319.     //-------------------------------------------------------------------------
  320.     if (!BASS::ChannelSetAttribute(ch->bass_ch, BASS_ATTRIB_FREQ, ch->freq))
  321.         reportError("BASS_ChannelSetAttribute() [freq]");
  322.     //-------------------------------------------------------------------------  
  323.     if (!BASS::ChannelSetAttribute(ch->bass_ch, BASS_ATTRIB_PAN, pan))
  324.         reportError("BASS_ChannelSetAttribute() [pan]");
  325.     //-------------------------------------------------------------------------
  326.     {   // Єръ ш фюыцэю с√Є№????
  327.         DWORD len = BASS::GetConfig(BASS_CONFIG_UPDATEPERIOD);
  328.         BASS_INFO info;
  329.         BASS::GetInfo(&info);
  330.         BASS::SetConfig(BASS_CONFIG_BUFFER, len + info.minbuf);
  331.     }
  332.     //-------------------------------------------------------------------------
  333.     if (!BASS::ChannelPlay(ch->bass_ch, FALSE))
  334.         reportError("BASS_ChannelPlay()");
  335.     //-------------------------------------------------------------------------
  336. }
  337. //=============================================================================
  338.  
  339.  
  340. //=============================================================================
  341. void GSHLE::flush_gs_frame()
  342. {
  343.     unsigned lvl;
  344.     //-------------------------------------------------------------------------
  345.     if (!hmod || (lvl = BASS::ChannelGetLevel(hmod)) == -1U)
  346.         lvl = 0;
  347.     //-------------------------------------------------------------------------
  348.     gsleds[0].level = LOWORD(lvl) >> (15-4);
  349.     gsleds[0].attrib = 0x0D;
  350.     gsleds[1].level = HIWORD(lvl) >> (15-4);
  351.     gsleds[1].attrib = 0x0D;
  352.     //-------------------------------------------------------------------------
  353.     for (int ch = 0; ch < 4; ch++)
  354.     {
  355.         //---------------------------------------------------------------------
  356.         if (chan[ch].bass_ch && (lvl = BASS::ChannelGetLevel(chan[ch].bass_ch)) != -1U)
  357.         {
  358.             lvl = max(HIWORD(lvl), LOWORD(lvl));
  359.             lvl >>= (15-4);
  360.         }
  361.         //---------------------------------------------------------------------
  362.         else
  363.         {
  364.             lvl = 0;
  365.         }
  366.         //---------------------------------------------------------------------
  367.         gsleds[ch+2].level = lvl;
  368.         gsleds[ch+2].attrib = 0x0F;
  369.     }
  370.     //---------------------------------------------------------------------
  371. }
  372. //=============================================================================
  373.  
  374.  
  375. //=============================================================================
  376. void GSHLE::debug_note(unsigned i)
  377. {
  378.     //-------------------------------------------------------------------------
  379.     if (BASS::ChannelIsActive(DebugCh.bass_ch) == BASS_ACTIVE_PLAYING)
  380.     {
  381.         if (!BASS::ChannelStop(DebugCh.bass_ch))
  382.         {
  383.             reportError("BASS_ChannelStop()");
  384.         }
  385.     }
  386.     //-------------------------------------------------------------------------
  387.     DebugCh.volume = sample[i].volume;
  388.     DebugCh.ptr = 0;
  389.     DebugCh.start = sample[i].start;
  390.     DebugCh.loop = sample[i].loop;
  391.     DebugCh.end = sample[i].end;
  392.     unsigned note = sample[i].note;
  393.     DebugCh.freq = note2rate[note];
  394.  
  395.     startfx(&DebugCh, 0);
  396. }
  397. //=============================================================================
  398.  
  399.  
  400. //=============================================================================
  401. void GSHLE::debug_save_note(unsigned i, const char *FileName)
  402. {
  403.     int f = open(FileName, O_CREAT | O_TRUNC | O_BINARY | O_WRONLY, S_IREAD | S_IWRITE);
  404.     //-------------------------------------------------------------------------
  405.     if (f >= 0)
  406.     {
  407.         write(f, sample[i].start, sample[i].end);
  408.         close(f);
  409.     }
  410.     //-------------------------------------------------------------------------
  411. }
  412. //=============================================================================
  413.  
  414.  
  415. //=============================================================================
  416. void GSHLE::debug_save_mod(const char *FileName)
  417. {
  418.     int f = open(FileName, O_CREAT | O_TRUNC | O_BINARY | O_WRONLY, S_IREAD | S_IWRITE);
  419.     //-------------------------------------------------------------------------
  420.     if (f >= 0)
  421.     {
  422.         write(f, mod, modsize);
  423.         close(f);
  424.     }
  425.     //-------------------------------------------------------------------------
  426. }
  427. //=============================================================================
  428. #endif
  429.