开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
pokeysnd.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：36k
源码类别：

Windows CE

开发平台：

C/C++

pokeysnd.c：源码内容
  1. /*
  2.  * pokeysnd.c - POKEY sound chip emulation, v2.4
  3.  *
  4.  * Copyright (C) 1996-1998 Ron Fries
  5.  * Copyright (C) 1998-2006 Atari800 development team (see DOC/CREDITS)
  6.  *
  7.  * This file is part of the Atari800 emulator project which emulates
  8.  * the Atari 400, 800, 800XL, 130XE, and 5200 8-bit computers.
  9.  *
  10.  * Atari800 is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * Atari800 is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with Atari800; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23. */
  25. #include "config.h"
  27. #ifdef ASAP /* external project, see http://asap.sf.net */
  28. #include "asap_internal.h"
  29. #else
  30. #include "atari.h"
  31. #ifndef __PLUS
  32. #include "sndsave.h"
  33. #else
  34. #include "sound_win.h"
  35. #endif
  36. #endif
  37. #include "mzpokeysnd.h"
  38. #include "pokeysnd.h"
  40. #ifdef WORDS_UNALIGNED_OK
  41. #  define READ_U32(x)     (*(uint32 *) (x))
  42. #  define WRITE_U32(x, d) (*(uint32 *) (x) = (d))
  43. #else
  44. #  ifdef WORDS_BIGENDIAN
  45. #    define READ_U32(x) (((*(unsigned char *)(x)) << 24) | ((*((unsigned char *)(x) + 1)) << 16) | 
  46.                         ((*((unsigned char *)(x) + 2)) << 8) | ((*((unsigned char *)(x) + 3))))
  47. #    define WRITE_U32(x, d) 
  48.   { 
  49.   uint32 i = d; 
  50.   (*(unsigned char *) (x)) = (((i) >> 24) & 255); 
  51.   (*((unsigned char *) (x) + 1)) = (((i) >> 16) & 255); 
  52.   (*((unsigned char *) (x) + 2)) = (((i) >> 8) & 255); 
  53.   (*((unsigned char *) (x) + 3)) = ((i) & 255); 
  54.   }
  55. #  else
  56. #    define READ_U32(x) ((*(unsigned char *) (x)) | ((*((unsigned char *) (x) + 1)) << 8) | 
  57.                         ((*((unsigned char *) (x) + 2)) << 16) | ((*((unsigned char *) (x) + 3)) << 24))
  58. #    define WRITE_U32(x, d) 
  59.   { 
  60.   uint32 i = d; 
  61.   (*(unsigned char *)(x)) = ((i) & 255); 
  62.   (*((unsigned char *)(x) + 1)) = (((i) >> 8) & 255); 
  63.   (*((unsigned char *)(x) + 2)) = (((i) >> 16) & 255); 
  64.   (*((unsigned char *)(x) + 3)) = (((i) >> 24) & 255); 
  65.   }
  66. #  endif
  67. #endif
  69. /* GLOBAL VARIABLE DEFINITIONS */
  71. /* number of pokey chips currently emulated */
  72. static uint8 Num_pokeys;
  74. static uint8 AUDV[4 * MAXPOKEYS]; /* Channel volume - derived */
  76. static uint8 Outbit[4 * MAXPOKEYS]; /* current state of the output (high or low) */
  78. static uint8 Outvol[4 * MAXPOKEYS]; /* last output volume for each channel */
  80. /* Initialze the bit patterns for the polynomials. */
  82. /* The 4bit and 5bit patterns are the identical ones used in the pokey chip. */
  83. /* Though the patterns could be packed with 8 bits per byte, using only a */
  84. /* single bit per byte keeps the math simple, which is important for */
  85. /* efficient processing. */
  87. static uint8 bit4[POLY4_SIZE] =
  88. #ifndef POKEY23_POLY
  89. {1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0}; /* new table invented by Perry */
  90. #else
  91. {1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0}; /* original POKEY 2.3 table */
  92. #endif
  94. static uint8 bit5[POLY5_SIZE] =
  95. #ifndef POKEY23_POLY
  96. {1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0};
  97. #else
  98. {0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1};
  99. #endif
  101. static uint32 P4 = 0, /* Global position pointer for the 4-bit  POLY array */
  102.  P5 = 0, /* Global position pointer for the 5-bit  POLY array */
  103.  P9 = 0, /* Global position pointer for the 9-bit  POLY array */
  104.  P17 = 0; /* Global position pointer for the 17-bit POLY array */
  106. static uint32 Div_n_cnt[4 * MAXPOKEYS], /* Divide by n counter. one for each channel */
  107.  Div_n_max[4 * MAXPOKEYS]; /* Divide by n maximum, one for each channel */
  109. static uint32 Samp_n_max, /* Sample max.  For accuracy, it is *256 */
  110.  Samp_n_cnt[2]; /* Sample cnt. */
  112. extern int atari_speaker;
  114. #ifdef INTERPOLATE_SOUND
  115. static uint16 last_val = 0; /* last output value */
  116. #ifdef STEREO_SOUND
  117. static uint16 last_val2 = 0; /* last output value */
  118. #endif
  119. #endif
  121. /* Volume only emulations declarations */
  122. #ifdef VOL_ONLY_SOUND
  124. #define SAMPBUF_MAX 2000
  125. int sampbuf_val[SAMPBUF_MAX]; /* volume values */
  126. int sampbuf_cnt[SAMPBUF_MAX]; /* relative start time */
  127. int sampbuf_ptr = 0; /* pointer to sampbuf */
  128. int sampbuf_rptr = 0; /* pointer to read from sampbuf */
  129. int sampbuf_last = 0; /* last absolute time */
  130. int sampbuf_AUDV[4 * MAXPOKEYS]; /* prev. channel volume */
  131. int sampbuf_lastval = 0; /* last volume */
  132. int sampout; /* last out volume */
  133. uint16 samp_freq;
  134. int samp_consol_val = 0; /* actual value of console sound */
  135. #ifdef STEREO_SOUND
  136. int sampbuf_val2[SAMPBUF_MAX]; /* volume values */
  137. int sampbuf_cnt2[SAMPBUF_MAX]; /* relative start time */
  138. int sampbuf_ptr2 = 0; /* pointer to sampbuf */
  139. int sampbuf_rptr2 = 0; /* pointer to read from sampbuf */
  140. int sampbuf_last2 = 0; /* last absolute time */
  141. int sampbuf_lastval2 = 0; /* last volume */
  142. int sampout2; /* last out volume */
  143. #endif
  144. #endif  /* VOL_ONLY_SOUND */
  146. static uint32 snd_freq17 = FREQ_17_EXACT;
  147. int32 snd_playback_freq = 44100;
  148. uint8 snd_num_pokeys = 1;
  149. static int snd_flags = 0;
  150. static int mz_quality = 0; /* default quality for mzpokeysnd */
  151. #ifdef __PLUS
  152. int mz_clear_regs = 0;
  153. #endif
  155. int enable_new_pokey = TRUE;
  156. #ifndef ASAP
  157. int stereo_enabled = FALSE;
  158. #endif
  160. /* multiple sound engine interface */
  161. static void Pokey_process_8(void *sndbuffer, unsigned sndn);
  162. static void Pokey_process_16(void *sndbuffer, unsigned sndn);
  163. static void null_pokey_process(void *sndbuffer, unsigned int sndn) {}
  164. void (*Pokey_process_ptr)(void *sndbuffer, unsigned int sndn) = null_pokey_process;
  166. static void Update_pokey_sound_rf(uint16, uint8, uint8, uint8);
  167. static void null_pokey_sound(uint16 addr, uint8 val, uint8 chip, uint8 gain) {}
  168. void (*Update_pokey_sound) (uint16 addr, uint8 val, uint8 chip, uint8 gain)
  169.   = null_pokey_sound;
  171. #ifdef SERIO_SOUND
  172. static void Update_serio_sound_rf(int out, UBYTE data);
  173. static void null_serio_sound(int out, UBYTE data) {}
  174. void (*Update_serio_sound)(int out, UBYTE data) = null_serio_sound;
  175. int serio_sound_enabled = 1;
  176. #endif
  178. #ifdef CONSOLE_SOUND
  179. static void Update_consol_sound_rf(int set);
  180. static void null_consol_sound(int set) {}
  181. void (*Update_consol_sound)(int set) = null_consol_sound;
  182. int console_sound_enabled = 1;
  183. #endif
  185. #ifdef VOL_ONLY_SOUND
  186. static void Update_vol_only_sound_rf(void);
  187. static void null_vol_only_sound(void) {}
  188. void (*Update_vol_only_sound)(void) = null_vol_only_sound;
  189. #endif
  191. /*****************************************************************************/
  192. /* In my routines, I treat the sample output as another divide by N counter  */
  193. /* For better accuracy, the Samp_n_cnt has a fixed binary decimal point      */
  194. /* which has 8 binary digits to the right of the decimal point.  I use a two */
  195. /* byte array to give me a minimum of 40 bits, and then use pointer math to  */
  196. /* reference either the 24.8 whole/fraction combination or the 32-bit whole  */
  197. /* only number.  This is mainly used to keep the math simple for             */
  198. /* optimization. See below:                                                  */
  199. /*                                                                           */
  200. /* Representation on little-endian machines:                                 */
  201. /* xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx | xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx */
  202. /* fraction   whole    whole    whole      whole   unused   unused   unused  */
  203. /*                                                                           */
  204. /* Samp_n_cnt[0] gives me a 32-bit int 24 whole bits with 8 fractional bits, */
  205. /* while (uint32 *)((uint8 *)(&Samp_n_cnt[0])+1) gives me the 32-bit whole   */
  206. /* number only.                                                              */
  207. /*                                                                           */
  208. /* Representation on big-endian machines:                                    */
  209. /* xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx | xxxxxxxx xxxxxxxx xxxxxxxx.xxxxxxxx */
  210. /*  unused   unused   unused    whole      whole    whole    whole  fraction */
  211. /*                                                                           */
  212. /* Samp_n_cnt[1] gives me a 32-bit int 24 whole bits with 8 fractional bits, */
  213. /* while (uint32 *)((uint8 *)(&Samp_n_cnt[0])+3) gives me the 32-bit whole   */
  214. /* number only.                                                              */
  215. /*****************************************************************************/
  218. /*****************************************************************************/
  219. /* Module:  Pokey_sound_init()                                               */
  220. /* Purpose: to handle the power-up initialization functions                  */
  221. /*          these functions should only be executed on a cold-restart        */
  222. /*                                                                           */
  223. /* Author:  Ron Fries                                                        */
  224. /* Date:    January 1, 1997                                                  */
  225. /*                                                                           */
  226. /* Inputs:  freq17 - the value for the '1.79MHz' Pokey audio clock           */
  227. /*          playback_freq - the playback frequency in samples per second     */
  228. /*          num_pokeys - specifies the number of pokey chips to be emulated  */
  229. /*                                                                           */
  230. /* Outputs: Adjusts local globals - no return value                          */
  231. /*                                                                           */
  232. /*****************************************************************************/
  234. static int Pokey_sound_init_rf(uint32 freq17, uint16 playback_freq,
  235.            uint8 num_pokeys, unsigned int flags);
  237. int Pokey_DoInit(void)
  238. {
  239. if (enable_new_pokey)
  240. return Pokey_sound_init_mz(snd_freq17, (uint16) snd_playback_freq,
  241. snd_num_pokeys, snd_flags, mz_quality
  242. #ifdef __PLUS
  243. , mz_clear_regs
  244. #endif
  245. );
  246. else
  247. return Pokey_sound_init_rf(snd_freq17, (uint16) snd_playback_freq,
  248. snd_num_pokeys, snd_flags);
  249. }
  251. int Pokey_sound_init(uint32 freq17, uint16 playback_freq, uint8 num_pokeys,
  252.                      unsigned int flags
  253. #ifdef __PLUS
  254.                      , int clear_regs
  255. #endif
  256. )
  257. {
  258. snd_freq17 = freq17;
  259. snd_playback_freq = playback_freq;
  260. snd_num_pokeys = num_pokeys;
  261. snd_flags = flags;
  262. #ifdef __PLUS
  263. mz_clear_regs = clear_regs;
  264. #endif
  266. return Pokey_DoInit();
  267. }
  269. void Pokey_set_mzquality(int quality) /* specially for win32, perhaps not needed? */
  270. {
  271. mz_quality = quality;
  272. }
  274. void Pokey_process(void *sndbuffer, unsigned int sndn)
  275. {
  276. Pokey_process_ptr(sndbuffer, sndn);
  277. #if !defined(__PLUS) && !defined(ASAP)
  278. WriteToSoundFile(sndbuffer, sndn);
  279. #endif
  280. }
  282. static int Pokey_sound_init_rf(uint32 freq17, uint16 playback_freq,
  283.            uint8 num_pokeys, unsigned int flags)
  284. {
  285. uint8 chan;
  287. Update_pokey_sound = Update_pokey_sound_rf;
  288. #ifdef SERIO_SOUND
  289. Update_serio_sound = Update_serio_sound_rf;
  290. #endif
  291. #ifdef CONSOLE_SOUND
  292. Update_consol_sound = Update_consol_sound_rf;
  293. #endif
  294. #ifdef VOL_ONLY_SOUND
  295. Update_vol_only_sound = Update_vol_only_sound_rf;
  296. #endif
  298. Pokey_process_ptr = (flags & SND_BIT16) ? Pokey_process_16 : Pokey_process_8;
  300. #ifdef VOL_ONLY_SOUND
  301. samp_freq = playback_freq;
  302. #endif
  304. /* start all of the polynomial counters at zero */
  305. P4 = 0;
  306. P5 = 0;
  307. P9 = 0;
  308. P17 = 0;
  310. /* calculate the sample 'divide by N' value based on the playback freq. */
  311. Samp_n_max = ((uint32) freq17 << 8) / playback_freq;
  313. Samp_n_cnt[0] = 0; /* initialize all bits of the sample */
  314. Samp_n_cnt[1] = 0; /* 'divide by N' counter */
  316. for (chan = 0; chan < (MAXPOKEYS * 4); chan++) {
  317. Outvol[chan] = 0;
  318. Outbit[chan] = 0;
  319. Div_n_cnt[chan] = 0;
  320. Div_n_max[chan] = 0x7fffffffL;
  321. AUDV[chan] = 0;
  322. #ifdef VOL_ONLY_SOUND
  323. sampbuf_AUDV[chan] = 0;
  324. #endif
  325. }
  327. /* set the number of pokey chips currently emulated */
  328. Num_pokeys = num_pokeys;
  330. return 0; /* OK */
  331. }
  334. /*****************************************************************************/
  335. /* Module:  Update_pokey_sound()                                             */
  336. /* Purpose: To process the latest control values stored in the AUDF, AUDC,   */
  337. /*          and AUDCTL registers.  It pre-calculates as much information as  */
  338. /*          possible for better performance.  This routine has not been      */
  339. /*          optimized.                                                       */
  340. /*                                                                           */
  341. /* Author:  Ron Fries                                                        */
  342. /* Date:    January 1, 1997                                                  */
  343. /*                                                                           */
  344. /* Inputs:  addr - the address of the parameter to be changed                */
  345. /*          val - the new value to be placed in the specified address        */
  346. /*          gain - specified as an 8-bit fixed point number - use 1 for no   */
  347. /*                 amplification (output is multiplied by gain)              */
  348. /*                                                                           */
  349. /* Outputs: Adjusts local globals - no return value                          */
  350. /*                                                                           */
  351. /*****************************************************************************/
  353. static void Update_pokey_sound_rf(uint16 addr, uint8 val, uint8 chip,
  354.   uint8 gain)
  355. {
  356. uint32 new_val = 0;
  357. uint8 chan;
  358. uint8 chan_mask;
  359. uint8 chip_offs;
  361. /* calculate the chip_offs for the channel arrays */
  362. chip_offs = chip << 2;
  364. /* determine which address was changed */
  365. switch (addr & 0x0f) {
  366. case _AUDF1:
  367. /* AUDF[CHAN1 + chip_offs] = val; */
  368. chan_mask = 1 << CHAN1;
  369. if (AUDCTL[chip] & CH1_CH2) /* if ch 1&2 tied together */
  370. chan_mask |= 1 << CHAN2; /* then also change on ch2 */
  371. break;
  372. case _AUDC1:
  373. /* AUDC[CHAN1 + chip_offs] = val; */
  374. AUDV[CHAN1 + chip_offs] = (val & VOLUME_MASK) * gain;
  375. chan_mask = 1 << CHAN1;
  376. break;
  377. case _AUDF2:
  378. /* AUDF[CHAN2 + chip_offs] = val; */
  379. chan_mask = 1 << CHAN2;
  380. break;
  381. case _AUDC2:
  382. /* AUDC[CHAN2 + chip_offs] = val; */
  383. AUDV[CHAN2 + chip_offs] = (val & VOLUME_MASK) * gain;
  384. chan_mask = 1 << CHAN2;
  385. break;
  386. case _AUDF3:
  387. /* AUDF[CHAN3 + chip_offs] = val; */
  388. chan_mask = 1 << CHAN3;
  389. if (AUDCTL[chip] & CH3_CH4) /* if ch 3&4 tied together */
  390. chan_mask |= 1 << CHAN4; /* then also change on ch4 */
  391. break;
  392. case _AUDC3:
  393. /* AUDC[CHAN3 + chip_offs] = val; */
  394. AUDV[CHAN3 + chip_offs] = (val & VOLUME_MASK) * gain;
  395. chan_mask = 1 << CHAN3;
  396. break;
  397. case _AUDF4:
  398. /* AUDF[CHAN4 + chip_offs] = val; */
  399. chan_mask = 1 << CHAN4;
  400. break;
  401. case _AUDC4:
  402. /* AUDC[CHAN4 + chip_offs] = val; */
  403. AUDV[CHAN4 + chip_offs] = (val & VOLUME_MASK) * gain;
  404. chan_mask = 1 << CHAN4;
  405. break;
  406. case _AUDCTL:
  407. /* AUDCTL[chip] = val; */
  408. chan_mask = 15; /* all channels */
  409. break;
  410. default:
  411. chan_mask = 0;
  412. break;
  413. }
  415. /************************************************************/
  416. /* As defined in the manual, the exact Div_n_cnt values are */
  417. /* different depending on the frequency and resolution:     */
  418. /*    64 kHz or 15 kHz - AUDF + 1                           */
  419. /*    1 MHz, 8-bit -     AUDF + 4                           */
  420. /*    1 MHz, 16-bit -    AUDF[CHAN1]+256*AUDF[CHAN2] + 7    */
  421. /************************************************************/
  423. /* only reset the channels that have changed */
  425. if (chan_mask & (1 << CHAN1)) {
  426. /* process channel 1 frequency */
  427. if (AUDCTL[chip] & CH1_179)
  428. new_val = AUDF[CHAN1 + chip_offs] + 4;
  429. else
  430. new_val = (AUDF[CHAN1 + chip_offs] + 1) * Base_mult[chip];
  432. if (new_val != Div_n_max[CHAN1 + chip_offs]) {
  433. Div_n_max[CHAN1 + chip_offs] = new_val;
  435. if (Div_n_cnt[CHAN1 + chip_offs] > new_val) {
  436. Div_n_cnt[CHAN1 + chip_offs] = new_val;
  437. }
  438. }
  439. }
  441. if (chan_mask & (1 << CHAN2)) {
  442. /* process channel 2 frequency */
  443. if (AUDCTL[chip] & CH1_CH2) {
  444. if (AUDCTL[chip] & CH1_179)
  445. new_val = AUDF[CHAN2 + chip_offs] * 256 +
  446. AUDF[CHAN1 + chip_offs] + 7;
  447. else
  448. new_val = (AUDF[CHAN2 + chip_offs] * 256 +
  449.    AUDF[CHAN1 + chip_offs] + 1) * Base_mult[chip];
  450. }
  451. else
  452. new_val = (AUDF[CHAN2 + chip_offs] + 1) * Base_mult[chip];
  454. if (new_val != Div_n_max[CHAN2 + chip_offs]) {
  455. Div_n_max[CHAN2 + chip_offs] = new_val;
  457. if (Div_n_cnt[CHAN2 + chip_offs] > new_val) {
  458. Div_n_cnt[CHAN2 + chip_offs] = new_val;
  459. }
  460. }
  461. }
  463. if (chan_mask & (1 << CHAN3)) {
  464. /* process channel 3 frequency */
  465. if (AUDCTL[chip] & CH3_179)
  466. new_val = AUDF[CHAN3 + chip_offs] + 4;
  467. else
  468. new_val = (AUDF[CHAN3 + chip_offs] + 1) * Base_mult[chip];
  470. if (new_val != Div_n_max[CHAN3 + chip_offs]) {
  471. Div_n_max[CHAN3 + chip_offs] = new_val;
  473. if (Div_n_cnt[CHAN3 + chip_offs] > new_val) {
  474. Div_n_cnt[CHAN3 + chip_offs] = new_val;
  475. }
  476. }
  477. }
  479. if (chan_mask & (1 << CHAN4)) {
  480. /* process channel 4 frequency */
  481. if (AUDCTL[chip] & CH3_CH4) {
  482. if (AUDCTL[chip] & CH3_179)
  483. new_val = AUDF[CHAN4 + chip_offs] * 256 +
  484. AUDF[CHAN3 + chip_offs] + 7;
  485. else
  486. new_val = (AUDF[CHAN4 + chip_offs] * 256 +
  487.    AUDF[CHAN3 + chip_offs] + 1) * Base_mult[chip];
  488. }
  489. else
  490. new_val = (AUDF[CHAN4 + chip_offs] + 1) * Base_mult[chip];
  492. if (new_val != Div_n_max[CHAN4 + chip_offs]) {
  493. Div_n_max[CHAN4 + chip_offs] = new_val;
  495. if (Div_n_cnt[CHAN4 + chip_offs] > new_val) {
  496. Div_n_cnt[CHAN4 + chip_offs] = new_val;
  497. }
  498. }
  499. }
  501. /* if channel is volume only, set current output */
  502. for (chan = CHAN1; chan <= CHAN4; chan++) {
  503. if (chan_mask & (1 << chan)) {
  505. #ifdef VOL_ONLY_SOUND
  507. #ifdef __PLUS
  508. if (g_Sound.nDigitized)
  509. #endif
  510. if ((AUDC[chan + chip_offs] & VOL_ONLY)) {
  512. #ifdef STEREO_SOUND
  514. #ifdef __PLUS
  515. if (stereo_enabled && chip & 0x01)
  516. #else
  517. if (chip & 0x01)
  518. #endif
  519. {
  520. sampbuf_lastval2 += AUDV[chan + chip_offs]
  521. - sampbuf_AUDV[chan + chip_offs];
  523. sampbuf_val2[sampbuf_ptr2] = sampbuf_lastval2;
  524. sampbuf_AUDV[chan + chip_offs] = AUDV[chan + chip_offs];
  525. sampbuf_cnt2[sampbuf_ptr2] =
  526. (cpu_clock - sampbuf_last2) * 128 * samp_freq / 178979;
  527. sampbuf_last2 = cpu_clock;
  528. sampbuf_ptr2++;
  529. if (sampbuf_ptr2 >= SAMPBUF_MAX)
  530. sampbuf_ptr2 = 0;
  531. if (sampbuf_ptr2 == sampbuf_rptr2) {
  532. sampbuf_rptr2++;
  533. if (sampbuf_rptr2 >= SAMPBUF_MAX)
  534. sampbuf_rptr2 = 0;
  535. }
  536. }
  537. else
  538. #endif /* STEREO_SOUND */
  539. {
  540. sampbuf_lastval += AUDV[chan + chip_offs]
  541. -sampbuf_AUDV[chan + chip_offs];
  543. sampbuf_val[sampbuf_ptr] = sampbuf_lastval;
  544. sampbuf_AUDV[chan + chip_offs] = AUDV[chan + chip_offs];
  545. sampbuf_cnt[sampbuf_ptr] =
  546. (cpu_clock - sampbuf_last) * 128 * samp_freq / 178979;
  547. sampbuf_last = cpu_clock;
  548. sampbuf_ptr++;
  549. if (sampbuf_ptr >= SAMPBUF_MAX)
  550. sampbuf_ptr = 0;
  551. if (sampbuf_ptr == sampbuf_rptr) {
  552. sampbuf_rptr++;
  553. if (sampbuf_rptr >= SAMPBUF_MAX)
  554. sampbuf_rptr = 0;
  555. }
  556. }
  557. }
  559. #endif /* VOL_ONLY_SOUND */
  561. /* I've disabled any frequencies that exceed the sampling
  562.    frequency.  There isn't much point in processing frequencies
  563.    that the hardware can't reproduce.  I've also disabled
  564.    processing if the volume is zero. */
  566. /* if the channel is volume only */
  567. /* or the channel is off (volume == 0) */
  568. /* or the channel freq is greater than the playback freq */
  569. if ( (AUDC[chan + chip_offs] & VOL_ONLY) ||
  570. ((AUDC[chan + chip_offs] & VOLUME_MASK) == 0)
  571. #if defined(__PLUS) && !defined(_WX_)
  572. || (!g_Sound.nBieniasFix && (Div_n_max[chan + chip_offs] < (Samp_n_max >> 8)))
  573. #else
  574. /* || (Div_n_max[chan + chip_offs] < (Samp_n_max >> 8))*/
  575. #endif
  576. ) {
  577. /* indicate the channel is 'on' */
  578. Outvol[chan + chip_offs] = 1;
  580. /* can only ignore channel if filtering off */
  581. if ((chan == CHAN3 && !(AUDCTL[chip] & CH1_FILTER)) ||
  582. (chan == CHAN4 && !(AUDCTL[chip] & CH2_FILTER)) ||
  583. (chan == CHAN1) ||
  584. (chan == CHAN2)
  585. #if defined(__PLUS) && !defined(_WX_)
  586. || (!g_Sound.nBieniasFix && (Div_n_max[chan + chip_offs] < (Samp_n_max >> 8)))
  587. #else
  588. /* || (Div_n_max[chan + chip_offs] < (Samp_n_max >> 8))*/
  589. #endif
  590. ) {
  591. /* and set channel freq to max to reduce processing */
  592. Div_n_max[chan + chip_offs] = 0x7fffffffL;
  593. Div_n_cnt[chan + chip_offs] = 0x7fffffffL;
  594. }
  595. }
  596. }
  597. }
  599. /*    _enable(); */ /* RSF - removed for portability 31-MAR-97 */
  600. }
  603. /*****************************************************************************/
  604. /* Module:  Pokey_process()                                                  */
  605. /* Purpose: To fill the output buffer with the sound output based on the     */
  606. /*          pokey chip parameters.                                           */
  607. /*                                                                           */
  608. /* Author:  Ron Fries                                                        */
  609. /* Date:    January 1, 1997                                                  */
  610. /*                                                                           */
  611. /* Inputs:  *buffer - pointer to the buffer where the audio output will      */
  612. /*                    be placed                                              */
  613. /*          n - size of the playback buffer                                  */
  614. /*          num_pokeys - number of currently active pokeys to process        */
  615. /*                                                                           */
  616. /* Outputs: the buffer will be filled with n bytes of audio - no return val  */
  617. /*          Also the buffer will be written to disk if Sound recording is ON */
  618. /*                                                                           */
  619. /*****************************************************************************/
  621. static void Pokey_process_8(void *sndbuffer, unsigned sndn)
  622. {
  623. register uint8 *buffer = (uint8 *) sndbuffer;
  624. register uint16 n = sndn;
  626. register uint32 *div_n_ptr;
  627. register uint8 *samp_cnt_w_ptr;
  628. register uint32 event_min;
  629. register uint8 next_event;
  630. #ifdef CLIP_SOUND
  631. register int16 cur_val; /* then we have to count as 16-bit signed */
  632. #ifdef STEREO_SOUND
  633. register int16 cur_val2;
  634. #endif
  635. #else /* CLIP_SOUND */
  636. register uint8 cur_val; /* otherwise we'll simplify as 8-bit unsigned */
  637. #ifdef STEREO_SOUND
  638. register uint8 cur_val2;
  639. #endif
  640. #endif /* CLIP_SOUND */
  641. register uint8 *out_ptr;
  642. register uint8 audc;
  643. register uint8 toggle;
  644. register uint8 count;
  645. register uint8 *vol_ptr;
  647. /* set a pointer to the whole portion of the samp_n_cnt */
  648. #ifdef WORDS_BIGENDIAN
  649. samp_cnt_w_ptr = ((uint8 *) (&Samp_n_cnt[0]) + 3);
  650. #else
  651. samp_cnt_w_ptr = ((uint8 *) (&Samp_n_cnt[0]) + 1);
  652. #endif
  654. /* set a pointer for optimization */
  655. out_ptr = Outvol;
  656. vol_ptr = AUDV;
  658. /* The current output is pre-determined and then adjusted based on each */
  659. /* output change for increased performance (less over-all math). */
  660. /* add the output values of all 4 channels */
  661. cur_val = SAMP_MIN;
  662. #ifdef STEREO_SOUND
  663. #ifdef __PLUS
  664. if (stereo_enabled)
  665. #endif
  666. cur_val2 = SAMP_MIN;
  667. #endif /* STEREO_SOUND */
  669. count = Num_pokeys;
  670. do {
  671. if (*out_ptr++)
  672. cur_val += *vol_ptr;
  673. vol_ptr++;
  675. if (*out_ptr++)
  676. cur_val += *vol_ptr;
  677. vol_ptr++;
  679. if (*out_ptr++)
  680. cur_val += *vol_ptr;
  681. vol_ptr++;
  683. if (*out_ptr++)
  684. cur_val += *vol_ptr;
  685. vol_ptr++;
  686. #ifdef STEREO_SOUND
  687. #ifdef __PLUS
  688. if (stereo_enabled)
  689. #endif
  690. {
  691. count--;
  692. if (count) {
  693. if (*out_ptr++)
  694. cur_val2 += *vol_ptr;
  695. vol_ptr++;
  697. if (*out_ptr++)
  698. cur_val2 += *vol_ptr;
  699. vol_ptr++;
  701. if (*out_ptr++)
  702. cur_val2 += *vol_ptr;
  703. vol_ptr++;
  705. if (*out_ptr++)
  706. cur_val2 += *vol_ptr;
  707. vol_ptr++;
  708. }
  709. else
  710. break;
  711. }
  712. #endif /* STEREO_SOUND */
  713. count--;
  714. } while (count);
  715. /*
  716. #if defined (USE_DOSSOUND)
  717. cur_val += 32 * atari_speaker;
  718. #endif
  719. */
  721. /* loop until the buffer is filled */
  722. while (n) {
  723. /* Normally the routine would simply decrement the 'div by N' */
  724. /* counters and react when they reach zero.  Since we normally */
  725. /* won't be processing except once every 80 or so counts, */
  726. /* I've optimized by finding the smallest count and then */
  727. /* 'accelerated' time by adjusting all pointers by that amount. */
  729. /* find next smallest event (either sample or chan 1-4) */
  730. next_event = SAMPLE;
  731. event_min = READ_U32(samp_cnt_w_ptr);
  733. div_n_ptr = Div_n_cnt;
  735. count = 0;
  736. do {
  737. /* Though I could have used a loop here, this is faster */
  738. if (*div_n_ptr <= event_min) {
  739. event_min = *div_n_ptr;
  740. next_event = CHAN1 + (count << 2);
  741. }
  742. div_n_ptr++;
  743. if (*div_n_ptr <= event_min) {
  744. event_min = *div_n_ptr;
  745. next_event = CHAN2 + (count << 2);
  746. }
  747. div_n_ptr++;
  748. if (*div_n_ptr <= event_min) {
  749. event_min = *div_n_ptr;
  750. next_event = CHAN3 + (count << 2);
  751. }
  752. div_n_ptr++;
  753. if (*div_n_ptr <= event_min) {
  754. event_min = *div_n_ptr;
  755. next_event = CHAN4 + (count << 2);
  756. }
  757. div_n_ptr++;
  759. count++;
  760. } while (count < Num_pokeys);
  762. /* if the next event is a channel change */
  763. if (next_event != SAMPLE) {
  764. /* shift the polynomial counters */
  766. count = Num_pokeys;
  767. do {
  768. /* decrement all counters by the smallest count found */
  769. /* again, no loop for efficiency */
  770. div_n_ptr--;
  771. *div_n_ptr -= event_min;
  772. div_n_ptr--;
  773. *div_n_ptr -= event_min;
  774. div_n_ptr--;
  775. *div_n_ptr -= event_min;
  776. div_n_ptr--;
  777. *div_n_ptr -= event_min;
  779. count--;
  780. } while (count);
  783. WRITE_U32(samp_cnt_w_ptr, READ_U32(samp_cnt_w_ptr) - event_min);
  785. /* since the polynomials require a mod (%) function which is
  786.    division, I don't adjust the polynomials on the SAMPLE events,
  787.    only the CHAN events.  I have to keep track of the change,
  788.    though. */
  790. P4 = (P4 + event_min) % POLY4_SIZE;
  791. P5 = (P5 + event_min) % POLY5_SIZE;
  792. P9 = (P9 + event_min) % POLY9_SIZE;
  793. P17 = (P17 + event_min) % POLY17_SIZE;
  795. /* adjust channel counter */
  796. Div_n_cnt[next_event] += Div_n_max[next_event];
  798. /* get the current AUDC into a register (for optimization) */
  799. audc = AUDC[next_event];
  801. /* set a pointer to the current output (for opt...) */
  802. out_ptr = &Outvol[next_event];
  804. /* assume no changes to the output */
  805. toggle = FALSE;
  807. /* From here, a good understanding of the hardware is required */
  808. /* to understand what is happening.  I won't be able to provide */
  809. /* much description to explain it here. */
  811. /* if VOLUME only then nothing to process */
  812. if (!(audc & VOL_ONLY)) {
  813. /* if the output is pure or the output is poly5 and the poly5 bit */
  814. /* is set */
  815. if ((audc & NOTPOLY5) || bit5[P5]) {
  816. /* if the PURETONE bit is set */
  817. if (audc & PURETONE) {
  818. /* then simply toggle the output */
  819. toggle = TRUE;
  820. }
  821. /* otherwise if POLY4 is selected */
  822. else if (audc & POLY4) {
  823. /* then compare to the poly4 bit */
  824. toggle = (bit4[P4] == !(*out_ptr));
  825. }
  826. else {
  827. /* if 9-bit poly is selected on this chip */
  828. if (AUDCTL[next_event >> 2] & POLY9) {
  829. /* compare to the poly9 bit */
  830. toggle = ((poly9_lookup[P9] & 1) == !(*out_ptr));
  831. }
  832. else {
  833. /* otherwise compare to the poly17 bit */
  834. toggle = (((poly17_lookup[P17 >> 3] >> (P17 & 7)) & 1) == !(*out_ptr));
  835. }
  836. }
  837. }
  838. }
  840. /* check channel 1 filter (clocked by channel 3) */
  841. if ( AUDCTL[next_event >> 2] & CH1_FILTER) {
  842. /* if we're processing channel 3 */
  843. if ((next_event & 0x03) == CHAN3) {
  844. /* check output of channel 1 on same chip */
  845. if (Outvol[next_event & 0xfd]) {
  846. /* if on, turn it off */
  847. Outvol[next_event & 0xfd] = 0;
  848. #ifdef STEREO_SOUND
  849. #ifdef __PLUS
  850. if (stereo_enabled && (next_event & 0x04))
  851. #else
  852. if ((next_event & 0x04))
  853. #endif
  854. cur_val2 -= AUDV[next_event & 0xfd];
  855. else
  856. #endif /* STEREO_SOUND */
  857. cur_val -= AUDV[next_event & 0xfd];
  858. }
  859. }
  860. }
  862. /* check channel 2 filter (clocked by channel 4) */
  863. if ( AUDCTL[next_event >> 2] & CH2_FILTER) {
  864. /* if we're processing channel 4 */
  865. if ((next_event & 0x03) == CHAN4) {
  866. /* check output of channel 2 on same chip */
  867. if (Outvol[next_event & 0xfd]) {
  868. /* if on, turn it off */
  869. Outvol[next_event & 0xfd] = 0;
  870. #ifdef STEREO_SOUND
  871. #ifdef __PLUS
  872. if (stereo_enabled && (next_event & 0x04))
  873. #else
  874. if ((next_event & 0x04))
  875. #endif
  876. cur_val2 -= AUDV[next_event & 0xfd];
  877. else
  878. #endif /* STEREO_SOUND */
  879. cur_val -= AUDV[next_event & 0xfd];
  880. }
  881. }
  882. }
  884. /* if the current output bit has changed */
  885. if (toggle) {
  886. if (*out_ptr) {
  887. /* remove this channel from the signal */
  888. #ifdef STEREO_SOUND
  889. #ifdef __PLUS
  890. if (stereo_enabled && (next_event & 0x04))
  891. #else
  892. if ((next_event & 0x04))
  893. #endif
  894. cur_val2 -= AUDV[next_event];
  895. else
  896. #endif /* STEREO_SOUND */
  897. cur_val -= AUDV[next_event];
  899. /* and turn the output off */
  900. *out_ptr = 0;
  901. }
  902. else {
  903. /* turn the output on */
  904. *out_ptr = 1;
  906. /* and add it to the output signal */
  907. #ifdef STEREO_SOUND
  908. #ifdef __PLUS
  909. if (stereo_enabled && (next_event & 0x04))
  910. #else
  911. if ((next_event & 0x04))
  912. #endif
  913. cur_val2 += AUDV[next_event];
  914. else
  915. #endif /* STEREO_SOUND */
  916. cur_val += AUDV[next_event];
  917. }
  918. }
  919. }
  920. else { /* otherwise we're processing a sample */
  921. /* adjust the sample counter - note we're using the 24.8 integer
  922.    which includes an 8 bit fraction for accuracy */
  924. int iout;
  925. #ifdef STEREO_SOUND
  926. int iout2;
  927. #endif
  928. #ifdef INTERPOLATE_SOUND
  929. if (cur_val != last_val) {
  930. if (*Samp_n_cnt < Samp_n_max) { /* need interpolation */
  931. iout = (cur_val * (*Samp_n_cnt) +
  932. last_val * (Samp_n_max - *Samp_n_cnt))
  933. / Samp_n_max;
  934. }
  935. else
  936. iout = cur_val;
  937. last_val = cur_val;
  938. }
  939. else
  940. iout = cur_val;
  941. #ifdef STEREO_SOUND
  942. #ifdef __PLUS
  943. if (stereo_enabled)
  944. #endif
  945. if (cur_val2 != last_val2) {
  946. if (*Samp_n_cnt < Samp_n_max) { /* need interpolation */
  947. iout2 = (cur_val2 * (*Samp_n_cnt) +
  948. last_val2 * (Samp_n_max - *Samp_n_cnt))
  949. / Samp_n_max;
  950. }
  951. else
  952. iout2 = cur_val2;
  953. last_val2 = cur_val2;
  954. }
  955. else
  956. iout2 = cur_val2;
  957. #endif  /* STEREO_SOUND */
  958. #else   /* INTERPOLATE_SOUND */
  959. iout = cur_val;
  960. #ifdef STEREO_SOUND
  961. #ifdef __PLUS
  962. if (stereo_enabled)
  963. #endif
  964. iout2 = cur_val2;
  965. #endif  /* STEREO_SOUND */
  966. #endif  /* INTERPOLATE_SOUND */
  968. #ifdef VOL_ONLY_SOUND
  969. #ifdef __PLUS
  970. if (g_Sound.nDigitized)
  971. #endif
  972. {
  973. if (sampbuf_rptr != sampbuf_ptr) {
  974. int l;
  975. if (sampbuf_cnt[sampbuf_rptr] > 0)
  976. sampbuf_cnt[sampbuf_rptr] -= 1280;
  977. while ((l = sampbuf_cnt[sampbuf_rptr]) <= 0) {
  978. sampout = sampbuf_val[sampbuf_rptr];
  979. sampbuf_rptr++;
  980. if (sampbuf_rptr >= SAMPBUF_MAX)
  981. sampbuf_rptr = 0;
  982. if (sampbuf_rptr != sampbuf_ptr)
  983. sampbuf_cnt[sampbuf_rptr] += l;
  984. else
  985. break;
  986. }
  987. }
  988. iout += sampout;
  989. #ifdef STEREO_SOUND
  990. #ifdef __PLUS
  991. if (stereo_enabled)
  992. #endif
  993. {
  994. if (sampbuf_rptr2 != sampbuf_ptr2) {
  995. int l;
  996. if (sampbuf_cnt2[sampbuf_rptr2] > 0)
  997. sampbuf_cnt2[sampbuf_rptr2] -= 1280;
  998. while ((l = sampbuf_cnt2[sampbuf_rptr2]) <= 0) {
  999. sampout2 = sampbuf_val2[sampbuf_rptr2];
  1000. sampbuf_rptr2++;
  1001. if (sampbuf_rptr2 >= SAMPBUF_MAX)
  1002. sampbuf_rptr2 = 0;
  1003. if (sampbuf_rptr2 != sampbuf_ptr2)
  1004. sampbuf_cnt2[sampbuf_rptr2] += l;
  1005. else
  1006. break;
  1007. }
  1008. }
  1009. iout2 += sampout2;
  1010. }
  1011. #endif  /* STEREO_SOUND */
  1012. }
  1013. #endif  /* VOL_ONLY_SOUND */
  1015. #ifdef CLIP_SOUND
  1016. if (iout > SAMP_MAX) { /* then check high limit */
  1017. *buffer++ = (uint8) SAMP_MAX; /* and limit if greater */
  1018. }
  1019. else if (iout < SAMP_MIN) { /* else check low limit */
  1020. *buffer++ = (uint8) SAMP_MIN; /* and limit if less */
  1021. }
  1022. else { /* otherwise use raw value */
  1023. *buffer++ = (uint8) iout;
  1024. }
  1025. #ifdef STEREO_SOUND
  1026. #ifdef __PLUS
  1027. if (stereo_enabled) {
  1028. if (iout2 > SAMP_MAX)
  1029. *buffer++ = (uint8) SAMP_MAX;
  1030. else if (iout2 < SAMP_MIN)
  1031. *buffer++ = (uint8) SAMP_MIN;
  1032. else
  1033. *buffer++ = (uint8) iout2;
  1034. }
  1035. #else /* __PLUS */
  1036. if (Num_pokeys > 1) {
  1037. if ((stereo_enabled ? iout2 : iout) > SAMP_MAX) { /* then check high limit */
  1038. *buffer++ = (uint8) SAMP_MAX; /* and limit if greater */
  1039. }
  1040. else if ((stereo_enabled ? iout2 : iout) < SAMP_MIN) { /* else check low limit */
  1041. *buffer++ = (uint8) SAMP_MIN; /* and limit if less */
  1042. }
  1043. else { /* otherwise use raw value */
  1044. *buffer++ = (uint8) (stereo_enabled ? iout2 : iout);
  1045. }
  1046. }
  1047. #endif /* __PLUS */
  1048. #endif /* STEREO_SOUND */
  1049. #else /* CLIP_SOUND */
  1050. *buffer++ = (uint8) iout; /* clipping not selected, use value */
  1051. #ifdef STEREO_SOUND
  1052. if (Num_pokeys > 1)
  1053. #ifdef ASAP
  1054. *buffer++ = (uint8) iout2;
  1055. #else
  1056. *buffer++ = (uint8) (stereo_enabled ? iout2 : iout);
  1057. #endif
  1058. #endif /* STEREO_SOUND */
  1059. #endif /* CLIP_SOUND */
  1061. #ifdef WORDS_BIGENDIAN
  1062. *(Samp_n_cnt + 1) += Samp_n_max;
  1063. #else
  1064. *Samp_n_cnt += Samp_n_max;
  1065. #endif
  1066. /* and indicate one less byte in the buffer */
  1067. n--;
  1068. #ifdef STEREO_SOUND
  1069. #ifdef __PLUS
  1070. if (stereo_enabled)
  1071. #endif
  1072. if (Num_pokeys > 1)
  1073. n--;
  1074. #endif
  1075. }
  1076. }
  1077. #ifdef VOL_ONLY_SOUND
  1078. #ifdef __PLUS
  1079. if (g_Sound.nDigitized)
  1080. #endif
  1081. {
  1082. if (sampbuf_rptr == sampbuf_ptr)
  1083. sampbuf_last = cpu_clock;
  1084. #ifdef STEREO_SOUND
  1085. #ifdef __PLUS
  1086. if (stereo_enabled)
  1087. #endif
  1088. if (sampbuf_rptr2 == sampbuf_ptr2)
  1089. sampbuf_last2 = cpu_clock;
  1090. #endif /* STEREO_SOUND */
  1091. }
  1092. #endif  /* VOL_ONLY_SOUND */
  1093. }
  1095. #ifdef SERIO_SOUND
  1096. static void Update_serio_sound_rf(int out, UBYTE data)
  1097. {
  1098. #ifdef VOL_ONLY_SOUND
  1099. #ifdef __PLUS
  1100. if (g_Sound.nDigitized) {
  1101. #endif
  1102. int bits, pv, future;
  1103. if (!serio_sound_enabled) return;
  1105. pv = 0;
  1106. future = 0;
  1107. bits = (data << 1) | 0x200;
  1108. while (bits)
  1109. {
  1110. sampbuf_lastval -= pv;
  1111. pv = (bits & 0x01) * AUDV[3]; /* FIXME!!! - set volume from AUDV */
  1112. sampbuf_lastval += pv;
  1114. sampbuf_val[sampbuf_ptr] = sampbuf_lastval;
  1115. sampbuf_cnt[sampbuf_ptr] =
  1116. (cpu_clock + future-sampbuf_last) * 128 * samp_freq / 178979;
  1117. sampbuf_last = cpu_clock + future;
  1118. sampbuf_ptr++;
  1119. if (sampbuf_ptr >= SAMPBUF_MAX )
  1120. sampbuf_ptr = 0;
  1121. if (sampbuf_ptr == sampbuf_rptr ) {
  1122. sampbuf_rptr++;
  1123. if (sampbuf_rptr >= SAMPBUF_MAX)
  1124. sampbuf_rptr = 0;
  1125. }
  1126. /* 1789790/19200 = 93 */
  1127. future += 93; /* ~ 19200 bit/s - FIXME!!! set speed form AUDF [2] ??? */
  1128. bits >>= 1;
  1129. }
  1130. sampbuf_lastval -= pv;
  1131. #ifdef __PLUS
  1132. }
  1133. #endif
  1134. #endif  /* VOL_ONLY_SOUND */
  1135. }
  1136. #endif /* SERIO_SOUND */
  1138. static void Pokey_process_16(void *sndbuffer, unsigned sndn)
  1139. {
  1140. uint16 *buffer = (uint16 *) sndbuffer;
  1141. int i;
  1143. Pokey_process_8(buffer, sndn);
  1145. for (i = sndn - 1; i >= 0; i--) {
  1146. int smp = ((int) (((uint8 *) buffer)[i]) - 0x80) * 0x100;
  1148. if (smp > 32767)
  1149. smp = 32767;
  1150. else if (smp < -32768)
  1151. smp = -32768;
  1153. buffer[i] = smp;
  1154. }
  1155. }
  1157. #ifdef CONSOLE_SOUND
  1158. static void Update_consol_sound_rf(int set)
  1159. {
  1160. #ifdef VOL_ONLY_SOUND
  1161. static int prev_atari_speaker = 0;
  1162. static unsigned int prev_cpu_clock = 0;
  1163. int d;
  1164. #ifdef __PLUS
  1165. if (!g_Sound.nDigitized)
  1166. return;
  1167. #endif
  1168. if (!console_sound_enabled)
  1169. return;
  1171. if (!set && samp_consol_val == 0)
  1172. return;
  1173. sampbuf_lastval -= samp_consol_val;
  1174. if (prev_atari_speaker != atari_speaker) {
  1175. samp_consol_val = atari_speaker * 8 * 4; /* gain */
  1176. prev_cpu_clock = cpu_clock;
  1177. }
  1178. else if (!set) {
  1179. d = cpu_clock - prev_cpu_clock;
  1180. if (d < 114) {
  1181. sampbuf_lastval += samp_consol_val;
  1182. return;
  1183. }
  1184. while (d >= 114 /* CPUL */) {
  1185. samp_consol_val = samp_consol_val * 99 / 100;
  1186. d -= 114;
  1187. }
  1188. prev_cpu_clock = cpu_clock - d;
  1189. }
  1190. sampbuf_lastval += samp_consol_val;
  1191. prev_atari_speaker = atari_speaker;
  1193. sampbuf_val[sampbuf_ptr] = sampbuf_lastval;
  1194. sampbuf_cnt[sampbuf_ptr] =
  1195. (cpu_clock - sampbuf_last) * 128 * samp_freq / 178979;
  1196. sampbuf_last = cpu_clock;
  1197. sampbuf_ptr++;
  1198. if (sampbuf_ptr >= SAMPBUF_MAX)
  1199. sampbuf_ptr = 0;
  1200. if (sampbuf_ptr == sampbuf_rptr) {
  1201. sampbuf_rptr++;
  1202. if (sampbuf_rptr >= SAMPBUF_MAX)
  1203. sampbuf_rptr = 0;
  1204. }
  1205. #endif  /* VOL_ONLY_SOUND */
  1206. }
  1207. #endif /* CONSOLE_SOUND */
  1209. #ifdef VOL_ONLY_SOUND
  1210. static void Update_vol_only_sound_rf(void)
  1211. {
  1212. #ifdef CONSOLE_SOUND
  1213. Update_consol_sound(0); /* mmm */
  1214. #endif /* CONSOLE_SOUND */
  1215. }
  1216. #endif  /* VOL_ONLY_SOUND */