Subversion Repositories pentevo

Rev

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

  1. #include "std.h"                //яЁртшы№эр  ъюфшЁютър
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "gs.h"
  6. #include "tape.h"
  7. #include "config.h"
  8. #include "sndrender/sndcounter.h"
  9. #include "sound.h"
  10.  
  11. //=============================================================================
  12.  
  13.     int spkr_dig =      0;
  14.     int mic_dig =       0;
  15.     int covFB_vol =     0;
  16.     int covDD_vol =     0;
  17.     int sd_l =          0;
  18.     int sd_r =          0;
  19.  
  20. //=============================================================================
  21. void flush_dig_snd()            //яЁюЎхфєЁр фы  т√тюфр digital-р
  22. {
  23. //   __debugbreak();
  24.     //-------------------------------------------------------------------------
  25.     if (temp.sndblock)
  26.         return;
  27.     //-------------------------------------------------------------------------
  28.     int mono =  spkr_dig        +       //сшяхЁ
  29.                 mic_dig         +       //ьруэшЄюЇюэ чряшё№
  30.                 covFB_vol       +       //covox FB
  31.                 covDD_vol       ;       //covox DD
  32.  
  33. //   printf("mono=%u\n", mono);
  34. //[vv]  
  35.     sound.update(       cpu.t - temp.cpu_t_at_frame_start,
  36.                         unsigned( mono + sd_l),         //ыхт√щ ърэры
  37.                         unsigned( mono + sd_r));        //яЁрт√щ ърэры
  38. }
  39. //тшфшью SNDRENDER::update
  40. //=============================================================================
  41.  
  42.  
  43. //=============================================================================
  44. void init_snd_frame()
  45. {
  46.     temp.cpu_t_at_frame_start = cpu.t;
  47. //[vv]  
  48.     sound.start_frame();
  49.     comp.tape.sound.start_frame();
  50.     //-------------------------------------------------------------------------
  51.     if (conf.sound.ay_scheme)
  52.     {
  53.         ay[0].start_frame();
  54.         //---------------------------------------------------------------------
  55.         if (conf.sound.ay_scheme > AY_SCHEME_SINGLE)
  56.             ay[1].start_frame();
  57.         //---------------------------------------------------------------------
  58.     }
  59.     //-------------------------------------------------------------------------
  60.     Saa1099.start_frame();
  61.     //-------------------------------------------------------------------------
  62.     #ifdef MOD_GS
  63.         init_gs_frame();
  64.     #endif
  65.     //-------------------------------------------------------------------------
  66. }
  67. //=============================================================================
  68.  
  69. static float y_1[2] = { 0.0f };
  70. static i16 x_1[2] = { 0 };
  71.  
  72. //=============================================================================
  73. void flush_snd_frame()
  74. {
  75.     tape_bit();
  76.     //-------------------------------------------------------------------------
  77.     #ifdef MOD_GS
  78.         flush_gs_frame();
  79.     #endif
  80.     //-------------------------------------------------------------------------
  81.     if (temp.sndblock)
  82.         return;
  83.     //-------------------------------------------------------------------------
  84.     unsigned endframe = cpu.t - temp.cpu_t_at_frame_start;
  85.     //-------------------------------------------------------------------------
  86.     // sound chip present
  87.     if (conf.sound.ay_scheme)
  88.     {
  89.         ay[0].end_frame( endframe);
  90.         // if (conf.sound.ay_samples) mix_dig(ay[0]);
  91.         //---------------------------------------------------------------------
  92.         if (conf.sound.ay_scheme > AY_SCHEME_SINGLE)
  93.         {
  94.             ay[1].end_frame(endframe);
  95.             // if (conf.sound.ay_samples) mix_dig(ay[1]);
  96.             //-----------------------------------------------------------------
  97.             if (conf.sound.ay_scheme == AY_SCHEME_PSEUDO)
  98.             {
  99.                 unsigned char last = ay[0].get_r13_reloaded()  ?  13 :
  100.                                                                   12;
  101.                 //-------------------------------------------------------------
  102.                 for (unsigned char r = 0;    r <= last;    r++)
  103.                 {
  104.                     ay[1].select( r);
  105.                     ay[1].write( 0, ay[0].get_reg( r));
  106.                 }
  107.                 //-------------------------------------------------------------
  108.             }
  109.             //-----------------------------------------------------------------
  110.         }
  111.         //---------------------------------------------------------------------
  112.         if (savesndtype == 2)   //vtx
  113.         {
  114.             //-----------------------------------------------------------------
  115.             // эрўры№эюх т√фхыхэшх ярь Єш
  116.             if (!vtxbuf)
  117.             {
  118.                 vtxbuf = (unsigned char*)malloc( 32768);
  119.                 vtxbufsize = 32768;
  120.                 vtxbuffilled = 0;
  121.             }
  122.             //-----------------------------------------------------------------
  123.             // т√фхыхэшх х∙х ярь Єш хёыш ъюэўшыюё№?
  124.             if (vtxbuffilled + 14 >= vtxbufsize)
  125.             {
  126.                 vtxbufsize += 32768;
  127.                 vtxbuf = (unsigned char*)realloc( vtxbuf, vtxbufsize);
  128.             }
  129.             //-----------------------------------------------------------------
  130.             for (unsigned char r = 0;    r < 14;    r++)
  131.                 vtxbuf[ vtxbuffilled + r] = ay[0].get_reg(r);
  132.             //-----------------------------------------------------------------
  133.             if (!ay[0].get_r13_reloaded())
  134.                 vtxbuf[ vtxbuffilled + 13] = 0xFF;
  135.             //-----------------------------------------------------------------
  136.             vtxbuffilled += 14;
  137.         }
  138.         //---------------------------------------------------------------------
  139.     }
  140.     //-------------------------------------------------------------------------
  141.     Saa1099.end_frame( endframe);
  142.  
  143.     sound.end_frame( endframe);
  144.     // if (comp.tape.play_pointer) // play tape pulses
  145.     comp.tape.sound.end_frame( endframe);
  146.     // else comp.tape.sound.end_empty_frame( endframe);
  147.  
  148.     unsigned bufplay;
  149.     unsigned n_samples;
  150.    
  151.     sndcounter.begin();
  152.  
  153.     sndcounter.count( sound);
  154.     sndcounter.count( comp.tape.sound);
  155.     //-------------------------------------------------------------------------
  156.     if (conf.sound.ay_scheme)
  157.     {
  158.         sndcounter.count( ay[0]);
  159.         //---------------------------------------------------------------------
  160.         if (conf.sound.ay_scheme > AY_SCHEME_SINGLE)
  161.             sndcounter.count( ay[1]);
  162.         //---------------------------------------------------------------------
  163.     }
  164.     //-------------------------------------------------------------------------
  165.     sndcounter.count( Saa1099);
  166.     //-------------------------------------------------------------------------
  167.     #ifdef MOD_GS
  168.         //---------------------------------------------------------------------
  169.         #ifdef MOD_GSZ80
  170.             if (conf.gs_type == 1)
  171.                 sndcounter.count( z80gs::sound);
  172.         #endif
  173.         //---------------------------------------------------------------------
  174.         #ifdef MOD_GSBASS
  175.             // if (conf.gs_type == 2)
  176.             // {
  177.             //     gs.mix_fx();
  178.             //     return;
  179.             // }
  180.         #endif
  181.         //---------------------------------------------------------------------
  182.     #endif // MOD_GS
  183.     //-------------------------------------------------------------------------
  184.     sndcounter.end( bufplay, n_samples);
  185.     //-------------------------------------------------------------------------
  186.     for (unsigned k = 0;    k < n_samples;    k++, bufplay++)
  187.     {
  188.         u32 v = sndbuf[ bufplay & (SNDBUFSIZE - 1)];
  189.         u32 Y;
  190.         //---------------------------------------------------------------------
  191.         if (conf.RejectDC) // DC rejection filter
  192.         {
  193.             i16 x[2];
  194.             float y[2];
  195.             x[0] = i16(v & 0xFFFF);
  196.             x[1] = i16(v >> 16U);
  197.             y[0] = 0.995f * (x[0] - x_1[0]) + 0.99f * y_1[0];
  198.             y[1] = 0.995f * (x[1] - x_1[1]) + 0.99f * y_1[1];
  199.             x_1[0] = x[0];
  200.             x_1[1] = x[1];
  201.             y_1[0] = y[0];
  202.             y_1[1] = y[1];
  203.             Y = u32(    (( i16( y[1]) & 0xFFFF) << 16) |
  204.                         (  i16( y[0]) & 0xFFFF)
  205.                 );
  206.         }
  207.         //---------------------------------------------------------------------
  208.         else
  209.         {
  210.             Y = v;
  211.         }
  212.         //---------------------------------------------------------------------
  213.         sndplaybuf[ k] = Y;
  214.         sndbuf[ bufplay & (SNDBUFSIZE - 1)] = 0;
  215.     }
  216.     //-------------------------------------------------------------------------    
  217.     #if 0
  218.         // printf("n_samples=%u\n", n_samples);
  219.         //---------------------------------------------------------------------
  220.         for (unsigned k = 0;    k < n_samples;    k++, bufplay++)
  221.         {
  222.             sndplaybuf[ k] = sndbuf[ bufplay & (SNDBUFSIZE - 1)];
  223.             /*
  224.             if (sndplaybuf[ k] == 0x20002000)
  225.                 __debugbreak();
  226.             */
  227.             sndbuf[ bufplay & (SNDBUFSIZE - 1)] = 0;
  228.         }
  229.         //---------------------------------------------------------------------
  230.     #endif
  231.     //-------------------------------------------------------------------------
  232.     spbsize = n_samples * 4;
  233.     // assert( spbsize != 0);
  234.  
  235.     return;
  236.  
  237. /*
  238.     // count available samples and copy to sound buffer
  239.     unsigned save_ticks = temp.snd_frame_ticks; // sound output limit = 1 frame
  240.     save_ticks = min( save_ticks, sound.ready_samples());
  241.     save_ticks = min( save_ticks, comp.ay->sound.ready_samples());
  242.     save_ticks = min( save_ticks, comp.tape.sound.ready_samples());
  243.     //-------------------------------------------------------------------------
  244.     #ifdef MOD_GSZ80
  245.         //---------------------------------------------------------------------
  246.         if (conf.gs_type == 1)
  247.             save_ticks = min( save_ticks, z80gs::sound.ready_samples());
  248.         //---------------------------------------------------------------------
  249.     #endif
  250.     //-------------------------------------------------------------------------
  251.     // fx player always gives enough samples
  252.     #ifdef MOD_GSBASS
  253.         //---------------------------------------------------------------------
  254.         if (conf.gs_type == 2)
  255.         {
  256.             //-----------------------------------------------------------------
  257.             for (int i = 0;    i < 4;    i++)
  258.                 save_ticks = min( save_ticks, gs.chan[i].sound_state.ready_samples());
  259.             //-----------------------------------------------------------------
  260.         }
  261.         //---------------------------------------------------------------------
  262.     #endif
  263.     //-------------------------------------------------------------------------
  264. */
  265.  
  266. }
  267. //=============================================================================
  268.  
  269.  
  270. //=============================================================================
  271. void restart_sound()
  272. {
  273.     //printf("%s\n", __FUNCTION__);
  274.  
  275.     unsigned cpufq = conf.intfq * conf.frame;
  276.     sound.set_timings( cpufq, conf.sound.fq);
  277.     comp.tape.sound.set_timings( cpufq, conf.sound.fq);
  278.     //-------------------------------------------------------------------------
  279.     if (conf.sound.ay_scheme)
  280.     {
  281.         //тюЄ ЄєЄ ёсштрхЄёю Їрчр є envelope
  282.         ay[0].set_timings( cpufq, conf.sound.ayfq, conf.sound.fq);
  283.         //---------------------------------------------------------------------
  284.         if (conf.sound.ay_scheme > AY_SCHEME_SINGLE)
  285.         {
  286.             ay[1].set_timings( cpufq, conf.sound.ayfq, conf.sound.fq);
  287.         }
  288.         //---------------------------------------------------------------------
  289.     }
  290.     //-------------------------------------------------------------------------
  291.     Saa1099.set_timings( cpufq, conf.sound.saa1099fq, conf.sound.fq);
  292.  
  293.     // comp.tape.sound.clear();
  294.     //-------------------------------------------------------------------------  
  295.     #ifdef MOD_GS
  296.         reset_gs_sound();
  297.     #endif
  298.     //-------------------------------------------------------------------------
  299.     sndcounter.reset();
  300.  
  301.     memset( sndbuf, 0, sizeof sndbuf);
  302. }
  303. //=============================================================================
  304.  
  305.  
  306. //=============================================================================
  307. void apply_sound()
  308. {
  309.     // printf ("apply_sound/n");
  310.     //-------------------------------------------------------------------------
  311.     if (conf.sound.ay_scheme < AY_SCHEME_QUADRO)
  312.         comp.active_ay = 0;
  313.     //-------------------------------------------------------------------------
  314.     load_ay_stereo();
  315.     load_ay_vols();
  316.  
  317.     ay[0].set_chip( (SNDCHIP::CHIP_TYPE)conf.sound.ay_chip);
  318.     ay[1].set_chip( (SNDCHIP::CHIP_TYPE)conf.sound.ay_chip);
  319.  
  320.     const SNDCHIP_VOLTAB *voltab = (SNDCHIP_VOLTAB*) & conf.sound.ay_voltab;
  321.     const SNDCHIP_PANTAB *stereo = (SNDCHIP_PANTAB*) & conf.sound.ay_stereo_tab;
  322.     ay[0].set_volumes( unsigned( conf.sound.ay_vol), voltab, stereo);
  323.  
  324.     SNDCHIP_PANTAB reversed;
  325.     //-------------------------------------------------------------------------
  326.     if (conf.sound.ay_scheme == AY_SCHEME_PSEUDO)
  327.     {
  328.         //---------------------------------------------------------------------
  329.         for (int i = 0;    i < 6;    i++)
  330.             reversed.raw[i] = stereo->raw[ i ^ 1];      // swap left/right
  331.         //---------------------------------------------------------------------
  332.         stereo = &reversed;
  333.     }
  334.     //-------------------------------------------------------------------------
  335.     ay[1].set_volumes( unsigned( conf.sound.ay_vol), voltab, stereo);
  336.     //-------------------------------------------------------------------------
  337.     #ifdef MOD_GS
  338.         apply_gs();
  339.     #endif
  340.     //-------------------------------------------------------------------------
  341.     restart_sound();
  342. }
  343. //=============================================================================
  344.  
  345.  
  346.  
  347. /*
  348. #define SAMPLE_SIZE (1024 * 3)
  349. #define SAMPLE_T    256
  350. int waveA[ SAMPLE_SIZE];
  351. int waveB[ SAMPLE_SIZE];
  352. int waveC[ SAMPLE_SIZE];
  353. //=============================================================================
  354. void mix_dig(SNDCHIP &chip)
  355. {
  356.     unsigned base = sb_start_frame >> TICK_FF;
  357.     //-------------------------------------------------------------------------
  358.     for (unsigned i = 0;    i < temp.snd_frame_samples;    i++)
  359.     {
  360.         ta += fa; while (ta >= SAMPLE_SIZE * 0x100) ta -= SAMPLE_SIZE * 0x100;
  361.         tb += fb; while (tb >= SAMPLE_SIZE * 0x100) tb -= SAMPLE_SIZE * 0x100;
  362.         tc += fc; while (tc >= SAMPLE_SIZE * 0x100) tc -= SAMPLE_SIZE * 0x100;
  363.         tn += fn;
  364.         //---------------------------------------------------------------------
  365.         while (tn >= 0x10000)
  366.         {
  367.             ns = (ns * 2 + 1) ^ (((ns >> 16) ^ (ns >> 13)) & 1);
  368.             bitN = 0 - ((ns >> 16) & 1);
  369.             tn -= 0x10000;
  370.         }
  371.         //---------------------------------------------------------------------
  372.         te += fe;
  373.         //---------------------------------------------------------------------
  374.         while (te >= 0x10000)
  375.         {
  376.             env += denv;
  377.             //-----------------------------------------------------------------
  378.             if (env & ~31)
  379.             {
  380.                 unsigned mask = 1 << r_env;
  381.                 //-------------------------------------------------------------
  382.                 if (mask & ((1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<7)|(1<<9)|(1<<15)))
  383.                     env = denv = 0;
  384.                 //-------------------------------------------------------------
  385.                 else if (mask & ((1<<8)|(1<<12)))
  386.                     env &= 31;
  387.                 //-------------------------------------------------------------
  388.                 else if (mask & ((1<<10)|(1<<14)))
  389.                     denv = -(int)denv, env = env + denv;
  390.                 //-------------------------------------------------------------
  391.                 else
  392.                     env = 31, denv = 0; //11,13
  393.                 //-------------------------------------------------------------
  394.             }
  395.             //-----------------------------------------------------------------
  396.             te -= 0x10000;
  397.         }
  398.         //---------------------------------------------------------------------
  399.         unsigned left = 0;
  400.         unsigned right = 0;
  401.         unsigned en;
  402.         unsigned vol;
  403.  
  404.         en = (r_vA & 0x10)  ?  env :
  405.                                (r_vA & 0x0F) * 2 + 1;
  406.         vol = (bitN | bit3) & (waveA[ ta / 0x100] | bit0) & 0xFFFF;
  407.         left +=  vol * vols[ 0][ en],
  408.         right += vol * vols[ 1][ en];
  409.  
  410.         en = (r_vB & 0x10)  ?  env :
  411.                                (r_vB & 0x0F) * 2 + 1;
  412.         vol = (bitN | bit4) & (waveB[ tb / 0x100] | bit1) & 0xFFFF;
  413.         left +=  vol * vols[ 2][ en],
  414.         right += vol * vols[ 3][ en];
  415.  
  416.         en = (r_vC & 0x10)  ?  env :
  417.                                (r_vC & 0x0F) * 2 + 1;
  418.         vol = (bitN | bit5) & (waveC[ tc / 0x100] | bit2) & 0xFFFF;
  419.         left +=  vol * vols[ 4][ en],
  420.         right += vol * vols[ 5][ en];
  421.  
  422.         *(unsigned*)&sndbuf[ (i + base) & (SNDBUFSIZE - 1)] += (left >> 16) + (right & 0xFFFF0000);
  423.     }
  424.     //-------------------------------------------------------------------------
  425.     sound.flush_empty();
  426. }
  427. //=============================================================================
  428.  
  429. #define PI 3.14159265359
  430.  
  431. //=============================================================================
  432. double sin1( int i)
  433. {
  434.     //-------------------------------------------------------------------------
  435.     while (i > SAMPLE_SIZE)
  436.         i -= SAMPLE_SIZE;
  437.     //-------------------------------------------------------------------------
  438.     if (i < SAMPLE_SIZE/2)
  439.         return (double)i * 2 / SAMPLE_SIZE;
  440.     //-------------------------------------------------------------------------
  441.     return 2 - (double)i * 2 / SAMPLE_SIZE;
  442. }
  443. //=============================================================================
  444. double cos1(int i)
  445. {
  446.     return 1 - sin1( i);
  447. }
  448. //=============================================================================
  449. int *wavs[ 3] = {       waveA,
  450.                         waveB,
  451.                         waveC
  452.                     };
  453. //=============================================================================
  454. void make_samples()
  455. {
  456.     #define cl (0.35)
  457.     #define cl2 (0.25)
  458.     #define clip(x) (((x>cl) ? cl : (x < cl) ? -cl : x)/cl)
  459.     #define clip2(x) ((x < -cl2) ? 0 : (x+cl2))
  460.     //-------------------------------------------------------------------------
  461.     for (int i = 0;    i < SAMPLE_SIZE;    i++)
  462.     {
  463.         double p1 = 0.8 + 0.2 * sin1( i * 4);
  464.         double p2 = 0.7 + 0.3 * cos1( i * 2);
  465.         double p3 = 0.9 + 0.1 * sin1( i);
  466.         double t = (double)(i % SAMPLE_T) * 2 * PI / SAMPLE_T;
  467.         // #define fabs(x) (x)
  468.         waveA[i] = (unsigned)( fabs(    p1 * clip( 1 + sin( 3 * t / 2)) * 0.7 +
  469.                                         p3 * clip( sin( t)) +
  470.                                         p1 * sin( 4 * t) * 0.25 +
  471.                                         p2 * clip2( cos( 1 + 6 * t))
  472.                                 ) * 0x3FFF);
  473.         waveB[i] = (unsigned)( fabs(    p1 * clip( 2 + sin( 3 * t / 2)) * 0.7 +
  474.                                         p3 * clip( sin( t)) +
  475.                                         p1 * sin( 1 + 7 * t / 2) * 0.4 +
  476.                                         p2 * clip2( cos( 2 + 5 * t))
  477.                                 ) * 0x3FFF);
  478.         waveC[i] = (unsigned)( fabs(    p1 * clip( 0.5 + sin( 3 * t / 2)) * 0.7 +
  479.                                         p3 * clip( sin( t)) +
  480.                                         p1 * sin( 0.2 + 9 * t / 2) * 0.6 +
  481.                                         p2 * clip2( cos( 3 + 5 * t))
  482.                                 ) * 0x3FFF);
  483. //      #undef fabs
  484.     }
  485.     //-------------------------------------------------------------------------
  486.     #undef clip
  487.     #undef cl
  488.     #undef cl2
  489.     #undef clip2
  490.     //-------------------------------------------------------------------------
  491.     for (int ind = 0;    ind < 3;    ind++)
  492.     {
  493.         int *arr = wavs[ind],
  494.         max = -0x7FFFFFFF,
  495.         min = 0x7FFFFFFF;
  496.         //---------------------------------------------------------------------
  497.         for (int i1 = 0;    i1 < SAMPLE_SIZE;    i1++)
  498.         {
  499.             //-----------------------------------------------------------------
  500.             if (arr[ i1] > max)
  501.                 max = arr[ i1];
  502.             //-----------------------------------------------------------------
  503.             if (arr[ i1] < min)
  504.                 min = arr[ i1];
  505.             //-----------------------------------------------------------------
  506.         }
  507.         //---------------------------------------------------------------------
  508.         for (i1 = 0;    i1 < SAMPLE_SIZE;    i1++)
  509.             arr[i1] = (int)(((double)arr[ i1] - min) * 0x10000 / (max - min));
  510.         //---------------------------------------------------------------------
  511.     }
  512.     //-------------------------------------------------------------------------
  513. }
  514. //=============================================================================
  515. */
  516.  
  517.  
  518.  
  519.