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

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

Windows CE

开发平台：

C/C++

asap.c：源码内容
  1. /*
  2.  * asap.c - ASAP engine
  3.  *
  4.  * Copyright (C) 2005-2006  Piotr Fusik
  5.  *
  6.  * This file is part of ASAP (Another Slight Atari Player),
  7.  * see http://asap.sourceforge.net
  8.  *
  9.  * ASAP is free software; you can redistribute it and/or modify it
  10.  * under the terms of the GNU General Public License as published
  11.  * by the Free Software Foundation; either version 2 of the License,
  12.  * or (at your option) any later version.
  13.  *
  14.  * ASAP is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty
  16.  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17.  * See the GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with ASAP; if not, write to the Free Software Foundation, Inc.,
  21.  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22.  */
  24. #include "config.h"
  25. #include <stdio.h>
  26. #include <stdlib.h>
  28. #include "asap.h"
  29. #include "asap_internal.h"
  30. #include "cpu.h"
  31. #include "pokey.h"
  32. #include "pokeysnd.h"
  34. #include "players.h"
  36. #define CMR_BASS_TABLE_OFFSET  0x70f
  38. static const unsigned char cmr_bass_table[] = {
  39. 0x5C, 0x56, 0x50, 0x4D, 0x47, 0x44, 0x41, 0x3E,
  40. 0x38, 0x35, 0x88, 0x7F, 0x79, 0x73, 0x6C, 0x67,
  41. 0x60, 0x5A, 0x55, 0x51, 0x4C, 0x48, 0x43, 0x3F,
  42. 0x3D, 0x39, 0x34, 0x33, 0x30, 0x2D, 0x2A, 0x28,
  43. 0x25, 0x24, 0x21, 0x1F, 0x1E
  44. };
  46. /* main clock in Hz, PAL (FREQ_17_EXACT is for NTSC!) */
  47. #define ASAP_MAIN_CLOCK  1773447U
  49. UBYTE memory[65536 + 2];
  51. int xpos = 0;
  52. int xpos_limit = 0;
  53. UBYTE wsync_halt = 0;
  55. /* structures to hold the 9 pokey control bytes */
  56. UBYTE AUDF[4 * MAXPOKEYS]; /* AUDFx (D200, D202, D204, D206) */
  57. UBYTE AUDC[4 * MAXPOKEYS]; /* AUDCx (D201, D203, D205, D207) */
  58. UBYTE AUDCTL[MAXPOKEYS]; /* AUDCTL (D208) */
  59. int Base_mult[MAXPOKEYS]; /* selects either 64Khz or 15Khz clock mult */
  61. UBYTE poly9_lookup[511];
  62. UBYTE poly17_lookup[16385];
  63. static ULONG random_scanline_counter;
  65. static unsigned int enable_stereo = 0;
  67. #ifndef SOUND_GAIN /* sound gain can be pre-defined in the configure/Makefile */
  68. #define SOUND_GAIN 4
  69. #endif
  71. static void POKEY_PutByte(UWORD addr, UBYTE byte)
  72. {
  73. #ifdef STEREO_SOUND
  74. addr &= enable_stereo ? 0x1f : 0x0f;
  75. #else
  76. addr &= 0x0f;
  77. #endif
  78. switch (addr) {
  79. case _AUDC1:
  80. AUDC[CHAN1] = byte;
  81. Update_pokey_sound(_AUDC1, byte, 0, SOUND_GAIN);
  82. break;
  83. case _AUDC2:
  84. AUDC[CHAN2] = byte;
  85. Update_pokey_sound(_AUDC2, byte, 0, SOUND_GAIN);
  86. break;
  87. case _AUDC3:
  88. AUDC[CHAN3] = byte;
  89. Update_pokey_sound(_AUDC3, byte, 0, SOUND_GAIN);
  90. break;
  91. case _AUDC4:
  92. AUDC[CHAN4] = byte;
  93. Update_pokey_sound(_AUDC4, byte, 0, SOUND_GAIN);
  94. break;
  95. case _AUDCTL:
  96. AUDCTL[0] = byte;
  98. /* determine the base multiplier for the 'div by n' calculations */
  99. if (byte & CLOCK_15)
  100. Base_mult[0] = DIV_15;
  101. else
  102. Base_mult[0] = DIV_64;
  104. Update_pokey_sound(_AUDCTL, byte, 0, SOUND_GAIN);
  105. break;
  106. case _AUDF1:
  107. AUDF[CHAN1] = byte;
  108. Update_pokey_sound(_AUDF1, byte, 0, SOUND_GAIN);
  109. break;
  110. case _AUDF2:
  111. AUDF[CHAN2] = byte;
  112. Update_pokey_sound(_AUDF2, byte, 0, SOUND_GAIN);
  113. break;
  114. case _AUDF3:
  115. AUDF[CHAN3] = byte;
  116. Update_pokey_sound(_AUDF3, byte, 0, SOUND_GAIN);
  117. break;
  118. case _AUDF4:
  119. AUDF[CHAN4] = byte;
  120. Update_pokey_sound(_AUDF4, byte, 0, SOUND_GAIN);
  121. break;
  122. case _STIMER:
  123. Update_pokey_sound(_STIMER, byte, 0, SOUND_GAIN);
  124. break;
  125. #ifdef STEREO_SOUND
  126. case _AUDC1 + _POKEY2:
  127. AUDC[CHAN1 + CHIP2] = byte;
  128. Update_pokey_sound(_AUDC1, byte, 1, SOUND_GAIN);
  129. break;
  130. case _AUDC2 + _POKEY2:
  131. AUDC[CHAN2 + CHIP2] = byte;
  132. Update_pokey_sound(_AUDC2, byte, 1, SOUND_GAIN);
  133. break;
  134. case _AUDC3 + _POKEY2:
  135. AUDC[CHAN3 + CHIP2] = byte;
  136. Update_pokey_sound(_AUDC3, byte, 1, SOUND_GAIN);
  137. break;
  138. case _AUDC4 + _POKEY2:
  139. AUDC[CHAN4 + CHIP2] = byte;
  140. Update_pokey_sound(_AUDC4, byte, 1, SOUND_GAIN);
  141. break;
  142. case _AUDCTL + _POKEY2:
  143. AUDCTL[1] = byte;
  144. /* determine the base multiplier for the 'div by n' calculations */
  145. if (byte & CLOCK_15)
  146. Base_mult[1] = DIV_15;
  147. else
  148. Base_mult[1] = DIV_64;
  150. Update_pokey_sound(_AUDCTL, byte, 1, SOUND_GAIN);
  151. break;
  152. case _AUDF1 + _POKEY2:
  153. AUDF[CHAN1 + CHIP2] = byte;
  154. Update_pokey_sound(_AUDF1, byte, 1, SOUND_GAIN);
  155. break;
  156. case _AUDF2 + _POKEY2:
  157. AUDF[CHAN2 + CHIP2] = byte;
  158. Update_pokey_sound(_AUDF2, byte, 1, SOUND_GAIN);
  159. break;
  160. case _AUDF3 + _POKEY2:
  161. AUDF[CHAN3 + CHIP2] = byte;
  162. Update_pokey_sound(_AUDF3, byte, 1, SOUND_GAIN);
  163. break;
  164. case _AUDF4 + _POKEY2:
  165. AUDF[CHAN4 + CHIP2] = byte;
  166. Update_pokey_sound(_AUDF4, byte, 1, SOUND_GAIN);
  167. break;
  168. case _STIMER + _POKEY2:
  169. Update_pokey_sound(_STIMER, byte, 1, SOUND_GAIN);
  170. break;
  171. #endif
  172. default:
  173. break;
  174. }
  175. }
  177. static void POKEY_Initialise(void)
  178. {
  179. int i;
  180. ULONG reg;
  182. for (i = 0; i < (MAXPOKEYS * 4); i++) {
  183. AUDC[i] = 0;
  184. AUDF[i] = 0;
  185. }
  187. for (i = 0; i < MAXPOKEYS; i++) {
  188. AUDCTL[i] = 0;
  189. Base_mult[i] = DIV_64;
  190. }
  192. /* initialise poly9_lookup */
  193. reg = 0x1ff;
  194. for (i = 0; i < 511; i++) {
  195. reg = ((((reg >> 5) ^ reg) & 1) << 8) + (reg >> 1);
  196. poly9_lookup[i] = (UBYTE) reg;
  197. }
  198. /* initialise poly17_lookup */
  199. reg = 0x1ffff;
  200. for (i = 0; i < 16385; i++) {
  201. reg = ((((reg >> 5) ^ reg) & 0xff) << 9) + (reg >> 8);
  202. poly17_lookup[i] = (UBYTE) (reg >> 1);
  203. }
  205. random_scanline_counter = 0;
  206. }
  208. UBYTE ASAP_GetByte(UWORD addr)
  209. {
  210. unsigned int i;
  211. switch (addr & 0xff0f) {
  212. case 0xd20a:
  213. i = random_scanline_counter + (unsigned int) xpos + (unsigned int) xpos / LINE_C * DMAR;
  214. if (AUDCTL[0] & POLY9)
  215. return poly9_lookup[i % POLY9_SIZE];
  216. else {
  217. const UBYTE *ptr;
  218. i %= POLY17_SIZE;
  219. ptr = poly17_lookup + (i >> 3);
  220. i &= 7;
  221. return (UBYTE) ((ptr[0] >> i) + (ptr[1] << (8 - i)));
  222. }
  223. case 0xd40b:
  224. return (UBYTE) ((unsigned int) xpos / (unsigned int) (2 * (LINE_C - DMAR)) % 156U);
  225. default:
  226. return dGetByte(addr);
  227. }
  228. }
  230. void ASAP_PutByte(UWORD addr, UBYTE byte)
  231. {
  232. /* TODO: implement WSYNC */
  233. #if 0
  234. if ((addr >> 8) == 0xd2)
  235. POKEY_PutByte(addr, byte);
  236. else if ((addr & 0xff0f) == 0xd40a) {
  237. if (xpos <= WSYNC_C && xpos_limit >= WSYNC_C)
  238. xpos = WSYNC_C;
  239. else {
  240. wsync_halt = TRUE;
  241. xpos = xpos_limit;
  242. }
  243. }
  244. else
  245. dPutByte(addr, byte);
  246. #else
  247. POKEY_PutByte(addr, byte);
  248. #endif
  249. }
  251. /* We use CIM opcode to return from a subroutine to ASAP */
  252. void ASAP_CIM(void)
  253. {
  254. xpos = xpos_limit;
  255. }
  257. static unsigned int block_rate;
  258. static unsigned int sample_format;
  259. static unsigned int sample_16bit;
  261. void ASAP_Initialize(unsigned int frequency, unsigned int audio_format, unsigned int quality)
  262. {
  263. block_rate = frequency;
  264. sample_format = audio_format;
  265. sample_16bit = audio_format == AUDIO_FORMAT_U8 ? 0 : 1;
  266. enable_stereo = 5; /* force Pokey_sound_init() in ASAP_PlaySong() */
  267. POKEY_Initialise();
  268. if (quality == 0)
  269. enable_new_pokey = FALSE;
  270. else {
  271. Pokey_set_mzquality(quality - 1);
  272. enable_new_pokey = TRUE;
  273. }
  274. }
  276. static char sap_type;
  277. static UWORD sap_player;
  278. static UWORD sap_music;
  279. static UWORD sap_init;
  280. static unsigned int sap_stereo;
  281. static unsigned int sap_songs;
  282. static unsigned int sap_defsong;
  283. static unsigned int sap_fastplay;
  285. /* This array maps subsong numbers to track positions for MPT and RMT formats. */
  286. static UBYTE song_pos[128];
  288. static unsigned int tmc_per_frame;
  289. static unsigned int tmc_per_frame_counter;
  291. static unsigned int blockclocks;
  292. static unsigned int blockclocks_per_player;
  294. static const unsigned int perframe2fastplay[] = { 312U, 312U / 2U, 312U / 3U, 312U / 4U };
  296. static int load_native(const unsigned char *module, unsigned int module_len,
  297.                        const unsigned char *player, char type)
  298. {
  299. UWORD player_last_byte;
  300. int block_len;
  301. if (module[0] != 0xff || module[1] != 0xff)
  302. return FALSE;
  303. sap_player = player[2] + (player[3] << 8);
  304. player_last_byte = player[4] + (player[5] << 8);
  305. sap_music = module[2] + (module[3] << 8);
  306. if (sap_music <= player_last_byte)
  307. return FALSE;
  308. block_len = module[4] + (module[5] << 8) + 1 - sap_music;
  309. if ((unsigned int) (6 + block_len) != module_len) {
  310. UWORD info_addr;
  311. int info_len;
  312. if (type != 'r' || (unsigned int) (11 + block_len) > module_len)
  313. return FALSE;
  314. /* allow optional info for Raster Music Tracker */
  315. info_addr = module[6 + block_len] + (module[7 + block_len] << 8);
  316. if (info_addr != sap_music + block_len)
  317. return FALSE;
  318. info_len = module[8 + block_len] + (module[9 + block_len] << 8) + 1 - info_addr;
  319. if ((unsigned int) (10 + block_len + info_len) != module_len)
  320. return FALSE;
  321. }
  322. memcpy(memory + sap_music, module + 6, block_len);
  323. memcpy(memory + sap_player, player + 6, player_last_byte + 1 - sap_player);
  324. sap_type = type;
  325. return TRUE;
  326. }
  328. static int load_cmc(const unsigned char *module, unsigned int module_len, int cmr)
  329. {
  330. int pos;
  331. if (module_len < 0x300)
  332. return FALSE;
  333. if (!load_native(module, module_len, cmc_obx, 'C'))
  334. return FALSE;
  335. if (cmr)
  336. memcpy(memory + 0x500 + CMR_BASS_TABLE_OFFSET, cmr_bass_table, sizeof(cmr_bass_table));
  337. /* auto-detect number of subsongs */
  338. pos = 0x54;
  339. while (--pos >= 0) {
  340. if (module[0x206 + pos] < 0xfe
  341.  || module[0x25b + pos] < 0xfe
  342.  || module[0x2b0 + pos] < 0xfe)
  343. break;
  344. }
  345. while (--pos >= 0) {
  346. if (module[0x206 + pos] == 0x8f || module[0x206 + pos] == 0xef)
  347. sap_songs++;
  348. }
  349. return TRUE;
  350. }
  352. static int load_mpt(const unsigned char *module, unsigned int module_len)
  353. {
  354. unsigned int i;
  355. unsigned int song_len;
  356. /* seen[i] == TRUE if the track position i is already processed */
  357. UBYTE seen[256];
  358. if (module_len < 0x1d0)
  359. return FALSE;
  360. if (!load_native(module, module_len, mpt_obx, 'm'))
  361. return FALSE;
  362. /* do not auto-detect number of subsongs if the address
  363.    of the first track is non-standard */
  364. if (module[0x1c6] + (module[0x1ca] << 8) != sap_music + 0x1ca) {
  365. song_pos[0] = 0;
  366. return TRUE;
  367. }
  368. /* Calculate the length of the first track. Address of the second track minus
  369.    address of the first track equals the length of the first track in bytes.
  370.    Divide by two to get number of track positions. */
  371. song_len = (module[0x1c7] + (module[0x1cb] << 8) - sap_music - 0x1ca) >> 1;
  372. if (song_len > 0xfe)
  373. return FALSE;
  374. memset(seen, FALSE, sizeof(seen));
  375. sap_songs = 0;
  376. for (i = 0; i < song_len; i++) {
  377. unsigned int j;
  378. UBYTE c;
  379. if (seen[i])
  380. continue;
  381. j = i;
  382. /* follow jump commands until a pattern or a stop command is found */
  383. do {
  384. seen[j] = TRUE;
  385. c = module[0x1d0 + j * 2];
  386. if (c != 0xff)
  387. break;
  388. j = module[0x1d1 + j * 2];
  389. } while (j < song_len && !seen[j]);
  390. /* if no pattern found then this is not a subsong */
  391. if (c >= 64)
  392. continue;
  393. /* found subsong */
  394. song_pos[sap_songs++] = (UBYTE) j;
  395. j++;
  396. /* follow this subsong */
  397. while (j < song_len && !seen[j]) {
  398. seen[j] = TRUE;
  399. c = module[0x1d0 + j * 2];
  400. if (c < 64)
  401. j++;
  402. else if (c == 0xff)
  403. j = module[0x1d1 + j * 2];
  404. else
  405. break;
  406. }
  407. }
  408. return sap_songs != 0;
  409. }
  411. static int load_rmt(const unsigned char *module, unsigned int module_len)
  412. {
  413. unsigned int i;
  414. UWORD song_start;
  415. UWORD song_last_byte;
  416. const unsigned char *song;
  417. unsigned int song_len;
  418. UBYTE seen[256];
  419. if (module_len < 0x30 || module[6] != 'R' || module[7] != 'M'
  420.  || module[8] != 'T' || module[13] != 1)
  421. return FALSE;
  422. switch (module[9]) {
  423. case '4':
  424. break;
  425. case '8':
  426. sap_stereo = 1;
  427. break;
  428. default:
  429. return FALSE;
  430. }
  431. i = module[12];
  432. if (i < 1 || i > 4)
  433. return FALSE;
  434. sap_fastplay = perframe2fastplay[i - 1];
  435. if (!load_native(module, module_len, sap_stereo ? rmt8_obx : rmt4_obx, 'r'))
  436. return FALSE;
  437. sap_player = 0x600;
  438. /* auto-detect number of subsongs */
  439. song_start = module[20] + (module[21] << 8);
  440. song_last_byte = module[4] + (module[5] << 8);
  441. if (song_start <= sap_music || song_start >= song_last_byte)
  442. return FALSE;
  443. song = module + 6 + song_start - sap_music;
  444. song_len = (song_last_byte + 1 - song_start) >> (2 + sap_stereo);
  445. if (song_len > 0xfe)
  446. song_len = 0xfe;
  447. memset(seen, FALSE, sizeof(seen));
  448. sap_songs = 0;
  449. for (i = 0; i < song_len; i++) {
  450. unsigned int j;
  451. if (seen[i])
  452. continue;
  453. j = i;
  454. do {
  455. seen[j] = TRUE;
  456. if (song[j << (2 + sap_stereo)] != 0xfe)
  457. break;
  458. j = song[(j << (2 + sap_stereo)) + 1];
  459. } while (j < song_len && !seen[j]);
  460. song_pos[sap_songs++] = (UBYTE) j;
  461. j++;
  462. while (j < song_len && !seen[j]) {
  463. seen[j] = TRUE;
  464. if (song[j << (2 + sap_stereo)] != 0xfe)
  465. j++;
  466. else
  467. j = song[(j << (2 + sap_stereo)) + 1];
  468. }
  469. }
  470. return sap_songs != 0;
  471. }
  473. static int load_tmc(const unsigned char *module, unsigned int module_len)
  474. {
  475. unsigned int i;
  476. if (module_len < 0x1d0)
  477. return FALSE;
  478. if (!load_native(module, module_len, tmc_obx, 't'))
  479. return FALSE;
  480. tmc_per_frame = module[37];
  481. if (tmc_per_frame < 1 || tmc_per_frame > 4)
  482. return FALSE;
  483. sap_fastplay = perframe2fastplay[tmc_per_frame - 1];
  484. i = 0;
  485. /* find first instrument */
  486. while (module[0x66 + i] == 0) {
  487. if (++i >= 64)
  488. return FALSE; /* no instrument */
  489. }
  490. i = (module[0x66 + i] << 8) + module[0x26 + i] - sap_music - 1 + 6;
  491. if (i >= module_len)
  492. return FALSE;
  493. /* skip trailing jumps */
  494. do {
  495. if (i <= 0x1b5)
  496. return FALSE; /* no pattern to play */
  497. i -= 16;
  498. } while (module[i] >= 0x80);
  499. while (i >= 0x1b5) {
  500. if (module[i] >= 0x80)
  501. sap_songs++;
  502. i -= 16;
  503. }
  504. return TRUE;
  505. }
  507. static int load_tm2(const unsigned char *module, unsigned int module_len)
  508. {
  509. unsigned int i;
  510. unsigned int song_end;
  511. unsigned char c;
  512. if (module_len < 0x3a4)
  513. return FALSE;
  514. i = module[0x25];
  515. if (i < 1 || i > 4)
  516. return FALSE;
  517. sap_fastplay = perframe2fastplay[i - 1];
  518. if (!load_native(module, module_len, tm2_obx, 'T'))
  519. return FALSE;
  520. /* TODO: quadrophonic */
  521. if (module[0x1f] != 0)
  522. #ifdef STEREO_SOUND
  523. sap_stereo = 1;
  524. #else
  525. return FALSE;
  526. #endif
  527. sap_player = 0x500;
  528. song_end = 0xffff;
  529. for (i = 0; i < 0x80; i++) {
  530. unsigned int instr_addr = module[0x86 + i] + (module[0x306 + i] << 8);
  531. if (instr_addr != 0 && instr_addr < song_end)
  532. song_end = instr_addr;
  533. }
  534. for (i = 0; i < 0x100; i++) {
  535. unsigned int pattern_addr = module[0x106 + i] + (module[0x206 + i] << 8);
  536. if (pattern_addr != 0 && pattern_addr < song_end)
  537. song_end = pattern_addr;
  538. }
  539. if (song_end < sap_music + 0x380U + 2U * 17U)
  540. return FALSE;
  541. i = song_end - sap_music - 0x380;
  542. if (0x386 + i >= module_len)
  543. return FALSE;
  544. i -= i % 17;
  545. /* skip trailing stop/jump commands */
  546. do {
  547. if (i == 0)
  548. return FALSE;
  549. i -= 17;
  550. c = module[0x386 + 16 + i];
  551. } while (c == 0 || c >= 0x80);
  552. /* count stop/jump commands */
  553. while (i > 0) {
  554. i -= 17;
  555. c = module[0x386 + 16 + i];
  556. if (c == 0 || c >= 0x80)
  557. sap_songs++;
  558. }
  559. return TRUE;
  560. }
  562. static int tag_matches(const char *tag, const UBYTE *sap_ptr, const UBYTE *sap_end)
  563. {
  564. size_t len = strlen(tag);
  565. return (sap_ptr + len + 8 < sap_end) && memcmp(tag, sap_ptr, len) == 0;
  566. }
  568. static int parse_hex(const UBYTE **ps, UWORD *retval)
  569. {
  570. int chars = 0;
  571. *retval = 0;
  572. while (**ps != 0x0d) {
  573. char c;
  574. if (++chars > 4)
  575. return FALSE;
  576. c = (char) *(*ps)++;
  577. *retval <<= 4;
  578. if (c >= '0' && c <= '9')
  579. *retval += c - '0';
  580. else if (c >= 'A' && c <= 'F')
  581. *retval += c - 'A' + 10;
  582. else if (c >= 'a' && c <= 'f')
  583. *retval += c - 'a' + 10;
  584. else
  585. return FALSE;
  586. }
  587. return chars != 0;
  588. }
  590. static int parse_dec(const UBYTE **ps, unsigned int *retval)
  591. {
  592. int chars = 0;
  593. *retval = 0;
  594. while (**ps != 0x0d) {
  595. char c;
  596. if (++chars > 3)
  597. return FALSE;
  598. c = (char) *(*ps)++;
  599. *retval *= 10;
  600. if (c >= '0' && c <= '9')
  601. *retval += c - '0';
  602. else
  603. return FALSE;
  604. }
  605. return chars != 0;
  606. }
  608. static int load_sap(const UBYTE *sap_ptr, const UBYTE * const sap_end)
  609. {
  610. if (!tag_matches("SAP", sap_ptr, sap_end))
  611. return FALSE;
  612. sap_type = '?';
  613. sap_player = 0xffff;
  614. sap_music = 0xffff;
  615. sap_init = 0xffff;
  616. sap_ptr += 3;
  617. for (;;) {
  618. if (sap_ptr + 8 >= sap_end || sap_ptr[0] != 0x0d || sap_ptr[1] != 0x0a)
  619. return FALSE;
  620. sap_ptr += 2;
  621. if (sap_ptr[0] == 0xff)
  622. break;
  623. if (tag_matches("TYPE ", sap_ptr, sap_end)) {
  624. sap_ptr += 5;
  625. sap_type = *sap_ptr++;
  626. }
  627. else if (tag_matches("PLAYER ", sap_ptr, sap_end)) {
  628. sap_ptr += 7;
  629. if (!parse_hex(&sap_ptr, &sap_player))
  630. return FALSE;
  631. }
  632. else if (tag_matches("MUSIC ", sap_ptr, sap_end)) {
  633. sap_ptr += 6;
  634. if (!parse_hex(&sap_ptr, &sap_music))
  635. return FALSE;
  636. }
  637. else if (tag_matches("INIT ", sap_ptr, sap_end)) {
  638. sap_ptr += 5;
  639. if (!parse_hex(&sap_ptr, &sap_init))
  640. return FALSE;
  641. }
  642. else if (tag_matches("SONGS ", sap_ptr, sap_end)) {
  643. sap_ptr += 6;
  644. if (!parse_dec(&sap_ptr, &sap_songs) || sap_songs < 1 || sap_songs > 255)
  645. return FALSE;
  646. }
  647. else if (tag_matches("DEFSONG ", sap_ptr, sap_end)) {
  648. sap_ptr += 8;
  649. if (!parse_dec(&sap_ptr, &sap_defsong))
  650. return FALSE;
  651. }
  652. else if (tag_matches("FASTPLAY ", sap_ptr, sap_end)) {
  653. sap_ptr += 9;
  654. if (!parse_dec(&sap_ptr, &sap_fastplay) || sap_fastplay < 1 || sap_fastplay > 312)
  655. return FALSE;
  656. }
  657. else if (tag_matches("STEREO", sap_ptr, sap_end))
  658. #ifdef STEREO_SOUND
  659. sap_stereo = 1;
  660. #else
  661. return FALSE;
  662. #endif
  663. /* ignore unknown tags */
  664. while (sap_ptr[0] != 0x0d) {
  665. sap_ptr++;
  666. if (sap_ptr >= sap_end)
  667. return FALSE;
  668. }
  669. }
  670. if (sap_defsong >= sap_songs)
  671. return FALSE;
  672. switch (sap_type) {
  673. case 'B':
  674. if (sap_player == 0xffff || sap_init == 0xffff)
  675. return FALSE;
  676. break;
  677. case 'C':
  678. if (sap_player == 0xffff || sap_music == 0xffff)
  679. return FALSE;
  680. break;
  681. default:
  682. return FALSE;
  683. }
  684. if (sap_ptr[1] != 0xff)
  685. return FALSE;
  686. memset(memory, 0, sizeof(memory));
  687. sap_ptr += 2;
  688. while (sap_ptr + 5 <= sap_end) {
  689. int start_addr = sap_ptr[0] + (sap_ptr[1] << 8);
  690. int block_len = sap_ptr[2] + (sap_ptr[3] << 8) + 1 - start_addr;
  691. if (block_len <= 0 || sap_ptr + block_len > sap_end)
  692. return FALSE;
  693. sap_ptr += 4;
  694. memcpy(memory + start_addr, sap_ptr, block_len);
  695. sap_ptr += block_len;
  696. if (sap_ptr == sap_end)
  697. return TRUE;
  698. if (sap_ptr + 7 <= sap_end && sap_ptr[0] == 0xff && sap_ptr[1] == 0xff)
  699. sap_ptr += 2;
  700. }
  701. return FALSE;
  702. }
  704. #define EXT(c1, c2, c3) ((c1 + (c2 << 8) + (c3 << 16)) | 0x202020)
  706. int ASAP_Load(const char *filename, const unsigned char *module, unsigned int module_len)
  707. {
  708. const char *p;
  709. int ext;
  710. for (p = filename; *p != ''; p++);
  711. ext = 0;
  712. for (;;) {
  713. if (--p <= filename || *p < ' ')
  714. return FALSE; /* no filename extension or invalid character */
  715. if (*p == '.')
  716. break;
  717. ext = (ext << 8) + (*p & 0xff);
  718. }
  719. sap_stereo = 0;
  720. sap_songs = 1;
  721. sap_defsong = 0;
  722. sap_fastplay = 312;
  723. switch (ext | 0x202020) {
  724. case EXT('C', 'M', 'C'):
  725. return load_cmc(module, module_len, FALSE);
  726. case EXT('C', 'M', 'R'):
  727. return load_cmc(module, module_len, TRUE);
  728. case EXT('D', 'M', 'C'):
  729. sap_fastplay = 156;
  730. return load_cmc(module, module_len, FALSE);
  731. case EXT('M', 'P', 'D'):
  732. sap_fastplay = 156;
  733. return load_mpt(module, module_len);
  734. case EXT('M', 'P', 'T'):
  735. return load_mpt(module, module_len);
  736. case EXT('R', 'M', 'T'):
  737. return load_rmt(module, module_len);
  738. case EXT('S', 'A', 'P'):
  739. return load_sap(module, module + module_len);
  740. case EXT('T', 'M', '2'):
  741. return load_tm2(module, module_len);
  742. #ifdef STEREO_SOUND
  743. case EXT('T', 'M', '8'):
  744. sap_stereo = 1;
  745. return load_tmc(module, module_len);
  746. #endif
  747. case EXT('T', 'M', 'C'):
  748. return load_tmc(module, module_len);
  749. default:
  750. return FALSE;
  751. }
  752. }
  754. unsigned int ASAP_GetChannels(void)
  755. {
  756. return 1 << sap_stereo;
  757. }
  759. unsigned int ASAP_GetSongs(void)
  760. {
  761. return sap_songs;
  762. }
  764. unsigned int ASAP_GetDefSong(void)
  765. {
  766. return sap_defsong;
  767. }
  769. static void call_6502(UWORD addr, int max_scanlines)
  770. {
  771. regPC = addr;
  772. /* put a CIM at 0xd20a and a return address on stack */
  773. dPutByte(0xd20a, 0xd2);
  774. dPutByte(0x01fe, 0x09);
  775. dPutByte(0x01ff, 0xd2);
  776. regS = 0xfd;
  777. xpos = 0;
  778. GO(max_scanlines * (LINE_C - DMAR));
  779. }
  781. /* 50 Atari frames for the initialization routine - some SAPs are self-extracting. */
  782. #define SCANLINES_FOR_INIT  (50 * 312)
  784. void ASAP_PlaySong(unsigned int song)
  785. {
  786. UWORD addr;
  787. if (enable_stereo != sap_stereo) {
  788. Pokey_sound_init(ASAP_MAIN_CLOCK, (uint16) block_rate,
  789. 1 << sap_stereo, sample_16bit ? SND_BIT16 : 0);
  790. enable_stereo = sap_stereo;
  791. }
  792. for (addr = _AUDF1; addr <= _STIMER; addr++)
  793. POKEY_PutByte(addr, 0);
  794. if (sap_stereo)
  795. for (addr = _AUDF1 + _POKEY2; addr <= _STIMER + _POKEY2; addr++)
  796. POKEY_PutByte(addr, 0);
  797. blockclocks = 0;
  798. blockclocks_per_player = 114U * sap_fastplay * block_rate;
  799. regP = 0x30;
  800. switch (sap_type) {
  801. case 'B':
  802. regA = (UBYTE) song;
  803. regX = 0x00;
  804. regY = 0x00;
  805. /* 5 frames should be enough */
  806. call_6502(sap_init, SCANLINES_FOR_INIT);
  807. break;
  808. case 'C':
  809. regA = 0x70;
  810. regX = (UBYTE) sap_music;
  811. regY = (UBYTE) (sap_music >> 8);
  812. call_6502((UWORD) (sap_player + 3), SCANLINES_FOR_INIT);
  813. regA = 0x00;
  814. regX = (UBYTE) song;
  815. call_6502((UWORD) (sap_player + 3), SCANLINES_FOR_INIT);
  816. break;
  817. case 'm':
  818. regA = 0x00;
  819. regX = (UBYTE) (sap_music >> 8);
  820. regY = (UBYTE) sap_music;
  821. call_6502(sap_player, SCANLINES_FOR_INIT);
  822. regA = 0x02;
  823. regX = song_pos[song];
  824. call_6502(sap_player, SCANLINES_FOR_INIT);
  825. break;
  826. case 'r':
  827. regA = song_pos[song];
  828. regX = (UBYTE) sap_music;
  829. regY = (UBYTE) (sap_music >> 8);
  830. call_6502(sap_player, SCANLINES_FOR_INIT);
  831. break;
  832. case 't':
  833. case 'T':
  834. regA = 0x70;
  835. regX = (UBYTE) (sap_music >> 8);
  836. regY = (UBYTE) sap_music;
  837. call_6502(sap_player, SCANLINES_FOR_INIT);
  838. regA = 0x00;
  839. regX = (UBYTE) song;
  840. call_6502(sap_player, SCANLINES_FOR_INIT);
  841. tmc_per_frame_counter = 1;
  842. break;
  843. }
  844. }
  846. void ASAP_Generate(void *buffer, unsigned int buffer_len)
  847. {
  848. /* convert number of bytes to number of blocks */
  849. buffer_len >>= sample_16bit + enable_stereo;
  850. if (buffer_len == 0U)
  851. return;
  852. for (;;) {
  853. unsigned int blocks = blockclocks / ASAP_MAIN_CLOCK;
  854. if (blocks != 0U) {
  855. unsigned int samples;
  856. if (blocks > buffer_len)
  857. blocks = buffer_len;
  858. buffer_len -= blocks;
  859. samples = blocks << enable_stereo;
  860. blockclocks -= blocks * ASAP_MAIN_CLOCK;
  861. Pokey_process(buffer, samples);
  862. /* swap bytes in non-native words if necessary */
  863. if (sample_format ==
  864. #ifdef WORDS_BIGENDIAN
  865. AUDIO_FORMAT_S16_LE
  866. #else
  867. AUDIO_FORMAT_S16_BE
  868. #endif
  869. ) {
  870. unsigned char *p = (unsigned char *) buffer;
  871. unsigned int n = samples;
  872. do {
  873. unsigned char t = p[0];
  874. p[0] = p[1];
  875. p[1] = t;
  876. p += 2;
  877. } while (--n != 0U);
  878. }
  879. if (buffer_len == 0U)
  880. return;
  881. buffer = (void *) ((unsigned char *) buffer +
  882. (samples << sample_16bit));
  883. }
  884. switch (sap_type) {
  885. case 'B':
  886. call_6502(sap_player, sap_fastplay);
  887. break;
  888. case 'C':
  889. call_6502((UWORD) (sap_player + 6), sap_fastplay);
  890. break;
  891. case 'm':
  892. case 'r':
  893. case 'T':
  894. call_6502((UWORD) (sap_player + 3), sap_fastplay);
  895. break;
  896. case 't':
  897. if (--tmc_per_frame_counter <= 0) {
  898. tmc_per_frame_counter = tmc_per_frame;
  899. call_6502((UWORD) (sap_player + 3), sap_fastplay);
  900. }
  901. else
  902. call_6502((UWORD) (sap_player + 6), sap_fastplay);
  903. break;
  904. }
  905. random_scanline_counter = (random_scanline_counter + LINE_C * sap_fastplay)
  906.                           % ((AUDCTL[0] & POLY9) ? POLY9_SIZE : POLY17_SIZE);
  907. blockclocks += blockclocks_per_player;
  908. }
  909. }