Index: apps/plugins/asap/SOURCES =================================================================== --- apps/plugins/asap/SOURCES (revision 0) +++ apps/plugins/asap/SOURCES (revision 0) @@ -0,0 +1,4 @@ +acpu.c +apokeysnd.c +asap.c +asap2wav.c \ No newline at end of file Index: apps/plugins/asap/asap.c =================================================================== --- apps/plugins/asap/asap.c (revision 0) +++ apps/plugins/asap/asap.c (revision 0) @@ -0,0 +1,2000 @@ +/* + * asap.c - ASAP engine + * + * Copyright (C) 2005-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#if !defined(JAVA) && !defined(CSHARP) +#include +#endif + +#include "asap_internal.h" +#if !defined(JAVA) && !defined(CSHARP) +#include "players.h" +#endif + +#define CMR_BASS_TABLE_OFFSET 0x70f + +CONST_LOOKUP(byte, cmr_bass_table) = { + 0x5C, 0x56, 0x50, 0x4D, 0x47, 0x44, 0x41, 0x3E, + 0x38, 0x35, (byte) 0x88, 0x7F, 0x79, 0x73, 0x6C, 0x67, + 0x60, 0x5A, 0x55, 0x51, 0x4C, 0x48, 0x43, 0x3F, + 0x3D, 0x39, 0x34, 0x33, 0x30, 0x2D, 0x2A, 0x28, + 0x25, 0x24, 0x21, 0x1F, 0x1E +}; + +ASAP_FUNC int ASAP_GetByte(ASAP_State PTR ast, int addr) +{ + switch (addr & 0xff0f) { + case 0xd20a: + return PokeySound_GetRandom(ast, addr); + case 0xd20e: + if ((addr & AST extra_pokey_mask) != 0) + return 0xff; + return AST irqst; + case 0xd20f: + return 0xff; + case 0xd40b: + return AST scanline_number >> 1; + default: + return dGetByte(addr); + } +} + +ASAP_FUNC void ASAP_PutByte(ASAP_State PTR ast, int addr, int data) +{ + if ((addr >> 8) == 0xd2) { + if ((addr & (AST extra_pokey_mask + 0xf)) == 0xe) { + AST irqst |= data ^ 0xff; +#define SET_TIMER_IRQ(ch) \ + if ((data & AST irqst & ch) != 0) { \ + if (AST timer##ch##_cycle == NEVER) { \ + int t = AST base_pokey.tick_cycle##ch; \ + while (t < AST cycle) \ + t += AST base_pokey.period_cycles##ch; \ + AST timer##ch##_cycle = t; \ + if (AST nearest_event_cycle > t) \ + AST nearest_event_cycle = t; \ + } \ + } \ + else \ + AST timer##ch##_cycle = NEVER; + SET_TIMER_IRQ(1); + SET_TIMER_IRQ(2); + SET_TIMER_IRQ(4); + } + else + PokeySound_PutByte(ast, addr, data); + } + else if ((addr & 0xff0f) == 0xd40a) { + if (AST cycle <= AST next_scanline_cycle - 8) + AST cycle = AST next_scanline_cycle - 8; + else + AST cycle = AST next_scanline_cycle + 106; + } + else + dPutByte(addr, data); +} + +#define MAX_SONGS 32 + +CONST_LOOKUP(int, perframe2fastplay) = { 312, 312 / 2, 312 / 3, 312 / 4 }; + +FILE_FUNC abool load_native(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len, ASAP_OBX player) +{ +#if defined(JAVA) || defined(CSHARP) + try +#endif + { + int player_last_byte; + int block_len; + if (UBYTE(module[0]) != 0xff || UBYTE(module[1]) != 0xff) + return FALSE; +#ifdef JAVA + try { + player.read(); + player.read(); + MODULE_INFO player = player.read(); + MODULE_INFO player += player.read() << 8; + player_last_byte = player.read(); + player_last_byte += player.read() << 8; + } catch (IOException e) { + throw new RuntimeException(); + } +#elif defined(CSHARP) + player.ReadByte(); + player.ReadByte(); + MODULE_INFO player = player.ReadByte(); + MODULE_INFO player += player.ReadByte() << 8; + player_last_byte = player.ReadByte(); + player_last_byte += player.ReadByte() << 8; +#else + MODULE_INFO player = UBYTE(player[2]) + (UBYTE(player[3]) << 8); + player_last_byte = UBYTE(player[4]) + (UBYTE(player[5]) << 8); +#endif + MODULE_INFO music = UBYTE(module[2]) + (UBYTE(module[3]) << 8); + if (MODULE_INFO music <= player_last_byte) + return FALSE; + block_len = UBYTE(module[4]) + (UBYTE(module[5]) << 8) + 1 - MODULE_INFO music; + if (6 + block_len != module_len) { + int info_addr; + int info_len; + if (MODULE_INFO type != 'r' || 11 + block_len > module_len) + return FALSE; + /* allow optional info for Raster Music Tracker */ + info_addr = UBYTE(module[6 + block_len]) + (UBYTE(module[7 + block_len]) << 8); + if (info_addr != MODULE_INFO music + block_len) + return FALSE; + info_len = UBYTE(module[8 + block_len]) + (UBYTE(module[9 + block_len]) << 8) + 1 - info_addr; + if (10 + block_len + info_len != module_len) + return FALSE; + } + if (ast != NULL) { + COPY_ARRAY(AST memory, MODULE_INFO music, module, 6, block_len); +#ifdef JAVA + int addr = MODULE_INFO player; + do { + int i; + try { + i = player.read(AST memory, addr, player_last_byte + 1 - addr); + } catch (IOException e) { + throw new RuntimeException(); + } + if (i <= 0) + throw new RuntimeException(); + addr += i; + } while (addr <= player_last_byte); +#elif defined(CSHARP) + int addr = MODULE_INFO player; + do { + int i = player.Read(AST memory, addr, player_last_byte + 1 - addr); + if (i <= 0) + throw new Exception(); + addr += i; + } while (addr <= player_last_byte); +#else + COPY_ARRAY(AST memory, MODULE_INFO player, player, 6, player_last_byte + 1 - MODULE_INFO player); +#endif + } + return TRUE; + } +#ifdef JAVA + finally { + try { + player.close(); + } catch (IOException e) { + throw new RuntimeException(); + } + } +#elif defined(CSHARP) + finally { + player.Close(); + } +#endif +} + +FILE_FUNC void set_song_duration(ASAP_ModuleInfo PTR module_info, int player_calls) +{ + MODULE_INFO durations[MODULE_INFO songs] = (int) (player_calls * MODULE_INFO fastplay * 114000.0 / 1773447); + MODULE_INFO songs++; +} + +#define SEEN_THIS_CALL 1 +#define SEEN_BEFORE 2 +#define SEEN_REPEAT 3 + +FILE_FUNC void parse_cmc_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, int pos) +{ + int tempo = UBYTE(module[0x19]); + int player_calls = 0; + int rep_start_pos = 0; + int rep_end_pos = 0; + int rep_times = 0; + NEW_ARRAY(byte, seen, 0x55); + INIT_ARRAY(seen); + while (pos >= 0 && pos < 0x55) { + int p1; + int p2; + int p3; + if (pos == rep_end_pos && rep_times > 0) { + for (p1 = 0; p1 < 0x55; p1++) + if (seen[p1] == SEEN_THIS_CALL || seen[p1] == SEEN_REPEAT) + seen[p1] = 0; + rep_times--; + pos = rep_start_pos; + } + if (seen[pos] != 0) { + if (seen[pos] != SEEN_THIS_CALL) + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + seen[pos] = SEEN_THIS_CALL; + p1 = UBYTE(module[0x206 + pos]); + p2 = UBYTE(module[0x25b + pos]); + p3 = UBYTE(module[0x2b0 + pos]); + if (p1 == 0xfe || p2 == 0xfe || p3 == 0xfe) { + pos++; + continue; + } + p1 >>= 4; + if (p1 == 8) + break; + if (p1 == 9) { + pos = p2; + continue; + } + if (p1 == 0xa) { + pos -= p2; + continue; + } + if (p1 == 0xb) { + pos += p2; + continue; + } + if (p1 == 0xc) { + tempo = p2; + pos++; + continue; + } + if (p1 == 0xd) { + pos++; + rep_start_pos = pos; + rep_end_pos = pos + p2; + rep_times = p3 - 1; + continue; + } + if (p1 == 0xe) { + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + p2 = rep_times > 0 ? SEEN_REPEAT : SEEN_BEFORE; + for (p1 = 0; p1 < 0x55; p1++) + if (seen[p1] == SEEN_THIS_CALL) + seen[p1] = (byte) p2; + player_calls += tempo << 6; + pos++; + } + set_song_duration(module_info, player_calls); +} + +FILE_FUNC abool parse_cmc(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len, abool cmr) +{ + int last_pos; + int pos; + if (module_len < 0x306) + return FALSE; + MODULE_INFO type = cmr ? 'z' : 'c'; + if (!load_native(ast, module_info, module, module_len, GET_OBX(cmc))) + return FALSE; + if (ast != NULL && cmr) + COPY_ARRAY(AST memory, 0x500 + CMR_BASS_TABLE_OFFSET, cmr_bass_table, 0, sizeof(cmr_bass_table)); + /* auto-detect number of subsongs */ + last_pos = 0x54; + while (--last_pos >= 0) { + if (UBYTE(module[0x206 + last_pos]) < 0xb0 + || UBYTE(module[0x25b + last_pos]) < 0x40 + || UBYTE(module[0x2b0 + last_pos]) < 0x40) + break; + } + MODULE_INFO songs = 0; + parse_cmc_song(module_info, module, 0); + for (pos = 0; pos < last_pos && MODULE_INFO songs < MAX_SONGS; pos++) + if (UBYTE(module[0x206 + pos]) == 0x8f || UBYTE(module[0x206 + pos]) == 0xef) + parse_cmc_song(module_info, module, pos + 1); + return TRUE; +} + +FILE_FUNC void parse_mpt_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, + abool ARRAY global_seen, int song_len, int pos) +{ + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int tempo = UBYTE(module[0x1cf]); + int player_calls = 0; + NEW_ARRAY(byte, seen, 256); + NEW_ARRAY(int, pattern_offset, 4); + NEW_ARRAY(int, blank_rows, 4); + NEW_ARRAY(int, blank_rows_counter, 4); + INIT_ARRAY(seen); + INIT_ARRAY(blank_rows); + while (pos < song_len) { + int i; + int ch; + int pattern_rows; + if (seen[pos] != 0) { + if (seen[pos] != SEEN_THIS_CALL) + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + seen[pos] = SEEN_THIS_CALL; + global_seen[pos] = TRUE; + i = UBYTE(module[0x1d0 + pos * 2]); + if (i == 0xff) { + pos = UBYTE(module[0x1d1 + pos * 2]); + continue; + } + for (ch = 3; ch >= 0; ch--) { + i = UBYTE(module[0x1c6 + ch]) + (UBYTE(module[0x1ca + ch]) << 8) - addr_to_offset; + i = UBYTE(module[i + pos * 2]); + if (i >= 0x40) + break; + i <<= 1; + i = UBYTE(module[0x46 + i]) + (UBYTE(module[0x47 + i]) << 8); + pattern_offset[ch] = i == 0 ? 0 : i - addr_to_offset; + blank_rows_counter[ch] = 0; + } + if (ch >= 0) + break; + for (i = 0; i < song_len; i++) + if (seen[i] == SEEN_THIS_CALL) + seen[i] = SEEN_BEFORE; + for (pattern_rows = UBYTE(module[0x1ce]); --pattern_rows >= 0; ) { + for (ch = 3; ch >= 0; ch--) { + if (pattern_offset[ch] == 0 || --blank_rows_counter[ch] >= 0) + continue; + for (;;) { + i = UBYTE(module[pattern_offset[ch]++]); + if (i < 0x40 || i == 0xfe) + break; + if (i < 0x80) + continue; + if (i < 0xc0) { + blank_rows[ch] = i - 0x80; + continue; + } + if (i < 0xd0) + continue; + if (i < 0xe0) { + tempo = i - 0xcf; + continue; + } + pattern_rows = 0; + } + blank_rows_counter[ch] = blank_rows[ch]; + } + player_calls += tempo; + } + pos++; + } + if (player_calls > 0) + set_song_duration(module_info, player_calls); +} + +FILE_FUNC abool parse_mpt(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int track0_addr; + int pos; + int song_len; + /* seen[i] == TRUE if the track position i has been processed */ + NEW_ARRAY(abool, global_seen, 256); + if (module_len < 0x1d0) + return FALSE; + MODULE_INFO type = 'm'; + if (!load_native(ast, module_info, module, module_len, GET_OBX(mpt))) + return FALSE; + track0_addr = UBYTE(module[2]) + (UBYTE(module[3]) << 8) + 0x1ca; + if (UBYTE(module[0x1c6]) + (UBYTE(module[0x1ca]) << 8) != track0_addr) + return FALSE; + /* Calculate the length of the first track. Address of the second track minus + address of the first track equals the length of the first track in bytes. + Divide by two to get number of track positions. */ + song_len = (UBYTE(module[0x1c7]) + (UBYTE(module[0x1cb]) << 8) - track0_addr) >> 1; + if (song_len > 0xfe) + return FALSE; + INIT_ARRAY(global_seen); + MODULE_INFO songs = 0; + for (pos = 0; pos < song_len && MODULE_INFO songs < MAX_SONGS; pos++) { + if (!global_seen[pos]) { + MODULE_INFO song_pos[MODULE_INFO songs] = (byte) pos; + parse_mpt_song(module_info, module, global_seen, song_len, pos); + } + } + return MODULE_INFO songs != 0; +} + +CONST_LOOKUP(byte, rmt_volume_silent) = { 16, 8, 4, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1 }; + +FILE_FUNC int rmt_instrument_frames(const byte ARRAY module, int instrument, int volume, int volume_frame, abool extra_pokey) +{ + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int per_frame = module[0xc]; + int player_call; + int player_calls; + int index; + int index_end; + int index_loop; + int volume_slide_depth; + int volume_min; + abool looping; + int volume_slide; + abool silent_loop; + instrument = UBYTE(module[0xe]) + (UBYTE(module[0xf]) << 8) - addr_to_offset + (instrument << 1); + if (module[instrument + 1] == 0) + return 0; + instrument = UBYTE(module[instrument]) + (UBYTE(module[instrument + 1]) << 8) - addr_to_offset; + player_calls = player_call = volume_frame * per_frame; + index = UBYTE(module[instrument]) + 1 + player_call * 3; + index_end = UBYTE(module[instrument + 2]) + 3; + index_loop = UBYTE(module[instrument + 3]); + if (index_loop >= index_end) + return 0; /* error */ + volume_slide_depth = UBYTE(module[instrument + 6]); + volume_min = UBYTE(module[instrument + 7]); + looping = index >= index_end; + if (looping) + index = (index - index_end) % (index_end - index_loop) + index_loop; + else { + do { + int vol = module[instrument + index]; + if (extra_pokey) + vol >>= 4; + if ((vol & 0xf) >= rmt_volume_silent[volume]) + player_calls = player_call + 1; + player_call++; + index += 3; + } while (index < index_end); + } + if (volume_slide_depth == 0) + return player_calls / per_frame; + volume_slide = 128; + silent_loop = FALSE; + for (;;) { + int vol; + if (index >= index_end) { + if (silent_loop) + break; + silent_loop = TRUE; + index = index_loop; + } + vol = module[instrument + index]; + if (extra_pokey) + vol >>= 4; + if ((vol & 0xf) >= rmt_volume_silent[volume]) { + player_calls = player_call + 1; + silent_loop = FALSE; + } + player_call++; + index += 3; + volume_slide -= volume_slide_depth; + if (volume_slide < 0) { + volume_slide += 256; + if (--volume <= volume_min) + break; + } + } + return player_calls / per_frame; +} + +FILE_FUNC void parse_rmt_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, + abool ARRAY global_seen, int song_len, int pos_shift, int pos) +{ + int ch; + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int tempo = UBYTE(module[0xb]); + int frames = 0; + int song_offset = UBYTE(module[0x14]) + (UBYTE(module[0x15]) << 8) - addr_to_offset; + int pattern_lo_offset = UBYTE(module[0x10]) + (UBYTE(module[0x11]) << 8) - addr_to_offset; + int pattern_hi_offset = UBYTE(module[0x12]) + (UBYTE(module[0x13]) << 8) - addr_to_offset; + int instrument_frames; + NEW_ARRAY(byte, seen, 256); + NEW_ARRAY(int, pattern_begin, 8); + NEW_ARRAY(int, pattern_offset, 8); + NEW_ARRAY(int, blank_rows, 8); + NEW_ARRAY(int, instrument_no, 8); + NEW_ARRAY(int, instrument_frame, 8); + NEW_ARRAY(int, volume_value, 8); + NEW_ARRAY(int, volume_frame, 8); + INIT_ARRAY(seen); + INIT_ARRAY(instrument_no); + INIT_ARRAY(instrument_frame); + INIT_ARRAY(volume_value); + INIT_ARRAY(volume_frame); + while (pos < song_len) { + int i; + int pattern_rows; + if (seen[pos] != 0) { + if (seen[pos] != SEEN_THIS_CALL) + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + seen[pos] = SEEN_THIS_CALL; + global_seen[pos] = TRUE; + if (UBYTE(module[song_offset + (pos << pos_shift)]) == 0xfe) { + pos = UBYTE(module[song_offset + (pos << pos_shift) + 1]); + continue; + } + for (ch = 0; ch < 1 << pos_shift; ch++) { + i = UBYTE(module[song_offset + (pos << pos_shift) + ch]); + if (i == 0xff) + blank_rows[ch] = 256; + else { + pattern_offset[ch] = pattern_begin[ch] = UBYTE(module[pattern_lo_offset + i]) + + (UBYTE(module[pattern_hi_offset + i]) << 8) - addr_to_offset; + blank_rows[ch] = 0; + } + } + for (i = 0; i < song_len; i++) + if (seen[i] == SEEN_THIS_CALL) + seen[i] = SEEN_BEFORE; + for (pattern_rows = UBYTE(module[0xa]); --pattern_rows >= 0; ) { + for (ch = 0; ch < 1 << pos_shift; ch++) { + if (--blank_rows[ch] > 0) + continue; + for (;;) { + i = UBYTE(module[pattern_offset[ch]++]); + if ((i & 0x3f) < 62) { + i += UBYTE(module[pattern_offset[ch]++]) << 8; + if ((i & 0x3f) != 61) { + instrument_no[ch] = i >> 10; + instrument_frame[ch] = frames; + } + volume_value[ch] = (i >> 6) & 0xf; + volume_frame[ch] = frames; + break; + } + if (i == 62) { + blank_rows[ch] = UBYTE(module[pattern_offset[ch]++]); + break; + } + if ((i & 0x3f) == 62) { + blank_rows[ch] = i >> 6; + break; + } + if ((i & 0xbf) == 63) { + tempo = UBYTE(module[pattern_offset[ch]++]); + continue; + } + if (i == 0xbf) { + pattern_offset[ch] = pattern_begin[ch] + UBYTE(module[pattern_offset[ch]]); + continue; + } + /* assert(i == 0xff); */ + pattern_rows = -1; + break; + } + if (pattern_rows < 0) + break; + } + if (pattern_rows >= 0) + frames += tempo; + } + pos++; + } + instrument_frames = 0; + for (ch = 0; ch < 1 << pos_shift; ch++) { + int frame = instrument_frame[ch]; + frame += rmt_instrument_frames(module, instrument_no[ch], volume_value[ch], volume_frame[ch] - frame, ch >= 4); + if (instrument_frames < frame) + instrument_frames = frame; + } + if (frames > instrument_frames) { + if (frames - instrument_frames > 100) + MODULE_INFO loops[MODULE_INFO songs] = FALSE; + frames = instrument_frames; + } + if (frames > 0) + set_song_duration(module_info, frames); +} + +FILE_FUNC abool parse_rmt(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int per_frame; + int pos_shift; + int song_len; + int pos; + NEW_ARRAY(abool, global_seen, 256); + if (module_len < 0x30 || module[6] != 'R' || module[7] != 'M' + || module[8] != 'T' || module[0xd] != 1) + return FALSE; + switch ((char) module[9]) { + case '4': + pos_shift = 2; + break; + case '8': + MODULE_INFO channels = 2; + pos_shift = 3; + break; + default: + return FALSE; + } + per_frame = module[0xc]; + if (per_frame < 1 || per_frame > 4) + return FALSE; + MODULE_INFO type = 'r'; + if (!load_native(ast, module_info, module, module_len, + MODULE_INFO channels == 2 ? GET_OBX(rmt8) : GET_OBX(rmt4))) + return FALSE; + song_len = UBYTE(module[4]) + (UBYTE(module[5]) << 8) + 1 + - UBYTE(module[0x14]) - (UBYTE(module[0x15]) << 8); + if (pos_shift == 3 && (song_len & 4) != 0 + && UBYTE(module[6 + UBYTE(module[4]) + (UBYTE(module[5]) << 8) + - UBYTE(module[2]) - (UBYTE(module[3]) << 8) - 3]) == 0xfe) + song_len += 4; + song_len >>= pos_shift; + if (song_len >= 0x100) + return FALSE; + INIT_ARRAY(global_seen); + MODULE_INFO songs = 0; + for (pos = 0; pos < song_len && MODULE_INFO songs < MAX_SONGS; pos++) { + if (!global_seen[pos]) { + MODULE_INFO song_pos[MODULE_INFO songs] = (byte) pos; + parse_rmt_song(module_info, module, global_seen, song_len, pos_shift, pos); + } + } + /* must set fastplay after song durations calculations, so they assume 312 */ + MODULE_INFO fastplay = perframe2fastplay[per_frame - 1]; + MODULE_INFO player = 0x600; + return MODULE_INFO songs != 0; +} + +FILE_FUNC void parse_tmc_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, int pos) +{ + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int tempo = UBYTE(module[0x24]) + 1; + int frames = 0; + NEW_ARRAY(int, pattern_offset, 8); + NEW_ARRAY(int, blank_rows, 8); + while (UBYTE(module[0x1a6 + 15 + pos]) < 0x80) { + int ch; + int pattern_rows; + for (ch = 7; ch >= 0; ch--) { + int pat = UBYTE(module[0x1a6 + 15 + pos - 2 * ch]); + pattern_offset[ch] = UBYTE(module[0xa6 + pat]) + (UBYTE(module[0x126 + pat]) << 8) - addr_to_offset; + blank_rows[ch] = 0; + } + for (pattern_rows = 64; --pattern_rows >= 0; ) { + for (ch = 7; ch >= 0; ch--) { + if (--blank_rows[ch] >= 0) + continue; + for (;;) { + int i = UBYTE(module[pattern_offset[ch]++]); + if (i < 0x40) { + pattern_offset[ch]++; + break; + } + if (i == 0x40) { + i = UBYTE(module[pattern_offset[ch]++]); + if ((i & 0x7f) == 0) + pattern_rows = 0; + else + tempo = (i & 0x7f) + 1; + if (i >= 0x80) + pattern_offset[ch]++; + break; + } + if (i < 0x80) { + i = module[pattern_offset[ch]++] & 0x7f; + if (i == 0) + pattern_rows = 0; + else + tempo = i + 1; + pattern_offset[ch]++; + break; + } + if (i < 0xc0) + continue; + blank_rows[ch] = i - 0xbf; + break; + } + } + frames += tempo; + } + pos += 16; + } + if (UBYTE(module[0x1a6 + 14 + pos]) < 0x80) + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + set_song_duration(module_info, frames); +} + +FILE_FUNC abool parse_tmc(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int i; + int last_pos; + if (module_len < 0x1d0) + return FALSE; + MODULE_INFO type = 't'; + if (!load_native(ast, module_info, module, module_len, GET_OBX(tmc))) + return FALSE; + MODULE_INFO channels = 2; + i = 0; + /* find first instrument */ + while (module[0x66 + i] == 0) { + if (++i >= 64) + return FALSE; /* no instrument */ + } + last_pos = (UBYTE(module[0x66 + i]) << 8) + UBYTE(module[0x26 + i]) + - UBYTE(module[2]) - (UBYTE(module[3]) << 8) - 0x1b0; + if (0x1b5 + last_pos >= module_len) + return FALSE; + /* skip trailing jumps */ + do { + if (last_pos <= 0) + return FALSE; /* no pattern to play */ + last_pos -= 16; + } while (UBYTE(module[0x1b5 + last_pos]) >= 0x80); + MODULE_INFO songs = 0; + parse_tmc_song(module_info, module, 0); + for (i = 0; i < last_pos && MODULE_INFO songs < MAX_SONGS; i += 16) + if (UBYTE(module[0x1b5 + i]) >= 0x80) + parse_tmc_song(module_info, module, i + 16); + /* must set fastplay after song durations calculations, so they assume 312 */ + i = module[0x25]; + if (i < 1 || i > 4) + return FALSE; + if (ast != NULL) + AST tmc_per_frame = module[0x25]; + MODULE_INFO fastplay = perframe2fastplay[i - 1]; + return TRUE; +} + +FILE_FUNC void parse_tm2_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, int pos) +{ + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int tempo = UBYTE(module[0x24]) + 1; + int player_calls = 0; + NEW_ARRAY(int, pattern_offset, 8); + NEW_ARRAY(int, blank_rows, 8); + for (;;) { + int ch; + int pattern_rows = UBYTE(module[0x386 + 16 + pos]); + if (pattern_rows == 0) + break; + if (pattern_rows >= 0x80) { + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + for (ch = 7; ch >= 0; ch--) { + int pat = UBYTE(module[0x386 + 15 + pos - 2 * ch]); + pattern_offset[ch] = UBYTE(module[0x106 + pat]) + (UBYTE(module[0x206 + pat]) << 8) - addr_to_offset; + blank_rows[ch] = 0; + } + while (--pattern_rows >= 0) { + for (ch = 7; ch >= 0; ch--) { + if (--blank_rows[ch] >= 0) + continue; + for (;;) { + int i = UBYTE(module[pattern_offset[ch]++]); + if (i == 0) { + pattern_offset[ch]++; + break; + } + if (i < 0x40) { + if (UBYTE(module[pattern_offset[ch]++]) >= 0x80) + pattern_offset[ch]++; + break; + } + if (i < 0x80) { + pattern_offset[ch]++; + break; + } + if (i == 0x80) { + blank_rows[ch] = UBYTE(module[pattern_offset[ch]++]); + break; + } + if (i < 0xc0) + break; + if (i < 0xd0) { + tempo = i - 0xbf; + continue; + } + if (i < 0xe0) { + pattern_offset[ch]++; + break; + } + if (i < 0xf0) { + pattern_offset[ch] += 2; + break; + } + if (i < 0xff) { + blank_rows[ch] = i - 0xf0; + break; + } + blank_rows[ch] = 64; + break; + } + } + player_calls += tempo; + } + pos += 17; + } + set_song_duration(module_info, player_calls); +} + +FILE_FUNC abool parse_tm2(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int i; + int last_pos; + int c; + if (module_len < 0x3a4) + return FALSE; + MODULE_INFO type = 'T'; + if (!load_native(ast, module_info, module, module_len, GET_OBX(tm2))) + return FALSE; + i = module[0x25]; + if (i < 1 || i > 4) + return FALSE; + MODULE_INFO fastplay = perframe2fastplay[i - 1]; + MODULE_INFO player = 0x500; + if (module[0x1f] != 0) + MODULE_INFO channels = 2; + last_pos = 0xffff; + for (i = 0; i < 0x80; i++) { + int instr_addr = UBYTE(module[0x86 + i]) + (UBYTE(module[0x306 + i]) << 8); + if (instr_addr != 0 && instr_addr < last_pos) + last_pos = instr_addr; + } + for (i = 0; i < 0x100; i++) { + int pattern_addr = UBYTE(module[0x106 + i]) + (UBYTE(module[0x206 + i]) << 8); + if (pattern_addr != 0 && pattern_addr < last_pos) + last_pos = pattern_addr; + } + last_pos -= UBYTE(module[2]) + (UBYTE(module[3]) << 8) + 0x380; + if (0x386 + last_pos >= module_len) + return FALSE; + /* skip trailing stop/jump commands */ + do { + if (last_pos <= 0) + return FALSE; + last_pos -= 17; + c = UBYTE(module[0x386 + 16 + last_pos]); + } while (c == 0 || c >= 0x80); + MODULE_INFO songs = 0; + parse_tm2_song(module_info, module, 0); + for (i = 0; i < last_pos && MODULE_INFO songs < MAX_SONGS; i += 17) { + c = UBYTE(module[0x386 + 16 + i]); + if (c == 0 || c >= 0x80) + parse_tm2_song(module_info, module, i + 17); + } + return TRUE; +} + +#if !defined(JAVA) && !defined(CSHARP) + +static abool parse_hex(int *retval, const char *p) +{ + int r = 0; + do { + char c = *p; + if (r > 0xfff) + return FALSE; + r <<= 4; + if (c >= '0' && c <= '9') + r += c - '0'; + else if (c >= 'A' && c <= 'F') + r += c - 'A' + 10; + else if (c >= 'a' && c <= 'f') + r += c - 'a' + 10; + else + return FALSE; + } while (*++p != '\0'); + *retval = r; + return TRUE; +} + +static abool parse_dec(int *retval, const char *p, int minval, int maxval) +{ + int r = 0; + do { + char c = *p; + if (c >= '0' && c <= '9') + r = 10 * r + c - '0'; + else + return FALSE; + if (r > maxval) + return FALSE; + } while (*++p != '\0'); + if (r < minval) + return FALSE; + *retval = r; + return TRUE; +} + +static abool parse_text(char *retval, const char *p) +{ + int i; + if (*p != '"') + return FALSE; + p++; + if (p[0] == '<' && p[1] == '?' && p[2] == '>' && p[3] == '"') + return TRUE; + i = 0; + while (*p != '"') { + if (i >= 127) + return FALSE; + if (*p == '\0') + return FALSE; + retval[i++] = *p++; + } + retval[i] = '\0'; + return TRUE; +} + +int ASAP_ParseDuration(const char *s) +{ + int r; + if (*s < '0' || *s > '9') + return -1; + r = *s++ - '0'; + if (*s >= '0' && *s <= '9') + r = 10 * r + *s++ - '0'; + if (*s == ':') { + s++; + if (*s < '0' || *s > '5') + return -1; + r = 60 * r + (*s++ - '0') * 10; + if (*s < '0' || *s > '9') + return -1; + r += *s++ - '0'; + } + r *= 1000; + if (*s != '.') + return r; + s++; + if (*s < '0' || *s > '9') + return r; + r += 100 * (*s++ - '0'); + if (*s < '0' || *s > '9') + return r; + r += 10 * (*s++ - '0'); + if (*s < '0' || *s > '9') + return r; + r += *s - '0'; + return r; +} + +static char *two_digits(char *s, int x) +{ + s[0] = '0' + x / 10; + s[1] = '0' + x % 10; + return s + 2; +} + +void ASAP_DurationToString(char *s, int duration) +{ + if (duration >= 0) { + int seconds = duration / 1000; + int minutes = seconds / 60; + s = two_digits(s, minutes); + *s++ = ':'; + s = two_digits(s, seconds % 60); + duration %= 1000; + if (duration != 0) { + *s++ = '.'; + s = two_digits(s, duration / 10); + duration %= 10; + if (duration != 0) + *s++ = '0' + duration; + } + } + *s = '\0'; +} + +#endif /* !defined(JAVA) && !defined(CSHARP) */ + +FILE_FUNC abool parse_sap_header(ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int module_index = 0; + abool sap_signature = FALSE; + int duration_index = 0; + for (;;) { + NEW_ARRAY(char, line, 256); + int i; +#if !defined(JAVA) && !defined(CSHARP) + char *p; +#endif + if (module_index + 8 >= module_len) + return FALSE; + if (UBYTE(module[module_index]) == 0xff) + break; + i = 0; + while (module[module_index] != 0x0d) { + line[i++] = (char) module[module_index++]; + if (module_index >= module_len || i >= sizeof(line) - 1) + return FALSE; + } + if (++module_index >= module_len || module[module_index++] != 0x0a) + return FALSE; + +#ifdef JAVA + String tag = new String(line, 0, i); + String arg = null; + i = tag.indexOf(' '); + if (i >= 0) { + arg = tag.substring(i + 1); + tag = tag.substring(0, i); + } +#define TAG_IS(t) tag.equals(t) +#define CHAR_ARG arg.charAt(0) +#define SET_HEX(v) v = Integer.parseInt(arg, 16) +#define SET_DEC(v, min, max) do { v = Integer.parseInt(arg); if (v < min || v > max) return FALSE; } while (FALSE) +#define SET_TEXT(v) v = arg.substring(1, arg.length() - 1) +#define DURATION_ARG parseDuration(arg) +#define ARG_CONTAINS(t) (arg.indexOf(t) >= 0) +#elif defined(CSHARP) + string tag = new string(line, 0, i); + string arg = null; + i = tag.IndexOf(' '); + if (i >= 0) { + arg = tag.Substring(i + 1); + tag = tag.Substring(0, i); + } +#define TAG_IS(t) tag == t +#define CHAR_ARG arg[0] +#define SET_HEX(v) v = int.Parse(arg, System.Globalization.NumberStyles.HexNumber) +#define SET_DEC(v, min, max) do { v = int.Parse(arg); if (v < min || v > max) return FALSE; } while (FALSE) +#define SET_TEXT(v) v = arg.Substring(1, arg.Length - 1) +#define DURATION_ARG ParseDuration(arg) +#define ARG_CONTAINS(t) (arg.IndexOf(t) >= 0) +#else + line[i] = '\0'; + for (p = line; *p != '\0'; p++) { + if (*p == ' ') { + *p++ = '\0'; + break; + } + } +#define TAG_IS(t) (strcmp(line, t) == 0) +#define CHAR_ARG *p +#define SET_HEX(v) do { if (!parse_hex(&v, p)) return FALSE; } while (FALSE) +#define SET_DEC(v, min, max) do { if (!parse_dec(&v, p, min, max)) return FALSE; } while (FALSE) +#define SET_TEXT(v) do { if (!parse_text(v, p)) return FALSE; } while (FALSE) +#define DURATION_ARG ASAP_ParseDuration(p) +#define ARG_CONTAINS(t) (strstr(p, t) != NULL) +#endif + + if (TAG_IS("SAP")) + sap_signature = TRUE; + if (!sap_signature) + return FALSE; + if (TAG_IS("AUTHOR")) + SET_TEXT(MODULE_INFO author); + else if (TAG_IS("NAME")) + SET_TEXT(MODULE_INFO name); + else if (TAG_IS("DATE")) + SET_TEXT(MODULE_INFO date); + else if (TAG_IS("SONGS")) + SET_DEC(MODULE_INFO songs, 1, MAX_SONGS); + else if (TAG_IS("DEFSONG")) + SET_DEC(MODULE_INFO default_song, 0, MAX_SONGS - 1); + else if (TAG_IS("STEREO")) + MODULE_INFO channels = 2; + else if (TAG_IS("TIME")) { + int duration = DURATION_ARG; + if (duration < 0 || duration_index >= MAX_SONGS) + return FALSE; + MODULE_INFO durations[duration_index] = duration; + if (ARG_CONTAINS("LOOP")) + MODULE_INFO loops[duration_index] = TRUE; + duration_index++; + } + else if (TAG_IS("TYPE")) + MODULE_INFO type = CHAR_ARG; + else if (TAG_IS("FASTPLAY")) + SET_DEC(MODULE_INFO fastplay, 1, 312); + else if (TAG_IS("MUSIC")) + SET_HEX(MODULE_INFO music); + else if (TAG_IS("INIT")) + SET_HEX(MODULE_INFO init); + else if (TAG_IS("PLAYER")) + SET_HEX(MODULE_INFO player); + } + if (MODULE_INFO default_song >= MODULE_INFO songs) + return FALSE; + switch (MODULE_INFO type) { + case 'B': + case 'D': + if (MODULE_INFO player < 0 || MODULE_INFO init < 0) + return FALSE; + break; + case 'C': + if (MODULE_INFO player < 0 || MODULE_INFO music < 0) + return FALSE; + break; + case 'S': + if (MODULE_INFO init < 0) + return FALSE; + MODULE_INFO fastplay = 78; + break; + default: + return FALSE; + } + if (UBYTE(module[module_index + 1]) != 0xff) + return FALSE; + MODULE_INFO header_len = module_index; + return TRUE; +} + +FILE_FUNC abool parse_sap(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int module_index; + if (!parse_sap_header(module_info, module, module_len)) + return FALSE; + if (ast == NULL) + return TRUE; + ZERO_ARRAY(AST memory); + module_index = MODULE_INFO header_len + 2; + while (module_index + 5 <= module_len) { + int start_addr = UBYTE(module[module_index]) + (UBYTE(module[module_index + 1]) << 8); + int block_len = UBYTE(module[module_index + 2]) + (UBYTE(module[module_index + 3]) << 8) + 1 - start_addr; + if (block_len <= 0 || module_index + block_len > module_len) + return FALSE; + module_index += 4; + COPY_ARRAY(AST memory, start_addr, module, module_index, block_len); + module_index += block_len; + if (module_index == module_len) + return TRUE; + if (module_index + 7 <= module_len + && UBYTE(module[module_index]) == 0xff && UBYTE(module[module_index + 1]) == 0xff) + module_index += 2; + } + return FALSE; +} + +#define ASAP_EXT(c1, c2, c3) (((c1) + ((c2) << 8) + ((c3) << 16)) | 0x202020) + +FILE_FUNC int get_packed_ext(STRING filename) +{ +#ifdef JAVA + int i = filename.length(); + int ext = 0; + while (--i > 0) { + if (filename.charAt(i) == '.') + return ext | 0x202020; + ext = (ext << 8) + filename.charAt(i); + } + return 0; +#elif defined(CSHARP) + int i = filename.Length; + int ext = 0; + while (--i > 0) { + if (filename[i] == '.') + return ext | 0x202020; + ext = (ext << 8) + filename[i]; + } + return 0; +#else + const char *p; + int ext; + for (p = filename; *p != '\0'; p++); + ext = 0; + for (;;) { + if (--p <= filename || *p <= ' ') + return 0; /* no filename extension or invalid character */ + if (*p == '.') + return ext | 0x202020; + ext = (ext << 8) + (*p & 0xff); + } +#endif +} + +FILE_FUNC abool is_our_ext(int ext) +{ + switch (ext) { + case ASAP_EXT('C', 'M', 'C'): + case ASAP_EXT('C', 'M', 'R'): + case ASAP_EXT('D', 'M', 'C'): + case ASAP_EXT('M', 'P', 'D'): + case ASAP_EXT('M', 'P', 'T'): + case ASAP_EXT('R', 'M', 'T'): + case ASAP_EXT('S', 'A', 'P'): + case ASAP_EXT('T', 'M', '2'): + case ASAP_EXT('T', 'M', '8'): + case ASAP_EXT('T', 'M', 'C'): + return TRUE; + default: + return FALSE; + } +} + +ASAP_FUNC abool ASAP_IsOurFile(STRING filename) +{ + int ext = get_packed_ext(filename); + return is_our_ext(ext); +} + +ASAP_FUNC abool ASAP_IsOurExt(STRING ext) +{ +#ifdef JAVA + return ext.length() == 3 + && is_our_ext(ASAP_EXT(ext.charAt(0), ext.charAt(1), ext.charAt(2))); +#else + return ext[0] > ' ' && ext[1] > ' ' && ext[2] > ' ' && ext[3] == '\0' + && is_our_ext(ASAP_EXT(ext[0], ext[1], ext[2])); +#endif +} + +FILE_FUNC abool parse_file(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + STRING filename, const byte ARRAY module, int module_len) +{ + int i; +#ifdef JAVA + int basename = 0; + int ext = -1; + for (i = 0; i < filename.length(); i++) { + int c = filename.charAt(i); + if (c == '/' || c == '\\') + basename = i + 1; + else if (c == '.') + ext = i; + } + if (ext < 0) + ext = i; + module_info.author = ""; + module_info.name = filename.substring(basename, ext); + module_info.date = ""; +#elif defined(CSHARP) + int basename = 0; + int ext = -1; + for (i = 0; i < filename.Length; i++) { + int c = filename[i]; + if (c == '/' || c == '\\') + basename = i + 1; + else if (c == '.') + ext = i; + } + if (ext < 0) + ext = i; + module_info.author = string.Empty; + module_info.name = filename.Substring(basename, ext - basename); + module_info.date = string.Empty; +#else + const char *p; + const char *basename = filename; + const char *ext = NULL; + for (p = filename; *p != '\0'; p++) { + if (*p == '/' || *p == '\\') + basename = p + 1; + else if (*p == '.') + ext = p; + } + if (ext == NULL) + ext = p; + module_info->author[0] = '\0'; + i = ext - basename; + memcpy(module_info->name, basename, i); + module_info->name[i] = '\0'; + module_info->date[0] = '\0'; +#endif + MODULE_INFO channels = 1; + MODULE_INFO songs = 1; + MODULE_INFO default_song = 0; + for (i = 0; i < MAX_SONGS; i++) { + MODULE_INFO durations[i] = -1; + MODULE_INFO loops[i] = FALSE; + } + MODULE_INFO type = '?'; + MODULE_INFO fastplay = 312; + MODULE_INFO music = -1; + MODULE_INFO init = -1; + MODULE_INFO player = -1; + switch (get_packed_ext(filename)) { + case ASAP_EXT('C', 'M', 'C'): + return parse_cmc(ast, module_info, module, module_len, FALSE); + case ASAP_EXT('C', 'M', 'R'): + return parse_cmc(ast, module_info, module, module_len, TRUE); + case ASAP_EXT('D', 'M', 'C'): + MODULE_INFO fastplay = 156; + return parse_cmc(ast, module_info, module, module_len, FALSE); + case ASAP_EXT('M', 'P', 'D'): + MODULE_INFO fastplay = 156; + return parse_mpt(ast, module_info, module, module_len); + case ASAP_EXT('M', 'P', 'T'): + return parse_mpt(ast, module_info, module, module_len); + case ASAP_EXT('R', 'M', 'T'): + return parse_rmt(ast, module_info, module, module_len); + case ASAP_EXT('S', 'A', 'P'): + return parse_sap(ast, module_info, module, module_len); + case ASAP_EXT('T', 'M', '2'): + return parse_tm2(ast, module_info, module, module_len); + case ASAP_EXT('T', 'M', '8'): + case ASAP_EXT('T', 'M', 'C'): + return parse_tmc(ast, module_info, module, module_len); + default: + return FALSE; + } +} + +ASAP_FUNC abool ASAP_GetModuleInfo(ASAP_ModuleInfo PTR module_info, STRING filename, + const byte ARRAY module, int module_len) +{ + return parse_file(NULL, module_info, filename, module, module_len); +} + +ASAP_FUNC abool ASAP_Load(ASAP_State PTR ast, STRING filename, + const byte ARRAY module, int module_len) +{ + AST silence_cycles = 0; + return parse_file(ast, ADDRESSOF AST module_info, filename, module, module_len); +} + +ASAP_FUNC void ASAP_DetectSilence(ASAP_State PTR ast, int seconds) +{ + AST silence_cycles = seconds * ASAP_MAIN_CLOCK; +} + +FILE_FUNC void call_6502(ASAP_State PTR ast, int addr, int max_scanlines) +{ + AST cpu_pc = addr; + /* put a CIM at 0xd20a and a return address on stack */ + dPutByte(0xd20a, 0xd2); + dPutByte(0x01fe, 0x09); + dPutByte(0x01ff, 0xd2); + AST cpu_s = 0xfd; + Cpu_RunScanlines(ast, max_scanlines); +} + +/* 50 Atari frames for the initialization routine - some SAPs are self-extracting. */ +#define SCANLINES_FOR_INIT (50 * 312) + +FILE_FUNC void call_6502_init(ASAP_State PTR ast, int addr, int a, int x, int y) +{ + AST cpu_a = a & 0xff; + AST cpu_x = x & 0xff; + AST cpu_y = y & 0xff; + call_6502(ast, addr, SCANLINES_FOR_INIT); +} + +ASAP_FUNC void ASAP_PlaySong(ASAP_State PTR ast, int song, int duration) +{ + AST current_song = song; + AST current_duration = duration; + AST blocks_played = 0; + AST silence_cycles_counter = AST silence_cycles; + AST extra_pokey_mask = AST module_info.channels > 1 ? 0x10 : 0; + PokeySound_Initialize(ast); + AST cycle = 0; + AST cpu_nz = 0; + AST cpu_c = 0; + AST cpu_vdi = 0; + AST scanline_number = 0; + AST next_scanline_cycle = 0; + AST timer1_cycle = NEVER; + AST timer2_cycle = NEVER; + AST timer4_cycle = NEVER; + AST irqst = 0xff; + switch (AST module_info.type) { + case 'B': + call_6502_init(ast, AST module_info.init, song, 0, 0); + break; + case 'C': + case 'c': + case 'z': + call_6502_init(ast, AST module_info.player + 3, 0x70, AST module_info.music, AST module_info.music >> 8); + call_6502_init(ast, AST module_info.player + 3, 0x00, song, 0); + break; + case 'D': + case 'S': + AST cpu_a = song; + AST cpu_x = 0x00; + AST cpu_y = 0x00; + AST cpu_s = 0xff; + AST cpu_pc = AST module_info.init; + break; + case 'm': + call_6502_init(ast, AST module_info.player, 0x00, AST module_info.music >> 8, AST module_info.music); + call_6502_init(ast, AST module_info.player, 0x02, AST module_info.song_pos[song], 0); + break; + case 'r': + call_6502_init(ast, AST module_info.player, AST module_info.song_pos[song], AST module_info.music, AST module_info.music >> 8); + break; + case 't': + case 'T': + call_6502_init(ast, AST module_info.player, 0x70, AST module_info.music >> 8, AST module_info.music); + call_6502_init(ast, AST module_info.player, 0x00, song, 0); + AST tmc_per_frame_counter = 1; + break; + } + ASAP_MutePokeyChannels(ast, 0); +} + +ASAP_FUNC void ASAP_MutePokeyChannels(ASAP_State PTR ast, int mask) +{ + PokeySound_Mute(ast, ADDRESSOF AST base_pokey, mask); + PokeySound_Mute(ast, ADDRESSOF AST extra_pokey, mask >> 4); +} + +ASAP_FUNC abool call_6502_player(ASAP_State PTR ast) +{ + int s; + PokeySound_StartFrame(ast); + switch (AST module_info.type) { + case 'B': + call_6502(ast, AST module_info.player, AST module_info.fastplay); + break; + case 'C': + case 'c': + case 'z': + call_6502(ast, AST module_info.player + 6, AST module_info.fastplay); + break; + case 'D': + s = AST cpu_s; +#define PUSH_ON_6502_STACK(x) dPutByte(0x100 + s, x); s = (s - 1) & 0xff +#define RETURN_FROM_PLAYER_ADDR 0xd200 + /* save 6502 state on 6502 stack */ + PUSH_ON_6502_STACK(AST cpu_pc >> 8); + PUSH_ON_6502_STACK(AST cpu_pc & 0xff); + PUSH_ON_6502_STACK(((AST cpu_nz | (AST cpu_nz >> 1)) & 0x80) + AST cpu_vdi + \ + ((AST cpu_nz & 0xff) == 0 ? Z_FLAG : 0) + AST cpu_c + 0x20); + PUSH_ON_6502_STACK(AST cpu_a); + PUSH_ON_6502_STACK(AST cpu_x); + PUSH_ON_6502_STACK(AST cpu_y); + /* RTS will jump to 6502 code that restores the state */ + PUSH_ON_6502_STACK((RETURN_FROM_PLAYER_ADDR - 1) >> 8); + PUSH_ON_6502_STACK((RETURN_FROM_PLAYER_ADDR - 1) & 0xff); + AST cpu_s = s; + dPutByte(RETURN_FROM_PLAYER_ADDR, 0x68); /* PLA */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 1, 0xa8); /* TAY */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 2, 0x68); /* PLA */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 3, 0xaa); /* TAX */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 4, 0x68); /* PLA */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 5, 0x40); /* RTI */ + AST cpu_pc = AST module_info.player; + Cpu_RunScanlines(ast, AST module_info.fastplay); + break; + case 'S': + Cpu_RunScanlines(ast, AST module_info.fastplay); + { + int i = dGetByte(0x45) - 1; + dPutByte(0x45, i); + if (i == 0) + dPutByte(0xb07b, dGetByte(0xb07b) + 1); + } + break; + case 'm': + case 'r': + case 'T': + call_6502(ast, AST module_info.player + 3, AST module_info.fastplay); + break; + case 't': + if (--AST tmc_per_frame_counter <= 0) { + AST tmc_per_frame_counter = AST tmc_per_frame; + call_6502(ast, AST module_info.player + 3, AST module_info.fastplay); + } + else + call_6502(ast, AST module_info.player + 6, AST module_info.fastplay); + break; + } + PokeySound_EndFrame(ast, AST module_info.fastplay * 114); + if (AST silence_cycles > 0) { + if (PokeySound_IsSilent(ADDRESSOF AST base_pokey) + && PokeySound_IsSilent(ADDRESSOF AST extra_pokey)) { + AST silence_cycles_counter -= AST module_info.fastplay * 114; + if (AST silence_cycles_counter <= 0) + return FALSE; + } + else + AST silence_cycles_counter = AST silence_cycles; + } + return TRUE; +} + +FILE_FUNC int milliseconds_to_blocks(int milliseconds) +{ + return milliseconds * (ASAP_SAMPLE_RATE / 100) / 10; +} + +ASAP_FUNC void ASAP_Seek(ASAP_State PTR ast, int position) +{ + int block = milliseconds_to_blocks(position); + if (block < AST blocks_played) + ASAP_PlaySong(ast, AST current_song, AST current_duration); + while (AST blocks_played + AST samples - AST sample_index < block) { + AST blocks_played += AST samples - AST sample_index; + call_6502_player(ast); + } + AST sample_index += block - AST blocks_played; + AST blocks_played = block; +} + +ASAP_FUNC int ASAP_Generate(ASAP_State PTR ast, VOIDPTR buffer, int buffer_len, + ASAP_SampleFormat format) +{ + int block_shift; + int buffer_blocks; + int block; + if (AST silence_cycles > 0 && AST silence_cycles_counter <= 0) + return 0; + block_shift = (AST module_info.channels - 1) + (format != ASAP_FORMAT_U8 ? 1 : 0); + buffer_blocks = buffer_len >> block_shift; + if (AST current_duration > 0) { + int total_blocks = milliseconds_to_blocks(AST current_duration); + if (buffer_blocks > total_blocks - AST blocks_played) + buffer_blocks = total_blocks - AST blocks_played; + } + block = 0; + do { + int blocks = PokeySound_Generate(ast, buffer, block << block_shift, buffer_blocks - block, format); + AST blocks_played += blocks; + block += blocks; + } while (block < buffer_blocks && call_6502_player(ast)); + return block << block_shift; +} + +#if !defined(JAVA) && !defined(CSHARP) + +abool ASAP_ChangeExt(char *filename, const char *ext) +{ + char *dest = NULL; + while (*filename != '\0') { + if (*filename == '/' || *filename == '\\') + dest = NULL; + else if (*filename == '.') + dest = filename + 1; + filename++; + } + if (dest == NULL) + return FALSE; + strcpy(dest, ext); + return TRUE; +} + +abool ASAP_CanSetModuleInfo(const char *filename) +{ + int ext = get_packed_ext(filename); + return ext == ASAP_EXT('S', 'A', 'P'); +} + +static byte *put_string(byte *dest, const char *str) +{ + while (*str != '\0') + *dest++ = *str++; + return dest; +} + +static byte *put_dec(byte *dest, int value) +{ + if (value >= 10) { + dest = put_dec(dest, value / 10); + value %= 10; + } + *dest++ = '0' + value; + return dest; +} + +static byte *put_text_tag(byte *dest, const char *tag, const char *value) +{ + dest = put_string(dest, tag); + *dest++ = ' '; + *dest++ = '"'; + if (*value == '\0') + value = ""; + while (*value != '\0') { + if (*value < ' ' || *value > 'z' || *value == '"' || *value == '`') + return NULL; + *dest++ = *value++; + } + *dest++ = '"'; + *dest++ = '\r'; + *dest++ = '\n'; + return dest; +} + +static byte *put_hex_tag(byte *dest, const char *tag, int value) +{ + int i; + if (value < 0) + return dest; + dest = put_string(dest, tag); + *dest++ = ' '; + for (i = 12; i >= 0; i -= 4) { + int digit = (value >> i) & 0xf; + *dest++ = (byte) (digit + (digit < 10 ? '0' : 'A' - 10)); + } + *dest++ = '\r'; + *dest++ = '\n'; + return dest; +} + +static byte *put_dec_tag(byte *dest, const char *tag, int value) +{ + dest = put_string(dest, tag); + *dest++ = ' '; + dest = put_dec(dest, value); + *dest++ = '\r'; + *dest++ = '\n'; + return dest; +} + +static byte *start_sap_header(byte *dest, const ASAP_ModuleInfo *module_info) +{ + dest = put_string(dest, "SAP\r\n"); + dest = put_text_tag(dest, "AUTHOR", module_info->author); + if (dest == NULL) + return NULL; + dest = put_text_tag(dest, "NAME", module_info->name); + if (dest == NULL) + return NULL; + dest = put_text_tag(dest, "DATE", module_info->date); + if (dest == NULL) + return NULL; + if (module_info->songs > 1) { + dest = put_dec_tag(dest, "SONGS", module_info->songs); + if (module_info->default_song > 0) + dest = put_dec_tag(dest, "DEFSONG", module_info->default_song); + } + if (module_info->channels > 1) + dest = put_string(dest, "STEREO\r\n"); + return dest; +} + +static byte *put_durations(byte *dest, const ASAP_ModuleInfo *module_info) +{ + int song; + for (song = 0; song < module_info->songs; song++) { + if (module_info->durations[song] < 0) + break; + dest = put_string(dest, "TIME "); + ASAP_DurationToString((char *) dest, module_info->durations[song]); + while (*dest != '\0') + dest++; + if (module_info->loops[song]) + dest = put_string(dest, " LOOP"); + *dest++ = '\r'; + *dest++ = '\n'; + } + return dest; +} + +static byte *put_sap_header(byte *dest, const ASAP_ModuleInfo *module_info, char type, int music, int init, int player) +{ + dest = start_sap_header(dest, module_info); + if (dest == NULL) + return NULL; + dest = put_string(dest, "TYPE "); + *dest++ = type; + *dest++ = '\r'; + *dest++ = '\n'; + if (module_info->fastplay != 312) + dest = put_dec_tag(dest, "FASTPLAY", module_info->fastplay); + dest = put_hex_tag(dest, "MUSIC", music); + dest = put_hex_tag(dest, "INIT", init); + dest = put_hex_tag(dest, "PLAYER", player); + dest = put_durations(dest, module_info); + return dest; +} + +int ASAP_SetModuleInfo(const ASAP_ModuleInfo *module_info, const byte ARRAY module, + int module_len, byte ARRAY out_module) +{ + byte *dest; + int i; + if (memcmp(module, "SAP\r\n", 5) != 0) + return -1; + dest = start_sap_header(out_module, module_info); + if (dest == NULL) + return -1; + i = 5; + while (i < module_len && module[i] != 0xff) { + if (memcmp(module + i, "AUTHOR ", 7) == 0 + || memcmp(module + i, "NAME ", 5) == 0 + || memcmp(module + i, "DATE ", 5) == 0 + || memcmp(module + i, "SONGS ", 6) == 0 + || memcmp(module + i, "DEFSONG ", 8) == 0 + || memcmp(module + i, "STEREO", 6) == 0 + || memcmp(module + i, "TIME ", 5) == 0) { + while (i < module_len && module[i++] != 0x0a); + } + else { + int b; + do { + b = module[i++]; + *dest++ = b; + } while (i < module_len && b != 0x0a); + } + } + dest = put_durations(dest, module_info); + module_len -= i; + memcpy(dest, module + i, module_len); + dest += module_len; + return dest - out_module; +} + +#define RMT_INIT 0x0c80 +#define TM2_INIT 0x1080 + +const char *ASAP_CanConvert(const char *filename, const ASAP_ModuleInfo *module_info, + const byte ARRAY module, int module_len) +{ + switch (module_info->type) { + case 'B': + if (module_info->init == 0x4f3 || module_info->init == 0xf4f3 || module_info->init == 0x4ef) + return module_info->fastplay == 156 ? "mpd" : "mpt"; + if (module_info->init == RMT_INIT) + return "rmt"; + if ((module_info->init == 0x4f5 || module_info->init == 0xf4f5 || module_info->init == 0x4f2) + || ((module_info->init == 0x4e7 || module_info->init == 0xf4e7 || module_info->init == 0x4e4) && module_info->fastplay == 156) + || ((module_info->init == 0x4e5 || module_info->init == 0xf4e5 || module_info->init == 0x4e2) && (module_info->fastplay == 104 || module_info->fastplay == 78))) + return "tmc"; + if (module_info->init == TM2_INIT) + return "tm2"; + break; + case 'C': + if (module_info->player == 0x500 || module_info->player == 0xf500) { + if (module_info->fastplay == 156) + return "dmc"; + return module[module_len - 170] == 0x1e ? "cmr" : "cmc"; + } + break; + case 'c': + case 'z': + case 'm': + case 'r': + case 't': + case 'T': + return "sap"; + default: + break; + } + return NULL; +} + +int ASAP_Convert(const char *filename, const ASAP_ModuleInfo *module_info, + const byte ARRAY module, int module_len, byte ARRAY out_module) +{ + int out_len; + byte *dest; + int addr; + int player; + static const int tmc_player[4] = { 3, -9, -10, -10 }; + static const int tmc_init[4] = { -14, -16, -17, -17 }; + switch (module_info->type) { + case 'B': + case 'C': + out_len = module[module_info->header_len + 4] + (module[module_info->header_len + 5] << 8) + - module[module_info->header_len + 2] - (module[module_info->header_len + 3] << 8) + 7; + if (out_len < 7 || module_info->header_len + out_len >= module_len) + return -1; + memcpy(out_module, module + module_info->header_len, out_len); + return out_len; + case 'c': + case 'z': + dest = put_sap_header(out_module, module_info, 'C', module_info->music, -1, module_info->player); + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + memcpy(dest, cmc_obx + 2, sizeof(cmc_obx) - 2); + if (module_info->type == 'z') + memcpy(dest + 4 + CMR_BASS_TABLE_OFFSET, cmr_bass_table, sizeof(cmr_bass_table)); + dest += sizeof(cmc_obx) - 2; + return dest - out_module; + case 'm': + if (module_info->songs != 1) { + addr = module_info->player - 17 - module_info->songs; + dest = put_sap_header(out_module, module_info, 'B', -1, module_info->player - 17, module_info->player + 3); + } + else { + addr = module_info->player - 13; + dest = put_sap_header(out_module, module_info, 'B', -1, addr, module_info->player + 3); + } + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + *dest++ = (byte) addr; + *dest++ = (byte) (addr >> 8); + *dest++ = mpt_obx[4]; + *dest++ = mpt_obx[5]; + if (module_info->songs != 1) { + memcpy(dest, module_info->song_pos, module_info->songs); + dest += module_info->songs; + *dest++ = 0x48; /* pha */ + } + *dest++ = 0xa0; /* ldy #music; + *dest++ = 0xa2; /* ldx #>music */ + *dest++ = (byte) (module_info->music >> 8); + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + *dest++ = 0x20; /* jsr player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + if (module_info->songs != 1) { + *dest++ = 0x68; /* pla */ + *dest++ = 0xa8; /* tay */ + *dest++ = 0xbe; /* ldx song2pos,y */ + *dest++ = (byte) addr; + *dest++ = (byte) (addr >> 8); + } + else { + *dest++ = 0xa2; /* ldx #0 */ + *dest++ = 0; + } + *dest++ = 0xa9; /* lda #2 */ + *dest++ = 2; + memcpy(dest, mpt_obx + 6, sizeof(mpt_obx) - 6); + dest += sizeof(mpt_obx) - 6; + return dest - out_module; + case 'r': + dest = put_sap_header(out_module, module_info, 'B', -1, RMT_INIT, module_info->player + 3); + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + *dest++ = (byte) RMT_INIT; + *dest++ = (byte) (RMT_INIT >> 8); + if (module_info->songs != 1) { + addr = RMT_INIT + 10 + module_info->songs; + *dest++ = (byte) addr; + *dest++ = (byte) (addr >> 8); + *dest++ = 0xa8; /* tay */ + *dest++ = 0xb9; /* lda song2pos,y */ + *dest++ = (byte) (RMT_INIT + 11); + *dest++ = (byte) ((RMT_INIT + 11) >> 8); + } + else { + *dest++ = (byte) (RMT_INIT + 8); + *dest++ = (byte) ((RMT_INIT + 8) >> 8); + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + } + *dest++ = 0xa2; /* ldx #music; + *dest++ = 0xa0; /* ldy #>music */ + *dest++ = (byte) (module_info->music >> 8); + *dest++ = 0x4c; /* jmp player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + if (module_info->songs != 1) { + memcpy(dest, module_info->song_pos, module_info->songs); + dest += module_info->songs; + } + if (module_info->channels == 1) { + memcpy(dest, rmt4_obx + 2, sizeof(rmt4_obx) - 2); + dest += sizeof(rmt4_obx) - 2; + } + else { + memcpy(dest, rmt8_obx + 2, sizeof(rmt8_obx) - 2); + dest += sizeof(rmt8_obx) - 2; + } + return dest - out_module; + case 't': + player = module_info->player + tmc_player[module[0x25] - 1]; + addr = player + tmc_init[module[0x25] - 1]; + if (module_info->songs != 1) + addr -= 3; + dest = put_sap_header(out_module, module_info, 'B', -1, addr, player); + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + *dest++ = (byte) addr; + *dest++ = (byte) (addr >> 8); + *dest++ = tmc_obx[4]; + *dest++ = tmc_obx[5]; + if (module_info->songs != 1) + *dest++ = 0x48; /* pha */ + *dest++ = 0xa0; /* ldy #music; + *dest++ = 0xa2; /* ldx #>music */ + *dest++ = (byte) (module_info->music >> 8); + *dest++ = 0xa9; /* lda #$70 */ + *dest++ = 0x70; + *dest++ = 0x20; /* jsr player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + if (module_info->songs != 1) { + *dest++ = 0x68; /* pla */ + *dest++ = 0xaa; /* tax */ + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + } + else { + *dest++ = 0xa9; /* lda #$60 */ + *dest++ = 0x60; + } + switch (module[0x25]) { + case 2: + *dest++ = 0x06; /* asl 0 */ + *dest++ = 0; + *dest++ = 0x4c; /* jmp player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + *dest++ = 0xa5; /* lda 0 */ + *dest++ = 0; + *dest++ = 0xe6; /* inc 0 */ + *dest++ = 0; + *dest++ = 0x4a; /* lsr @ */ + *dest++ = 0x90; /* bcc player+3 */ + *dest++ = 5; + *dest++ = 0xb0; /* bcs player+6 */ + *dest++ = 6; + break; + case 3: + case 4: + *dest++ = 0xa0; /* ldy #1 */ + *dest++ = 1; + *dest++ = 0x84; /* sty 0 */ + *dest++ = 0; + *dest++ = 0xd0; /* bne player */ + *dest++ = 10; + *dest++ = 0xc6; /* dec 0 */ + *dest++ = 0; + *dest++ = 0xd0; /* bne player+6 */ + *dest++ = 12; + *dest++ = 0xa0; /* ldy #3 */ + *dest++ = module[0x25]; + *dest++ = 0x84; /* sty 0 */ + *dest++ = 0; + *dest++ = 0xd0; /* bne player+3 */ + *dest++ = 3; + break; + default: + break; + } + memcpy(dest, tmc_obx + 6, sizeof(tmc_obx) - 6); + dest += sizeof(tmc_obx) - 6; + return dest - out_module; + case 'T': + dest = put_sap_header(out_module, module_info, 'B', -1, TM2_INIT, module_info->player + 3); + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + *dest++ = (byte) TM2_INIT; + *dest++ = (byte) (TM2_INIT >> 8); + if (module_info->songs != 1) { + *dest++ = (byte) (TM2_INIT + 16); + *dest++ = (byte) ((TM2_INIT + 16) >> 8); + *dest++ = 0x48; /* pha */ + } + else { + *dest++ = (byte) (TM2_INIT + 14); + *dest++ = (byte) ((TM2_INIT + 14) >> 8); + } + *dest++ = 0xa0; /* ldy #music; + *dest++ = 0xa2; /* ldx #>music */ + *dest++ = (byte) (module_info->music >> 8); + *dest++ = 0xa9; /* lda #$70 */ + *dest++ = 0x70; + *dest++ = 0x20; /* jsr player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + if (module_info->songs != 1) { + *dest++ = 0x68; /* pla */ + *dest++ = 0xaa; /* tax */ + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + } + else { + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + *dest++ = 0xaa; /* tax */ + } + *dest++ = 0x4c; /* jmp player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + memcpy(dest, tm2_obx + 2, sizeof(tm2_obx) - 2); + dest += sizeof(tm2_obx) - 2; + return dest - out_module; + default: + return -1; + } +} + +#endif /* !defined(JAVA) && !defined(CSHARP) */ Index: apps/plugins/asap/asap2wav.c =================================================================== --- apps/plugins/asap/asap2wav.c (revision 0) +++ apps/plugins/asap/asap2wav.c (revision 0) @@ -0,0 +1,179 @@ +/* + * asap2wav.c - converter of ASAP-supported formats to WAV files + * + * Copyright (C) 2005-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include +#include +#include + +#include "asap.h" +#include "plugin.h" + +/* This macros must always be included. Should be placed at the top by + convention, although the actual position doesn't matter */ +PLUGIN_HEADER + +/* here is a global api struct pointer. while not strictly necessary, + it's nice not to have to pass the api pointer in all function calls + in the plugin */ +const struct plugin_api* rb; + +static abool no_input_files = TRUE; +static const char *output_file = NULL; +static abool output_header = TRUE; +static int song = -1; +static abool use_16bit = TRUE; +static int duration = -1; +static int mute_mask = 0; + +#define FILENAME_MAX 255 + +/* write 16-bit word as little endian */ +static void fput16(int x, int fp) +{ + char a = x & 0xff; + char b = (x >> 8) & 0xff; + rb->write(fp,&a, 1); + rb->write(fp,&b, 1); +} + +/* write 32-bit word as little endian */ +static void fput32(int x, int fp) +{ + char a = x & 0xff; + char b= (x >> 8) & 0xff; + char c = (x >> 16) & 0xff; + char d =(x >> 24) & 0xff; + + rb->write(fp,&a, 1); + rb->write(fp,&b, 1); + rb->write(fp,&c, 1); + rb->write(fp,&d, 1); +} + +static byte module[ASAP_MODULE_MAX]; +static ASAP_State asap; +static byte buffer[8192]; + +static void process_file(const char *input_file) +{ + int fp; + + int module_len; + + int n_bytes; + + fp = rb->open(input_file, O_RDONLY); + if (fp == -1) + { + rb->splash(HZ*2,"cannot open input_file"); + return; + } + + module_len = rb->read(fp,module,sizeof(module)); + rb->close(fp); + + if (!ASAP_Load(&asap, input_file, module, module_len)) + { + rb->splash(HZ*2,"format not supported"); + return; + } + + song = asap.module_info.default_song; + + duration = asap.module_info.durations[song]; + if (duration < 0) + duration = 180 * 1000; + + ASAP_PlaySong(&asap, song, duration); + ASAP_MutePokeyChannels(&asap, mute_mask); + + if (output_file == NULL) { + static char output_default[FILENAME_MAX]; + rb->strcpy(output_default, input_file); + ASAP_ChangeExt(output_default, output_header ? "wav" : "raw"); + output_file = output_default; + } + + fp = rb->open(output_file, O_WRONLY); + if (fp == -1) + { + rb->splash(HZ*2,"could not open outputfile."); + return; + } + + if (output_header) + { + int block_size = asap.module_info.channels << use_16bit; + int bytes_per_second = ASAP_SAMPLE_RATE * block_size; + n_bytes = duration * (ASAP_SAMPLE_RATE / 100) / 10 * block_size; + rb->write(fp,"RIFF", 4); + fput32(n_bytes + 36, fp); + rb->write(fp,"WAVEfmt \x10\0\0\0\1\0", 14); + fput16(asap.module_info.channels, fp); + fput32(ASAP_SAMPLE_RATE, fp); + fput32(bytes_per_second, fp); + fput16(block_size, fp); + fput16(8 << use_16bit, fp); + rb->write(fp,"data", 4); + fput32(n_bytes, fp); + } + + do { + n_bytes = ASAP_Generate(&asap, buffer, sizeof(buffer), + use_16bit ? ASAP_FORMAT_S16_LE : ASAP_FORMAT_U8); + if (rb->write(fp,buffer, n_bytes) != n_bytes) + { + rb->close(fp); + rb->splash(HZ*2,"error writing to output_file"); + return; + } + } while (n_bytes == sizeof(buffer)); + + rb->close(fp); + output_file = NULL; + song = -1; + duration = -1; + no_input_files = FALSE; +} + + +/* this is the plugin entry point */ +enum plugin_status plugin_start(const struct plugin_api* api, const void* parameter) +{ + /* if you are using a global api pointer, don't forget to copy it! + otherwise you will get lovely "I04: IllInstr" errors... :-) */ + rb = api; + + /* now go ahead and have fun! */ + rb->splash(HZ*2, "Encoding!"); + + output_file = "/test.wav"; + use_16bit = TRUE; + process_file(parameter); + + rb->splash(HZ*2, "Finished!"); + + return PLUGIN_OK; +} + Index: apps/plugins/asap/players.h =================================================================== --- apps/plugins/asap/players.h (revision 0) +++ apps/plugins/asap/players.h (revision 0) @@ -0,0 +1,947 @@ +static const unsigned char cmc_obx[] = { + 0xFF, 0xFF, 0x00, 0x05, 0xDC, 0x0C, 0x4C, 0x0F, 0x0B, 0x4C, 0x78, 0x05, 0x4C, 0xCB, 0x07, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xE3, 0xED, 0xE3, 0xA0, 0xF0, 0xEC, 0xE1, + 0xF9, 0xE5, 0xF2, 0xA0, 0xF6, 0xA0, 0xB2, 0xAE, 0xB1, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, + 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8D, 0x6E, + 0x05, 0x8E, 0x6F, 0x05, 0x8C, 0x70, 0x05, 0x29, 0x70, 0x4A, 0x4A, 0x4A, 0xAA, 0xBD, 0x91, 0x0B, + 0x8D, 0xA9, 0x05, 0xBD, 0x92, 0x0B, 0x8D, 0xAA, 0x05, 0xA9, 0x03, 0x8D, 0x0F, 0xD2, 0xD8, 0xA5, + 0xFE, 0x48, 0xA5, 0xFF, 0x48, 0xAC, 0x70, 0x05, 0xAE, 0x6F, 0x05, 0xAD, 0x6E, 0x05, 0x20, 0xB2, + 0x05, 0x68, 0x85, 0xFF, 0x68, 0x85, 0xFE, 0x60, 0xAD, 0x76, 0x05, 0x85, 0xFE, 0xAD, 0x77, 0x05, + 0x85, 0xFF, 0xA0, 0x00, 0x8A, 0xF0, 0x1C, 0xB1, 0xFE, 0xC9, 0x8F, 0xF0, 0x04, 0xC9, 0xEF, 0xD0, + 0x0C, 0xCA, 0xD0, 0x09, 0xC8, 0xC0, 0x54, 0xB0, 0x09, 0x98, 0xAA, 0x10, 0x06, 0xC8, 0xC0, 0x54, + 0x90, 0xE5, 0x60, 0x8E, 0x68, 0x05, 0x20, 0x7B, 0x06, 0xA9, 0x00, 0xA2, 0x09, 0x9D, 0x45, 0x05, + 0xCA, 0x10, 0xFA, 0x8D, 0x67, 0x05, 0xA9, 0x01, 0x8D, 0x71, 0x05, 0xA9, 0xFF, 0x8D, 0x6A, 0x05, + 0xAD, 0x72, 0x05, 0x85, 0xFE, 0xAD, 0x73, 0x05, 0x85, 0xFF, 0xA0, 0x13, 0xB1, 0xFE, 0xAA, 0xAD, + 0x76, 0x05, 0x85, 0xFE, 0xAD, 0x77, 0x05, 0x85, 0xFF, 0xAC, 0x68, 0x05, 0xB1, 0xFE, 0xC9, 0xCF, + 0xD0, 0x0D, 0x98, 0x18, 0x69, 0x55, 0xA8, 0xB1, 0xFE, 0x30, 0x0F, 0xAA, 0x4C, 0x34, 0x06, 0xC9, + 0x8F, 0xF0, 0x07, 0xC9, 0xEF, 0xF0, 0x03, 0x88, 0x10, 0xE2, 0x8E, 0x6C, 0x05, 0x8E, 0x6D, 0x05, + 0x60, 0x29, 0x0F, 0xF0, 0xF5, 0x8E, 0xDA, 0x0A, 0x8E, 0xF0, 0x0A, 0x8E, 0xFF, 0x0A, 0x8C, 0xDB, + 0x0A, 0x8C, 0xF1, 0x0A, 0x8C, 0x00, 0x0B, 0x60, 0x8E, 0x72, 0x05, 0x86, 0xFE, 0x8C, 0x73, 0x05, + 0x84, 0xFF, 0x18, 0x8A, 0x69, 0x14, 0x8D, 0x74, 0x05, 0x98, 0x69, 0x00, 0x8D, 0x75, 0x05, 0x8E, + 0x76, 0x05, 0xC8, 0xC8, 0x8C, 0x77, 0x05, 0xA0, 0x13, 0xB1, 0xFE, 0x8D, 0x6C, 0x05, 0x8D, 0x6D, + 0x05, 0xA2, 0x08, 0xA9, 0x00, 0x8D, 0x71, 0x05, 0x9D, 0x00, 0xD2, 0xE0, 0x03, 0xB0, 0x08, 0x9D, + 0x09, 0x05, 0xA9, 0xFF, 0x9D, 0x39, 0x05, 0xCA, 0x10, 0xE9, 0xA9, 0x80, 0xA2, 0x03, 0x9D, 0x4B, + 0x05, 0xCA, 0x10, 0xFA, 0x60, 0xA9, 0x01, 0x8D, 0x71, 0x05, 0xA9, 0x00, 0xF0, 0xEE, 0x29, 0x03, + 0xC9, 0x03, 0xF0, 0xF0, 0xE0, 0x40, 0xB0, 0xEC, 0xC0, 0x1A, 0xB0, 0xE8, 0xAA, 0xA9, 0x80, 0x9D, + 0x4B, 0x05, 0xA9, 0x00, 0x9D, 0x39, 0x05, 0x9D, 0x3C, 0x05, 0x9D, 0x3F, 0x05, 0xAD, 0x6F, 0x05, + 0x9D, 0x0C, 0x05, 0xAD, 0x70, 0x05, 0x0A, 0x0A, 0x0A, 0x85, 0xFE, 0x18, 0xAD, 0x72, 0x05, 0x69, + 0x30, 0x48, 0xAD, 0x73, 0x05, 0x69, 0x01, 0xA8, 0x68, 0x18, 0x65, 0xFE, 0x9D, 0x61, 0x05, 0x98, + 0x69, 0x00, 0x9D, 0x64, 0x05, 0x18, 0xAD, 0x72, 0x05, 0x69, 0x94, 0x85, 0xFE, 0xAD, 0x73, 0x05, + 0x69, 0x00, 0x85, 0xFF, 0xAD, 0x70, 0x05, 0x0A, 0x6D, 0x70, 0x05, 0x0A, 0xA8, 0xB1, 0xFE, 0x9D, + 0x4F, 0x05, 0xC8, 0xB1, 0xFE, 0x9D, 0x52, 0x05, 0x29, 0x07, 0x8D, 0x6E, 0x05, 0xC8, 0xB1, 0xFE, + 0x9D, 0x55, 0x05, 0xC8, 0xB1, 0xFE, 0x9D, 0x58, 0x05, 0xC8, 0xB1, 0xFE, 0x9D, 0x5B, 0x05, 0xC8, + 0xB1, 0xFE, 0x9D, 0x5E, 0x05, 0xA0, 0x00, 0xAD, 0x6E, 0x05, 0xC9, 0x03, 0xD0, 0x02, 0xA0, 0x02, + 0xC9, 0x07, 0xD0, 0x02, 0xA0, 0x04, 0xB9, 0xAF, 0x0B, 0x85, 0xFE, 0xB9, 0xB0, 0x0B, 0x85, 0xFF, + 0xBD, 0x55, 0x05, 0x4A, 0x4A, 0x4A, 0x4A, 0x18, 0x6D, 0x6F, 0x05, 0x8D, 0x6F, 0x05, 0x8D, 0xC2, + 0x07, 0xA8, 0xAD, 0x6E, 0x05, 0xC9, 0x07, 0xD0, 0x0F, 0x98, 0x0A, 0xA8, 0xB1, 0xFE, 0x9D, 0x2D, + 0x05, 0xC8, 0x8C, 0x6F, 0x05, 0x4C, 0x83, 0x07, 0xB1, 0xFE, 0x9D, 0x2D, 0x05, 0xBD, 0x55, 0x05, + 0x29, 0x0F, 0x18, 0x6D, 0x6F, 0x05, 0x8D, 0x6F, 0x05, 0xAC, 0x6F, 0x05, 0xAD, 0x6E, 0x05, 0xC9, + 0x05, 0x08, 0xB1, 0xFE, 0x28, 0xF0, 0x08, 0xDD, 0x2D, 0x05, 0xD0, 0x03, 0x38, 0xE9, 0x01, 0x9D, + 0x30, 0x05, 0xBD, 0x4F, 0x05, 0x48, 0x29, 0x03, 0xA8, 0xB9, 0xB5, 0x0B, 0x9D, 0x36, 0x05, 0x68, + 0x4A, 0x4A, 0x4A, 0x4A, 0xA0, 0x3E, 0xC9, 0x0F, 0xF0, 0x10, 0xA0, 0x37, 0xC9, 0x0E, 0xF0, 0x0A, + 0xA0, 0x30, 0xC9, 0x0D, 0xF0, 0x04, 0x18, 0x69, 0x00, 0xA8, 0xB9, 0xB9, 0x0B, 0x9D, 0x33, 0x05, + 0x60, 0xD8, 0xA5, 0xFC, 0x48, 0xA5, 0xFD, 0x48, 0xA5, 0xFE, 0x48, 0xA5, 0xFF, 0x48, 0xAD, 0x71, + 0x05, 0xD0, 0x03, 0x4C, 0x02, 0x0B, 0xAD, 0x4E, 0x05, 0xF0, 0x03, 0x4C, 0x6B, 0x09, 0xAD, 0x6C, + 0x05, 0xCD, 0x6D, 0x05, 0xF0, 0x03, 0x4C, 0x58, 0x09, 0xAD, 0x67, 0x05, 0xF0, 0x03, 0x4C, 0xDC, + 0x08, 0xA2, 0x02, 0xBC, 0x4B, 0x05, 0x30, 0x03, 0x9D, 0x4B, 0x05, 0x9D, 0x45, 0x05, 0xCA, 0x10, + 0xF2, 0xAD, 0x76, 0x05, 0x85, 0xFC, 0xAD, 0x77, 0x05, 0x85, 0xFD, 0xAC, 0x68, 0x05, 0x84, 0xFE, + 0xCC, 0x6A, 0x05, 0xD0, 0x19, 0xAD, 0x6B, 0x05, 0xF0, 0x14, 0xAD, 0x68, 0x05, 0xAC, 0x69, 0x05, + 0x8C, 0x68, 0x05, 0xCE, 0x6B, 0x05, 0xD0, 0xE8, 0x8D, 0x68, 0x05, 0xA8, 0x10, 0xE2, 0xA2, 0x00, + 0xB1, 0xFC, 0xC9, 0xFE, 0xD0, 0x0E, 0xAC, 0x68, 0x05, 0xC8, 0xC4, 0xFE, 0xF0, 0x43, 0x8C, 0x68, + 0x05, 0x4C, 0x1A, 0x08, 0x9D, 0x42, 0x05, 0x18, 0x98, 0x69, 0x55, 0xA8, 0xE8, 0xE0, 0x03, 0x90, + 0xDF, 0xAC, 0x68, 0x05, 0xB1, 0xFC, 0x10, 0x7A, 0xC9, 0xFF, 0xF0, 0x76, 0x4A, 0x4A, 0x4A, 0x29, + 0x0E, 0xAA, 0xBD, 0xA1, 0x0B, 0x8D, 0x7E, 0x08, 0xBD, 0xA2, 0x0B, 0x8D, 0x7F, 0x08, 0xAD, 0x43, + 0x05, 0x85, 0xFF, 0x20, 0x93, 0x08, 0x8C, 0x68, 0x05, 0xC0, 0x55, 0xB0, 0x04, 0xC4, 0xFE, 0xD0, + 0x8F, 0xA4, 0xFE, 0x8C, 0x68, 0x05, 0x4C, 0x02, 0x0B, 0x20, 0x94, 0x06, 0xA0, 0xFF, 0x60, 0x30, + 0xFB, 0xA8, 0x60, 0x30, 0xF7, 0x38, 0x98, 0xE5, 0xFF, 0xA8, 0x60, 0x30, 0xEF, 0x18, 0x98, 0x65, + 0xFF, 0xA8, 0x60, 0x30, 0xE7, 0x8D, 0x6C, 0x05, 0x8D, 0x6D, 0x05, 0xC8, 0x60, 0x30, 0xDD, 0xAD, + 0x44, 0x05, 0x30, 0xD8, 0x8D, 0x6B, 0x05, 0xC8, 0x8C, 0x69, 0x05, 0x18, 0x98, 0x65, 0xFF, 0x8D, + 0x6A, 0x05, 0x60, 0x88, 0x30, 0x0A, 0xB1, 0xFC, 0xC9, 0x8F, 0xF0, 0x04, 0xC9, 0xEF, 0xD0, 0xF3, + 0xC8, 0x60, 0xA2, 0x02, 0xBD, 0x48, 0x05, 0xF0, 0x05, 0xDE, 0x48, 0x05, 0x10, 0x63, 0xBD, 0x4B, + 0x05, 0xD0, 0x5E, 0xBC, 0x42, 0x05, 0xC0, 0x40, 0xB0, 0x57, 0xAD, 0x74, 0x05, 0x85, 0xFC, 0xAD, + 0x75, 0x05, 0x85, 0xFD, 0xB1, 0xFC, 0x85, 0xFE, 0x18, 0x98, 0x69, 0x40, 0xA8, 0xB1, 0xFC, 0x85, + 0xFF, 0x25, 0xFE, 0xC9, 0xFF, 0xF0, 0x3A, 0xBC, 0x45, 0x05, 0xB1, 0xFE, 0x29, 0xC0, 0xD0, 0x0C, + 0xB1, 0xFE, 0x29, 0x3F, 0x9D, 0x0F, 0x05, 0xFE, 0x45, 0x05, 0x10, 0xEB, 0xC9, 0x40, 0xD0, 0x13, + 0xB1, 0xFE, 0x29, 0x3F, 0x8D, 0x6F, 0x05, 0xBD, 0x0F, 0x05, 0x8D, 0x70, 0x05, 0x20, 0xBC, 0x06, + 0x4C, 0x48, 0x09, 0xC9, 0x80, 0xD0, 0x0A, 0xB1, 0xFE, 0x29, 0x3F, 0x9D, 0x48, 0x05, 0xFE, 0x45, + 0x05, 0xCA, 0x10, 0x90, 0xAE, 0x67, 0x05, 0xE8, 0x8A, 0x29, 0x3F, 0x8D, 0x67, 0x05, 0xCE, 0x6D, + 0x05, 0xD0, 0x0E, 0xAD, 0x6C, 0x05, 0x8D, 0x6D, 0x05, 0xAD, 0x67, 0x05, 0xD0, 0x03, 0xEE, 0x68, + 0x05, 0xAC, 0x30, 0x05, 0xAD, 0x52, 0x05, 0x29, 0x07, 0xC9, 0x05, 0xF0, 0x04, 0xC9, 0x06, 0xD0, + 0x01, 0x88, 0x8C, 0x27, 0x05, 0xA0, 0x00, 0xC9, 0x05, 0xF0, 0x04, 0xC9, 0x06, 0xD0, 0x02, 0xA0, + 0x02, 0xC9, 0x07, 0xD0, 0x02, 0xA0, 0x28, 0x8C, 0x2C, 0x05, 0xA2, 0x02, 0xBD, 0x52, 0x05, 0x29, + 0xE0, 0x9D, 0x28, 0x05, 0xBD, 0x61, 0x05, 0x85, 0xFC, 0xBD, 0x64, 0x05, 0x85, 0xFD, 0xBD, 0x39, + 0x05, 0xC9, 0xFF, 0xF0, 0x36, 0xC9, 0x0F, 0xD0, 0x20, 0xBD, 0x3F, 0x05, 0xF0, 0x2D, 0xDE, 0x3F, + 0x05, 0xBD, 0x3F, 0x05, 0xD0, 0x25, 0xBC, 0x09, 0x05, 0xF0, 0x01, 0x88, 0x98, 0x9D, 0x09, 0x05, + 0xBD, 0x58, 0x05, 0x9D, 0x3F, 0x05, 0x4C, 0xE5, 0x09, 0xBD, 0x39, 0x05, 0x4A, 0xA8, 0xB1, 0xFC, + 0x90, 0x04, 0x4A, 0x4A, 0x4A, 0x4A, 0x29, 0x0F, 0x9D, 0x09, 0x05, 0xBC, 0x2D, 0x05, 0xBD, 0x52, + 0x05, 0x29, 0x07, 0xC9, 0x01, 0xD0, 0x1F, 0x88, 0x98, 0xC8, 0xDD, 0x30, 0x05, 0x08, 0xA9, 0x01, + 0x28, 0xD0, 0x02, 0x0A, 0x0A, 0x3D, 0x3C, 0x05, 0xF0, 0x0C, 0xBC, 0x30, 0x05, 0xC0, 0xFF, 0xD0, + 0x05, 0xA9, 0x00, 0x9D, 0x09, 0x05, 0x98, 0x9D, 0x24, 0x05, 0xA9, 0x01, 0x8D, 0x6E, 0x05, 0xBD, + 0x39, 0x05, 0xC9, 0x0F, 0xF0, 0x38, 0x29, 0x07, 0xA8, 0xB9, 0xCD, 0x0C, 0x85, 0xFE, 0xBD, 0x39, + 0x05, 0x29, 0x08, 0x08, 0x8A, 0x28, 0x18, 0xF0, 0x02, 0x69, 0x03, 0xA8, 0xB9, 0x5B, 0x05, 0x25, + 0xFE, 0xF0, 0x1B, 0xBD, 0x33, 0x05, 0x9D, 0x24, 0x05, 0x8E, 0x6E, 0x05, 0xCA, 0x10, 0x08, 0x8D, + 0x27, 0x05, 0xA9, 0x00, 0x8D, 0x2C, 0x05, 0xE8, 0xBD, 0x36, 0x05, 0x9D, 0x28, 0x05, 0xBD, 0x39, + 0x05, 0x29, 0x0F, 0xC9, 0x0F, 0xF0, 0x10, 0xFE, 0x39, 0x05, 0xBD, 0x39, 0x05, 0xC9, 0x0F, 0xD0, + 0x06, 0xBD, 0x58, 0x05, 0x9D, 0x3F, 0x05, 0xBD, 0x4B, 0x05, 0x10, 0x0A, 0xBD, 0x09, 0x05, 0xD0, + 0x05, 0xA9, 0x40, 0x9D, 0x4B, 0x05, 0xFE, 0x3C, 0x05, 0xA0, 0x00, 0xBD, 0x52, 0x05, 0x4A, 0x4A, + 0x4A, 0x4A, 0x90, 0x01, 0x88, 0x4A, 0x90, 0x01, 0xC8, 0x18, 0x98, 0x7D, 0x2D, 0x05, 0x9D, 0x2D, + 0x05, 0xBD, 0x30, 0x05, 0xC9, 0xFF, 0xD0, 0x02, 0xA0, 0x00, 0x18, 0x98, 0x7D, 0x30, 0x05, 0x9D, + 0x30, 0x05, 0xCA, 0x30, 0x03, 0x4C, 0x96, 0x09, 0xAD, 0x28, 0x05, 0x8D, 0x2B, 0x05, 0xAD, 0x52, + 0x05, 0x29, 0x07, 0xAA, 0xA0, 0x03, 0xAD, 0x6E, 0x05, 0xF0, 0x03, 0xBC, 0xD5, 0x0C, 0x98, 0x48, + 0xB9, 0xB9, 0x0C, 0x08, 0x29, 0x7F, 0xAA, 0x98, 0x29, 0x03, 0x0A, 0xA8, 0xBD, 0x24, 0x05, 0x99, + 0x00, 0xD2, 0xC8, 0xBD, 0x09, 0x05, 0xE0, 0x03, 0xD0, 0x03, 0xAD, 0x09, 0x05, 0x1D, 0x28, 0x05, + 0x28, 0x10, 0x02, 0xA9, 0x00, 0x99, 0x00, 0xD2, 0x68, 0xA8, 0x88, 0x29, 0x03, 0xD0, 0xCF, 0xA0, + 0x08, 0xAD, 0x2C, 0x05, 0x99, 0x00, 0xD2, 0x18, 0x68, 0x85, 0xFF, 0x68, 0x85, 0xFE, 0x68, 0x85, + 0xFD, 0x68, 0x85, 0xFC, 0x60, 0x68, 0xAA, 0xF0, 0x4E, 0xC9, 0x02, 0xF0, 0x06, 0x68, 0x68, 0xCA, + 0xD0, 0xFB, 0x60, 0xA5, 0x14, 0xC5, 0x14, 0xF0, 0xFC, 0xAD, 0x24, 0x02, 0xC9, 0x86, 0xD0, 0x07, + 0xAD, 0x25, 0x02, 0xC9, 0x0B, 0xF0, 0xE6, 0xAD, 0x24, 0x02, 0x8D, 0x8F, 0x0B, 0xAD, 0x25, 0x02, + 0x8D, 0x90, 0x0B, 0xA9, 0x86, 0x8D, 0x24, 0x02, 0xA9, 0x0B, 0x8D, 0x25, 0x02, 0x68, 0x68, 0xF0, + 0x03, 0x38, 0xE9, 0x01, 0x8D, 0x5D, 0x0B, 0x68, 0xA8, 0x68, 0xAA, 0xA9, 0x70, 0x20, 0x78, 0x05, + 0xA9, 0x00, 0xA2, 0x00, 0x4C, 0x78, 0x05, 0xA5, 0x14, 0xC5, 0x14, 0xF0, 0xFC, 0xAD, 0x24, 0x02, + 0xC9, 0x86, 0xD0, 0xAE, 0xAD, 0x25, 0x02, 0xC9, 0x0B, 0xD0, 0xA7, 0xAD, 0x8F, 0x0B, 0x8D, 0x24, + 0x02, 0xAD, 0x90, 0x0B, 0x8D, 0x25, 0x02, 0xA9, 0x40, 0x4C, 0x78, 0x05, 0x20, 0xCB, 0x07, 0x90, + 0x03, 0x20, 0x75, 0x0B, 0x4C, 0xFF, 0xFF, 0xB2, 0x05, 0xDD, 0x05, 0xA8, 0x06, 0x3B, 0x06, 0x7B, + 0x06, 0x94, 0x06, 0x9F, 0x06, 0x52, 0x06, 0x93, 0x08, 0x99, 0x08, 0x9D, 0x08, 0xA5, 0x08, 0xAD, + 0x08, 0xB7, 0x08, 0xCD, 0x08, 0xB9, 0x0B, 0xFA, 0x0B, 0x3B, 0x0C, 0x80, 0xA0, 0x20, 0x40, 0xFF, + 0xF1, 0xE4, 0xD7, 0xCB, 0xC0, 0xB5, 0xAA, 0xA1, 0x98, 0x8F, 0x87, 0x7F, 0x78, 0x72, 0x6B, 0x65, + 0x5F, 0x5A, 0x55, 0x50, 0x4B, 0x47, 0x43, 0x3F, 0x3C, 0x38, 0x35, 0x32, 0x2F, 0x2C, 0x2A, 0x27, + 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, + 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xF2, 0xE9, 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, + 0x7A, 0x71, 0x6B, 0x65, 0x5F, 0x00, 0x56, 0x50, 0x67, 0x60, 0x5A, 0x55, 0x51, 0x4C, 0x48, 0x43, + 0x3F, 0x3D, 0x39, 0x34, 0x33, 0x39, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x00, 0x00, + 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, + 0x00, 0x38, 0x0B, 0x8C, 0x0A, 0x00, 0x0A, 0x6A, 0x09, 0xE8, 0x08, 0x6A, 0x08, 0xEF, 0x07, 0x80, + 0x07, 0x08, 0x07, 0xAE, 0x06, 0x46, 0x06, 0xE6, 0x05, 0x95, 0x05, 0x41, 0x05, 0xF6, 0x04, 0xB0, + 0x04, 0x6E, 0x04, 0x30, 0x04, 0xF6, 0x03, 0xBB, 0x03, 0x84, 0x03, 0x52, 0x03, 0x22, 0x03, 0xF4, + 0x02, 0xC8, 0x02, 0xA0, 0x02, 0x7A, 0x02, 0x55, 0x02, 0x34, 0x02, 0x14, 0x02, 0xF5, 0x01, 0xD8, + 0x01, 0xBD, 0x01, 0xA4, 0x01, 0x8D, 0x01, 0x77, 0x01, 0x60, 0x01, 0x4E, 0x01, 0x38, 0x01, 0x27, + 0x01, 0x15, 0x01, 0x06, 0x01, 0xF7, 0x00, 0xE8, 0x00, 0xDB, 0x00, 0xCF, 0x00, 0xC3, 0x00, 0xB8, + 0x00, 0xAC, 0x00, 0xA2, 0x00, 0x9A, 0x00, 0x90, 0x00, 0x88, 0x00, 0x7F, 0x00, 0x78, 0x00, 0x70, + 0x00, 0x6A, 0x00, 0x64, 0x00, 0x5E, 0x00, 0x57, 0x00, 0x52, 0x00, 0x32, 0x00, 0x0A, 0x00, 0x00, + 0x01, 0x02, 0x83, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x02, 0x83, 0x01, 0x00, 0x02, 0x03, 0x01, + 0x02, 0x80, 0x03, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x03, 0x03, 0x03, 0x03, 0x07, + 0x0B, 0x0F, 0x13 +}; +static const unsigned char mpt_obx[] = { + 0xFF, 0xFF, 0x00, 0x05, 0xB2, 0x0D, 0x4C, 0xCD, 0x0B, 0xAD, 0x2E, 0x07, 0xD0, 0x01, 0x60, 0xA9, + 0x00, 0x8D, 0x1C, 0x0E, 0xEE, 0x1D, 0x0E, 0xAD, 0x17, 0x0E, 0xCD, 0xBB, 0x0D, 0x90, 0x50, 0xCE, + 0x15, 0x0E, 0xF0, 0x03, 0x4C, 0xC5, 0x05, 0xA2, 0x00, 0x8E, 0x17, 0x0E, 0xA9, 0x00, 0x9D, 0xED, + 0x0D, 0x9D, 0xF5, 0x0D, 0xBD, 0xB3, 0x0D, 0x85, 0xEC, 0xBD, 0xB7, 0x0D, 0x85, 0xED, 0xAC, 0x16, + 0x0E, 0xB1, 0xEC, 0xC8, 0xC9, 0xFF, 0xF0, 0x07, 0xC9, 0xFE, 0xD0, 0x0F, 0x4C, 0x2A, 0x0C, 0xB1, + 0xEC, 0x30, 0xF9, 0x0A, 0xA8, 0x8C, 0x16, 0x0E, 0x4C, 0x3B, 0x05, 0x9D, 0xE9, 0x0D, 0xB1, 0xEC, + 0x9D, 0xD5, 0x0D, 0xE8, 0xE0, 0x04, 0xD0, 0xC4, 0xC8, 0x8C, 0x16, 0x0E, 0x4C, 0xC5, 0x05, 0xCE, + 0x15, 0x0E, 0x10, 0x57, 0xAD, 0xBC, 0x0D, 0x8D, 0x15, 0x0E, 0xA2, 0x03, 0xDE, 0xF5, 0x0D, 0x10, + 0x44, 0xBD, 0xE9, 0x0D, 0x0A, 0xA8, 0xB9, 0xFF, 0xFF, 0x85, 0xEC, 0xC8, 0xB9, 0xFF, 0xFF, 0x85, + 0xED, 0x05, 0xEC, 0xF0, 0x30, 0xBD, 0xED, 0x0D, 0x8D, 0x1F, 0x0E, 0x20, 0x3E, 0x07, 0xAC, 0x1F, + 0x0E, 0xC8, 0x98, 0x9D, 0xED, 0x0D, 0xBD, 0xF1, 0x0D, 0x9D, 0xF5, 0x0D, 0xE0, 0x02, 0xD0, 0x15, + 0xBD, 0xC5, 0x0D, 0x49, 0x0F, 0x0A, 0x0A, 0x0A, 0x0A, 0x69, 0x45, 0x8D, 0xA1, 0x0D, 0xA9, 0x0A, + 0x69, 0x00, 0x8D, 0xA2, 0x0D, 0xCA, 0x10, 0xB4, 0xEE, 0x17, 0x0E, 0xA2, 0x01, 0xAD, 0x1B, 0x0E, + 0xC9, 0x02, 0xF0, 0x02, 0xA2, 0x03, 0xAD, 0x1B, 0x0E, 0xC9, 0x02, 0xD0, 0x05, 0xEC, 0x19, 0x0E, + 0xF0, 0x03, 0x4C, 0x76, 0x06, 0xB5, 0xF0, 0x3D, 0x72, 0x06, 0xF0, 0x12, 0xA0, 0x28, 0xB1, 0xEC, + 0x18, 0x7D, 0xE1, 0x0D, 0x20, 0x75, 0x09, 0x38, 0x7D, 0x01, 0x0E, 0x9D, 0xCB, 0x0D, 0xCA, 0x10, + 0xD5, 0xA9, 0x03, 0x8D, 0x0F, 0xD2, 0xA5, 0xF1, 0x29, 0x10, 0xF0, 0x0F, 0xAC, 0xE2, 0x0D, 0xB9, + 0xC6, 0x09, 0x8D, 0xC9, 0x0D, 0xB9, 0x05, 0x0A, 0x8D, 0xCA, 0x0D, 0xAD, 0xC9, 0x0D, 0x8D, 0x00, + 0xD2, 0xAD, 0xCA, 0x0D, 0x8D, 0x02, 0xD2, 0xAD, 0xCB, 0x0D, 0x8D, 0x04, 0xD2, 0xAD, 0xCC, 0x0D, + 0x8D, 0x06, 0xD2, 0xAD, 0xC1, 0x0D, 0xA2, 0xFF, 0xAC, 0x1B, 0x0E, 0xC0, 0x01, 0xD0, 0x05, 0xAE, + 0x19, 0x0E, 0xF0, 0x03, 0x8D, 0x01, 0xD2, 0xAD, 0xC2, 0x0D, 0xE0, 0x01, 0xF0, 0x03, 0x8D, 0x03, + 0xD2, 0xC0, 0x02, 0xF0, 0x14, 0xAD, 0xC3, 0x0D, 0xE0, 0x02, 0xF0, 0x03, 0x8D, 0x05, 0xD2, 0xAD, + 0xC4, 0x0D, 0xE0, 0x03, 0xF0, 0x03, 0x8D, 0x07, 0xD2, 0xA5, 0xF0, 0x05, 0xF1, 0x05, 0xF2, 0x05, + 0xF3, 0x0D, 0x1C, 0x0E, 0x8D, 0x08, 0xD2, 0x60, 0x04, 0x02, 0x00, 0x00, 0xBD, 0xD9, 0x0D, 0x85, + 0xEC, 0xBD, 0xDD, 0x0D, 0x85, 0xED, 0x05, 0xEC, 0xD0, 0x08, 0x9D, 0xC1, 0x0D, 0x95, 0xF0, 0x4C, + 0xF8, 0x05, 0xB4, 0xF4, 0xC0, 0x20, 0xF0, 0x42, 0xB1, 0xEC, 0x38, 0xFD, 0xC5, 0x0D, 0x2C, 0x3A, + 0x07, 0xF0, 0x02, 0x29, 0xF0, 0x9D, 0xC1, 0x0D, 0xC8, 0xB1, 0xEC, 0x8D, 0x1E, 0x0E, 0xC8, 0x94, + 0xF4, 0x29, 0x07, 0xF0, 0x3C, 0xA8, 0xB9, 0x7E, 0x09, 0x8D, 0xCB, 0x06, 0xB9, 0x85, 0x09, 0x8D, + 0xCC, 0x06, 0xAD, 0x1E, 0x0E, 0x4A, 0x4A, 0x4A, 0x4A, 0x4A, 0x09, 0x28, 0xA8, 0xB1, 0xEC, 0x18, + 0x20, 0xFF, 0xFF, 0xA9, 0x00, 0x95, 0xF0, 0x4C, 0xF8, 0x05, 0xBD, 0x09, 0x0E, 0xF0, 0x12, 0xDE, + 0x0D, 0x0E, 0xD0, 0x0D, 0x9D, 0x0D, 0x0E, 0xBD, 0xC1, 0x0D, 0x29, 0x0F, 0xF0, 0x03, 0xDE, 0xC1, + 0x0D, 0xA0, 0x23, 0xB1, 0xEC, 0x95, 0xF0, 0xBD, 0x11, 0x0E, 0x18, 0x69, 0x25, 0xA8, 0x29, 0x03, + 0x9D, 0x11, 0x0E, 0x88, 0xB1, 0xEC, 0x7D, 0xD1, 0x0D, 0x9D, 0xE1, 0x0D, 0x20, 0x77, 0x09, 0x9D, + 0xC9, 0x0D, 0xBD, 0x05, 0x0E, 0xF0, 0x06, 0xDE, 0x05, 0x0E, 0x4C, 0xDF, 0x05, 0xBD, 0xBD, 0x0D, + 0x8D, 0x1E, 0x07, 0x10, 0xFE, 0x4C, 0xC2, 0x08, 0x00, 0x4C, 0xE5, 0x08, 0x00, 0x4C, 0xFB, 0x08, + 0x00, 0x4C, 0x15, 0x09, 0x00, 0x4C, 0x25, 0x09, 0x00, 0x4C, 0x38, 0x09, 0x00, 0x4C, 0x42, 0x09, + 0x10, 0x4C, 0x48, 0x09, 0xA9, 0x00, 0x9D, 0xC5, 0x0D, 0xAC, 0x1F, 0x0E, 0x88, 0xC8, 0xB1, 0xEC, + 0xC9, 0xFE, 0xD0, 0x04, 0x8C, 0x1F, 0x0E, 0x60, 0xC9, 0xE0, 0x90, 0x08, 0xAD, 0xBB, 0x0D, 0x8D, + 0x17, 0x0E, 0xD0, 0xE9, 0xC9, 0xD0, 0x90, 0x0A, 0x29, 0x0F, 0x8D, 0xBC, 0x0D, 0x8D, 0x15, 0x0E, + 0x10, 0xDB, 0xC9, 0xC0, 0x90, 0x09, 0x29, 0x0F, 0x49, 0x0F, 0x9D, 0xC5, 0x0D, 0x10, 0xCE, 0xC9, + 0x80, 0x90, 0x07, 0x29, 0x3F, 0x9D, 0xF1, 0x0D, 0x10, 0xC3, 0xC9, 0x40, 0x90, 0x1B, 0xC8, 0x8C, + 0x1F, 0x0E, 0x29, 0x1F, 0x9D, 0xE5, 0x0D, 0x0A, 0xA8, 0xB9, 0xFF, 0xFF, 0x9D, 0xD9, 0x0D, 0xC8, + 0xB9, 0xFF, 0xFF, 0x9D, 0xDD, 0x0D, 0x4C, 0x3E, 0x07, 0x8C, 0x1F, 0x0E, 0x8D, 0x1E, 0x0E, 0x18, + 0x7D, 0xD5, 0x0D, 0x9D, 0xD1, 0x0D, 0xAD, 0x1B, 0x0E, 0xF0, 0x42, 0xC9, 0x02, 0xF0, 0x3A, 0xBD, + 0xE5, 0x0D, 0xC9, 0x1F, 0xD0, 0x37, 0xAD, 0x1E, 0x0E, 0x38, 0xE9, 0x01, 0x29, 0x0F, 0xA8, 0xB1, + 0xFE, 0x85, 0xFD, 0x98, 0x09, 0x10, 0xA8, 0xB1, 0xFE, 0x85, 0xF8, 0xA0, 0x01, 0x05, 0xFD, 0xD0, + 0x02, 0xA0, 0x00, 0x8C, 0x1A, 0x0E, 0xA9, 0x00, 0x85, 0xFC, 0x9D, 0xD9, 0x0D, 0x9D, 0xDD, 0x0D, + 0x8A, 0x0A, 0x8D, 0x18, 0x0E, 0x8E, 0x19, 0x0E, 0x60, 0xE0, 0x02, 0xB0, 0x63, 0xBD, 0xD9, 0x0D, + 0x85, 0xEE, 0xBD, 0xDD, 0x0D, 0x85, 0xEF, 0x05, 0xEE, 0xF0, 0x4A, 0xA0, 0x20, 0xB1, 0xEE, 0x29, + 0x0F, 0x9D, 0xF9, 0x0D, 0xB1, 0xEE, 0x29, 0x70, 0x4A, 0x4A, 0x9D, 0xBD, 0x0D, 0xC8, 0xB1, 0xEE, + 0x0A, 0x0A, 0x48, 0x29, 0x3F, 0x9D, 0x05, 0x0E, 0x68, 0x29, 0xC0, 0x9D, 0xCD, 0x0D, 0xC8, 0xB1, + 0xEE, 0x9D, 0x09, 0x0E, 0x9D, 0x0D, 0x0E, 0xA9, 0x00, 0x95, 0xF4, 0x9D, 0x11, 0x0E, 0x9D, 0xFD, + 0x0D, 0x9D, 0x01, 0x0E, 0xBD, 0xD1, 0x0D, 0x9D, 0xE1, 0x0D, 0x20, 0x75, 0x09, 0x9D, 0xC9, 0x0D, + 0xEC, 0x19, 0x0E, 0xF0, 0x01, 0x60, 0xA0, 0xFF, 0x8C, 0x19, 0x0E, 0xC8, 0x8C, 0x1A, 0x0E, 0x60, + 0xE0, 0x02, 0xD0, 0x33, 0xAC, 0xD3, 0x0D, 0xB9, 0x45, 0x0B, 0x8D, 0x79, 0x0D, 0xB9, 0x81, 0x0B, + 0x8D, 0x7F, 0x0D, 0xA9, 0x00, 0x85, 0xF9, 0x85, 0xFA, 0xAD, 0xE7, 0x0D, 0x29, 0x0F, 0xA8, 0xB1, + 0xFE, 0x85, 0xFB, 0x98, 0x09, 0x10, 0xA8, 0xB1, 0xFE, 0x8D, 0x89, 0x0D, 0x05, 0xFB, 0xD0, 0x06, + 0x8D, 0x79, 0x0D, 0x8D, 0x7F, 0x0D, 0x60, 0xAD, 0xE8, 0x0D, 0x29, 0x0F, 0xA8, 0xB1, 0xFE, 0x85, + 0xFD, 0x98, 0x09, 0x10, 0xA8, 0xB1, 0xFE, 0x05, 0xFD, 0xF0, 0x0F, 0xB1, 0xFE, 0x38, 0xE5, 0xFD, + 0x85, 0xF8, 0xA9, 0x00, 0x85, 0xFC, 0xA9, 0x8D, 0xD0, 0x02, 0xA9, 0xAD, 0x8D, 0x61, 0x0D, 0x8D, + 0x38, 0x0D, 0xA9, 0x18, 0x8D, 0x07, 0xD2, 0x60, 0xAD, 0x1D, 0x0E, 0x29, 0x07, 0x4A, 0x4A, 0x90, + 0x12, 0xD0, 0x18, 0xBD, 0xF9, 0x0D, 0x18, 0x9D, 0x01, 0x0E, 0x7D, 0xC9, 0x0D, 0x9D, 0xC9, 0x0D, + 0x4C, 0xDF, 0x05, 0xA9, 0x00, 0x9D, 0x01, 0x0E, 0x4C, 0xDF, 0x05, 0xBD, 0xC9, 0x0D, 0x38, 0xFD, + 0xF9, 0x0D, 0x9D, 0xC9, 0x0D, 0x38, 0xA9, 0x00, 0xFD, 0xF9, 0x0D, 0x9D, 0x01, 0x0E, 0x4C, 0xDF, + 0x05, 0xBD, 0xFD, 0x0D, 0x18, 0x9D, 0x01, 0x0E, 0x7D, 0xC9, 0x0D, 0x9D, 0xC9, 0x0D, 0x18, 0xBD, + 0xFD, 0x0D, 0x7D, 0xF9, 0x0D, 0x9D, 0xFD, 0x0D, 0x4C, 0xDF, 0x05, 0xBD, 0xE1, 0x0D, 0x38, 0xFD, + 0xFD, 0x0D, 0x9D, 0xE1, 0x0D, 0x20, 0x75, 0x09, 0x4C, 0x05, 0x09, 0xA9, 0x00, 0x38, 0xFD, 0xFD, + 0x0D, 0x9D, 0x01, 0x0E, 0xBD, 0xC9, 0x0D, 0x38, 0xFD, 0xFD, 0x0D, 0x4C, 0x05, 0x09, 0xBD, 0xE1, + 0x0D, 0x18, 0x7D, 0xFD, 0x0D, 0x4C, 0x1C, 0x09, 0x20, 0x55, 0x09, 0x4C, 0xD0, 0x08, 0x20, 0x55, + 0x09, 0x18, 0x7D, 0xE1, 0x0D, 0x20, 0x9B, 0x09, 0x4C, 0xDF, 0x05, 0xBC, 0xFD, 0x0D, 0xBD, 0xF9, + 0x0D, 0x30, 0x02, 0xC8, 0xC8, 0x88, 0x98, 0x9D, 0xFD, 0x0D, 0xDD, 0xF9, 0x0D, 0xD0, 0x08, 0xBD, + 0xF9, 0x0D, 0x49, 0xFF, 0x9D, 0xF9, 0x0D, 0xBD, 0xFD, 0x0D, 0x60, 0x29, 0x3F, 0x1D, 0xCD, 0x0D, + 0xA8, 0xB9, 0xFF, 0xFF, 0x60, 0x94, 0x91, 0x98, 0xA5, 0xAD, 0xB4, 0xC0, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x40, 0x00, 0x20, 0x00, 0x7D, 0xC9, 0x0D, 0x9D, 0xC9, 0x0D, 0x60, 0x7D, 0xD1, + 0x0D, 0x9D, 0xE1, 0x0D, 0x20, 0x75, 0x09, 0x9D, 0xC9, 0x0D, 0x60, 0x9D, 0xC9, 0x0D, 0xBD, 0x8D, + 0x09, 0x10, 0x0C, 0x9D, 0xC9, 0x0D, 0xA9, 0x80, 0xD0, 0x05, 0x9D, 0xC9, 0x0D, 0xA9, 0x01, 0x0D, + 0x1C, 0x0E, 0x8D, 0x1C, 0x0E, 0x60, 0x2D, 0x0A, 0xD2, 0x9D, 0xC9, 0x0D, 0x60, 0xF2, 0x33, 0x96, + 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, 0xEF, 0x80, 0x08, 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, + 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, 0x22, 0xF4, 0xC8, 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, + 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, 0x38, 0x27, 0x15, 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, + 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, 0x78, 0x70, 0x6A, 0x64, 0x5E, 0x0D, 0x0D, 0x0C, 0x0B, + 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, + 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x16, 0x16, 0x17, 0x17, 0x17, + 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x1A, 0x15, 0x15, 0x16, 0x16, 0x16, + 0x17, 0x17, 0x18, 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1A, 0x1B, 0x14, 0x15, 0x15, 0x16, 0x16, + 0x17, 0x17, 0x18, 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B, 0x14, 0x14, 0x15, 0x15, 0x16, + 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B, 0x1C, 0x13, 0x14, 0x14, 0x15, 0x16, + 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1C, 0x13, 0x13, 0x14, 0x15, 0x15, + 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1B, 0x1B, 0x1C, 0x1D, 0x12, 0x13, 0x14, 0x14, 0x15, + 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1B, 0x1C, 0x1C, 0x1D, 0x12, 0x13, 0x13, 0x14, 0x15, + 0x16, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1D, 0x1D, 0x12, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1B, 0x1C, 0x1D, 0x1E, 0x11, 0x12, 0x13, 0x14, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1C, 0x1D, 0x1E, 0x11, 0x12, 0x13, 0x13, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x11, 0x12, 0x12, 0x13, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1E, 0x10, 0x11, 0x12, 0x13, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x22, 0x24, 0x26, 0x29, + 0x2B, 0x2E, 0x30, 0x33, 0x37, 0x3A, 0x3D, 0x41, 0x45, 0x49, 0x4D, 0x52, 0x57, 0x5C, 0x61, 0x67, + 0x6E, 0x74, 0x7B, 0x82, 0x8A, 0x92, 0x9B, 0xA4, 0xAE, 0xB8, 0xC3, 0xCF, 0xDC, 0xE9, 0xF6, 0x05, + 0x15, 0x25, 0x37, 0x49, 0x5D, 0x71, 0x87, 0x9F, 0xB8, 0xD2, 0xED, 0x0B, 0x2A, 0x4B, 0x6E, 0x93, + 0xBA, 0xE3, 0x0F, 0x3E, 0x70, 0xA4, 0xDB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x03, 0x03, 0xE5, 0x2A, 0x40, 0x59, 0x64, 0xEE, 0x08, 0xA6, 0x0B, 0x0C, 0x0C, 0x0C, 0x0C, + 0x0C, 0x0D, 0x0D, 0x8E, 0x32, 0x07, 0x8C, 0x36, 0x07, 0x29, 0x07, 0xA8, 0xB9, 0xBD, 0x0B, 0x8D, + 0xE3, 0x0B, 0xB9, 0xC5, 0x0B, 0x8D, 0xE4, 0x0B, 0x4C, 0xFF, 0xFF, 0xAD, 0x36, 0x07, 0xAE, 0x32, + 0x07, 0x8D, 0x94, 0x07, 0x8D, 0x9B, 0x07, 0x8E, 0x95, 0x07, 0x8E, 0x9C, 0x07, 0x18, 0x69, 0x40, + 0x8D, 0x81, 0x05, 0x8D, 0x87, 0x05, 0x90, 0x01, 0xE8, 0x8E, 0x82, 0x05, 0x8E, 0x88, 0x05, 0x18, + 0x69, 0x80, 0x8D, 0x7C, 0x09, 0x90, 0x01, 0xE8, 0x8E, 0x7D, 0x09, 0xE8, 0x8D, 0x1F, 0x0C, 0x8E, + 0x20, 0x0C, 0xA2, 0x09, 0xBD, 0xFF, 0xFF, 0x9D, 0xB3, 0x0D, 0xCA, 0x10, 0xF7, 0xCE, 0xBC, 0x0D, + 0xA9, 0x00, 0x8D, 0x2E, 0x07, 0xA2, 0x62, 0x9D, 0xBD, 0x0D, 0xCA, 0x10, 0xFA, 0xA2, 0x08, 0x9D, + 0x00, 0xD2, 0xCA, 0x10, 0xFA, 0x60, 0x20, 0x2A, 0x0C, 0xAD, 0x32, 0x07, 0x0A, 0x8D, 0x16, 0x0E, + 0xAD, 0xBB, 0x0D, 0x8D, 0x17, 0x0E, 0xA9, 0x01, 0x8D, 0x15, 0x0E, 0x8D, 0x2E, 0x07, 0x60, 0xAD, + 0x36, 0x07, 0x85, 0xFE, 0xAD, 0x32, 0x07, 0x85, 0xFF, 0x60, 0xAD, 0x36, 0x07, 0x29, 0x03, 0xAA, + 0xAD, 0x32, 0x07, 0x20, 0xC6, 0x07, 0xAD, 0x1A, 0x0E, 0xF0, 0xEE, 0x0E, 0x36, 0x07, 0x20, 0xBE, + 0x0C, 0xA9, 0x01, 0x8D, 0x1B, 0x0E, 0xAD, 0x1A, 0x0E, 0xF0, 0xDE, 0xC9, 0x01, 0xD0, 0x05, 0xA0, + 0x00, 0xEE, 0x1A, 0x0E, 0xB1, 0xFC, 0xAE, 0x18, 0x0E, 0x4A, 0x4A, 0x4A, 0x4A, 0x09, 0x10, 0x8D, + 0x0A, 0xD4, 0x8D, 0x0A, 0xD4, 0x9D, 0x01, 0xD2, 0xB1, 0xFC, 0x09, 0x10, 0x8D, 0x0A, 0xD4, 0x8D, + 0x0A, 0xD4, 0x9D, 0x01, 0xD2, 0xC8, 0xD0, 0xCE, 0xE6, 0xFD, 0xA5, 0xFD, 0xC5, 0xF8, 0xD0, 0xC6, + 0x8C, 0x1A, 0x0E, 0x60, 0x90, 0x15, 0xA9, 0xEA, 0x8D, 0x99, 0x0C, 0x8D, 0x9A, 0x0C, 0x8D, 0x9B, + 0x0C, 0x8D, 0xA6, 0x0C, 0x8D, 0xA7, 0x0C, 0x8D, 0xA8, 0x0C, 0x60, 0xA9, 0x8D, 0x8D, 0x99, 0x0C, + 0x8D, 0xA6, 0x0C, 0xA9, 0x0A, 0x8D, 0x9A, 0x0C, 0x8D, 0xA7, 0x0C, 0xA9, 0xD4, 0x8D, 0x9B, 0x0C, + 0x8D, 0xA8, 0x0C, 0x60, 0xA9, 0x00, 0x8D, 0x1A, 0x0E, 0xAD, 0x32, 0x07, 0x4A, 0x20, 0xBE, 0x0C, + 0xA9, 0x01, 0x8D, 0x1B, 0x0E, 0x20, 0x80, 0x0C, 0xAD, 0x1B, 0x0E, 0xD0, 0xF8, 0x60, 0xA9, 0x02, + 0x8D, 0x1B, 0x0E, 0x8D, 0x19, 0x0E, 0xA9, 0x18, 0x8D, 0x07, 0xD2, 0xA9, 0x11, 0x85, 0xFA, 0xA9, + 0x0D, 0x85, 0xFB, 0xA9, 0xAD, 0x8D, 0x61, 0x0D, 0x8D, 0x38, 0x0D, 0xA0, 0x00, 0x8C, 0x79, 0x0D, + 0x8C, 0x7F, 0x0D, 0xAE, 0x0B, 0xD4, 0xB1, 0xFC, 0x4A, 0x4A, 0x4A, 0x4A, 0x09, 0x10, 0x8D, 0x07, + 0xD2, 0x20, 0x75, 0x0D, 0xEC, 0x0B, 0xD4, 0xF0, 0xFB, 0x8D, 0x05, 0xD2, 0xAE, 0x0B, 0xD4, 0xB1, + 0xFC, 0xE6, 0xFC, 0xD0, 0x10, 0xE6, 0xFD, 0xC6, 0xF8, 0xD0, 0x0A, 0xA9, 0xAD, 0x8D, 0x61, 0x0D, + 0x8D, 0x38, 0x0D, 0xA9, 0x08, 0x09, 0x10, 0x8D, 0x07, 0xD2, 0x20, 0x75, 0x0D, 0xEC, 0x0B, 0xD4, + 0xF0, 0xFB, 0x8D, 0x05, 0xD2, 0xAD, 0x1B, 0x0E, 0xD0, 0xB9, 0x60, 0x18, 0xA5, 0xF9, 0x69, 0x00, + 0x85, 0xF9, 0xA5, 0xFA, 0x69, 0x00, 0x85, 0xFA, 0x90, 0x0F, 0xE6, 0xFB, 0xA5, 0xFB, 0xC9, 0x00, + 0xD0, 0x07, 0x8C, 0x79, 0x0D, 0x8C, 0x7F, 0x0D, 0x60, 0xB1, 0xFA, 0x24, 0xF9, 0x30, 0x04, 0x4A, + 0x4A, 0x4A, 0x4A, 0x29, 0x0F, 0xA8, 0xB9, 0x45, 0x0A, 0xA0, 0x00, 0x60, 0xA0, 0x00, 0x8C, 0x1B, + 0x0E, 0x8C, 0x1A, 0x0E, 0x88, 0x8C, 0x19, 0x0E, 0x60 +}; +static const unsigned char rmt4_obx[] = { + 0xFF, 0xFF, 0x90, 0x03, 0x60, 0x0B, 0x80, 0x00, 0x80, 0x20, 0x80, 0x40, 0x00, 0xC0, 0x80, 0x80, + 0x80, 0xA0, 0x00, 0xC0, 0x40, 0xC0, 0x00, 0x01, 0x05, 0x0B, 0x15, 0x00, 0x01, 0xFF, 0xFF, 0x01, + 0x01, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x01, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF2, 0x33, 0x96, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, + 0xEF, 0x80, 0x08, 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, + 0x22, 0xF4, 0xC8, 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, + 0x38, 0x27, 0x15, 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, + 0x78, 0x70, 0x6A, 0x64, 0x5E, 0x00, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0xF2, 0xE6, + 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0x7A, 0x71, 0x6B, 0x65, 0x5F, 0x5C, + 0x56, 0x50, 0x4D, 0x47, 0x44, 0x3E, 0x3C, 0x38, 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, + 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, + 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0xFF, 0xF1, 0xE4, 0xD8, 0xCA, 0xC0, 0xB5, 0xAB, 0xA2, 0x99, + 0x8E, 0x87, 0x7F, 0x79, 0x73, 0x70, 0x66, 0x61, 0x5A, 0x55, 0x52, 0x4B, 0x48, 0x43, 0x3F, 0x3C, + 0x39, 0x37, 0x33, 0x30, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x1C, 0x1B, 0x19, 0x17, + 0x16, 0x15, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xF3, 0xE6, 0xD9, 0xCC, 0xC1, 0xB5, 0xAD, 0xA2, 0x99, 0x90, + 0x88, 0x80, 0x79, 0x72, 0x6C, 0x66, 0x60, 0x5B, 0x55, 0x51, 0x4C, 0x48, 0x44, 0x40, 0x3C, 0x39, + 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, + 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x0D, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, + 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, + 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, + 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, + 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, + 0x07, 0x07, 0x08, 0x09, 0x09, 0x0A, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, + 0x07, 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x0D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x4C, 0x0F, 0x06, 0x4C, 0xFC, 0x07, 0x4C, 0x21, 0x08, 0x4C, + 0x58, 0x06, 0x4C, 0x2B, 0x0B, 0x86, 0xD3, 0x84, 0xD4, 0x48, 0xA0, 0xA8, 0xA9, 0x00, 0x99, 0x7F, + 0x02, 0x88, 0xD0, 0xFA, 0xA0, 0x04, 0xB1, 0xD3, 0x8D, 0x15, 0x08, 0xC8, 0xB1, 0xD3, 0x8D, 0x24, + 0x03, 0xC8, 0xB1, 0xD3, 0x8D, 0x05, 0x08, 0x8D, 0x26, 0x03, 0xA0, 0x08, 0xB1, 0xD3, 0x99, 0xC3, + 0x00, 0xC8, 0xC0, 0x10, 0xD0, 0xF6, 0x68, 0x48, 0x0A, 0x0A, 0x18, 0x65, 0xD1, 0x85, 0xD1, 0x68, + 0x08, 0x29, 0xC0, 0x0A, 0x2A, 0x2A, 0x28, 0x65, 0xD2, 0x85, 0xD2, 0x20, 0x6E, 0x06, 0xA9, 0x00, + 0x8D, 0x08, 0xD2, 0xA0, 0x03, 0x8C, 0x0F, 0xD2, 0xA0, 0x08, 0x99, 0x00, 0xD2, 0x88, 0x10, 0xFA, + 0xAD, 0x05, 0x08, 0x60, 0xA2, 0x00, 0x8E, 0x27, 0x03, 0x8A, 0xA8, 0xB1, 0xD1, 0xC9, 0xFE, 0xB0, + 0x2D, 0xA8, 0xB1, 0xCD, 0x9D, 0x80, 0x02, 0xB1, 0xCF, 0x9D, 0x84, 0x02, 0xA9, 0x00, 0x9D, 0x88, + 0x02, 0xA9, 0x01, 0x9D, 0x8C, 0x02, 0xA9, 0x80, 0x9D, 0xB4, 0x02, 0xE8, 0xE0, 0x04, 0xD0, 0xD9, + 0xA5, 0xD1, 0x18, 0x69, 0x04, 0x85, 0xD1, 0x90, 0x1B, 0xE6, 0xD2, 0x4C, 0xBE, 0x06, 0xF0, 0x04, + 0xA9, 0x00, 0xF0, 0xDF, 0xA0, 0x02, 0xB1, 0xD1, 0xAA, 0xC8, 0xB1, 0xD1, 0x85, 0xD2, 0x86, 0xD1, + 0xA2, 0x00, 0xF0, 0xB5, 0xAD, 0x24, 0x03, 0x8D, 0x16, 0x07, 0xA2, 0xFF, 0xE8, 0xDE, 0x8C, 0x02, + 0xD0, 0x45, 0xBD, 0x80, 0x02, 0x85, 0xD3, 0xBD, 0x84, 0x02, 0x85, 0xD4, 0xBC, 0x88, 0x02, 0xFE, + 0x88, 0x02, 0xB1, 0xD3, 0x85, 0xD9, 0x29, 0x3F, 0xC9, 0x3D, 0xF0, 0x11, 0xB0, 0x38, 0x9D, 0x90, + 0x02, 0x9D, 0x10, 0x03, 0xC8, 0xB1, 0xD3, 0x4A, 0x29, 0x7E, 0x9D, 0xB4, 0x02, 0xA9, 0x01, 0x9D, + 0x8C, 0x02, 0xBC, 0x88, 0x02, 0xFE, 0x88, 0x02, 0xB1, 0xD3, 0x4A, 0x66, 0xD9, 0x4A, 0x66, 0xD9, + 0xA5, 0xD9, 0x29, 0xF0, 0x9D, 0x94, 0x02, 0xE0, 0x03, 0xD0, 0xB1, 0xA9, 0xFF, 0x8D, 0x24, 0x03, + 0x8D, 0x25, 0x03, 0x4C, 0x65, 0x07, 0xC9, 0x3F, 0xF0, 0x1B, 0xA5, 0xD9, 0x29, 0xC0, 0xF0, 0x09, + 0x0A, 0x2A, 0x2A, 0x9D, 0x8C, 0x02, 0x4C, 0x11, 0x07, 0xC8, 0xB1, 0xD3, 0x9D, 0x8C, 0x02, 0xFE, + 0x88, 0x02, 0x4C, 0x11, 0x07, 0xA5, 0xD9, 0x30, 0x0C, 0xC8, 0xB1, 0xD3, 0x8D, 0x16, 0x07, 0xFE, + 0x88, 0x02, 0x4C, 0xD6, 0x06, 0xC9, 0xFF, 0xF0, 0x09, 0xC8, 0xB1, 0xD3, 0x9D, 0x88, 0x02, 0x4C, + 0xD6, 0x06, 0x4C, 0x6E, 0x06, 0x4C, 0x21, 0x08, 0xCA, 0x30, 0xFA, 0xBC, 0xB4, 0x02, 0x30, 0xF8, + 0xB1, 0xCB, 0x9D, 0xB8, 0x02, 0x85, 0xD7, 0xC8, 0xB1, 0xCB, 0x9D, 0xBC, 0x02, 0x85, 0xD8, 0xA9, + 0x01, 0x9D, 0x14, 0x03, 0xA8, 0xB1, 0xD7, 0x9D, 0x04, 0x03, 0xC8, 0xB1, 0xD7, 0x9D, 0xC4, 0x02, + 0xC8, 0xB1, 0xD7, 0x9D, 0xC8, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xF0, 0x02, 0x29, 0x3F, 0x9D, 0x08, + 0x03, 0xB1, 0xD7, 0x29, 0x40, 0x9D, 0xF4, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0x20, 0x03, 0xC8, 0xB1, + 0xD7, 0x9D, 0xD0, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xD8, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xDC, 0x02, + 0xC8, 0xB1, 0xD7, 0xA8, 0xB9, 0xA0, 0x03, 0x9D, 0xE0, 0x02, 0x9D, 0xE4, 0x02, 0xB9, 0xA1, 0x03, + 0x9D, 0xE8, 0x02, 0xA0, 0x0A, 0xB1, 0xD7, 0x9D, 0xEC, 0x02, 0xA9, 0x80, 0x9D, 0xD4, 0x02, 0x9D, + 0xB4, 0x02, 0x0A, 0x9D, 0xCC, 0x02, 0x9D, 0x9C, 0x02, 0xA8, 0xB1, 0xD7, 0x9D, 0x00, 0x03, 0x69, + 0x00, 0x9D, 0xC0, 0x02, 0xA9, 0x0C, 0x9D, 0xFC, 0x02, 0xA8, 0xB1, 0xD7, 0x9D, 0xF8, 0x02, 0x4C, + 0x62, 0x07, 0x20, 0x2B, 0x0B, 0xCE, 0x26, 0x03, 0xD0, 0x1D, 0xA9, 0xFF, 0x8D, 0x26, 0x03, 0xCE, + 0x25, 0x03, 0xD0, 0x13, 0xEE, 0x27, 0x03, 0xAD, 0x27, 0x03, 0xC9, 0xFF, 0xF0, 0x03, 0x4C, 0xBE, + 0x06, 0x4C, 0x6E, 0x06, 0x4C, 0x5F, 0x0A, 0xA9, 0x04, 0x85, 0xD6, 0xA2, 0x03, 0xBD, 0xBC, 0x02, + 0xF0, 0xF2, 0x85, 0xD4, 0xBD, 0xB8, 0x02, 0x85, 0xD3, 0xBC, 0xC0, 0x02, 0xB1, 0xD3, 0x85, 0xD9, + 0xC8, 0xB1, 0xD3, 0x85, 0xDA, 0xC8, 0xB1, 0xD3, 0x85, 0xDB, 0xC8, 0x98, 0xDD, 0xC4, 0x02, 0x90, + 0x0A, 0xF0, 0x08, 0xA9, 0x80, 0x9D, 0xCC, 0x02, 0xBD, 0xC8, 0x02, 0x9D, 0xC0, 0x02, 0xA5, 0xD9, + 0x29, 0x0F, 0x1D, 0x94, 0x02, 0xA8, 0xB9, 0x00, 0x05, 0x85, 0xDC, 0xA5, 0xDA, 0x29, 0x0E, 0xA8, + 0xB9, 0x90, 0x03, 0x85, 0xD5, 0xA5, 0xDC, 0x19, 0x91, 0x03, 0x9D, 0x1C, 0x03, 0xBD, 0xDC, 0x02, + 0xF0, 0x28, 0xC9, 0x01, 0xD0, 0x21, 0xBD, 0x9C, 0x02, 0x18, 0x7D, 0xEC, 0x02, 0x18, 0xBC, 0xE0, + 0x02, 0x79, 0xA5, 0x03, 0x9D, 0x9C, 0x02, 0xC8, 0x98, 0xDD, 0xE8, 0x02, 0xD0, 0x03, 0xBD, 0xE4, + 0x02, 0x9D, 0xE0, 0x02, 0x4C, 0xA4, 0x08, 0xDE, 0xDC, 0x02, 0xBC, 0x00, 0x03, 0xC0, 0x0D, 0x90, + 0x3C, 0xBD, 0x08, 0x03, 0x10, 0x31, 0x98, 0xDD, 0xFC, 0x02, 0xD0, 0x08, 0xBD, 0x04, 0x03, 0x9D, + 0xFC, 0x02, 0xD0, 0x03, 0xFE, 0xFC, 0x02, 0xBD, 0xB8, 0x02, 0x85, 0xD7, 0xBD, 0xBC, 0x02, 0x85, + 0xD8, 0xBC, 0xFC, 0x02, 0xB1, 0xD7, 0xBC, 0xF4, 0x02, 0xF0, 0x04, 0x18, 0x7D, 0xF8, 0x02, 0x9D, + 0xF8, 0x02, 0xBD, 0xF0, 0x02, 0x29, 0x3F, 0x38, 0xE9, 0x01, 0x9D, 0x08, 0x03, 0xBD, 0xCC, 0x02, + 0x10, 0x1F, 0xBD, 0x94, 0x02, 0xF0, 0x1A, 0xDD, 0xD8, 0x02, 0xF0, 0x15, 0x90, 0x13, 0xA8, 0xBD, + 0xD4, 0x02, 0x18, 0x7D, 0xD0, 0x02, 0x9D, 0xD4, 0x02, 0x90, 0x06, 0x98, 0xE9, 0x10, 0x9D, 0x94, + 0x02, 0xA9, 0x00, 0x85, 0xDD, 0xA5, 0xDA, 0x9D, 0x0C, 0x03, 0x29, 0x70, 0x4A, 0x4A, 0x8D, 0x1C, + 0x09, 0x90, 0xFE, 0x4C, 0xD2, 0x09, 0xEA, 0x4C, 0x3C, 0x09, 0xEA, 0x4C, 0x41, 0x09, 0xEA, 0x4C, + 0x4B, 0x09, 0xEA, 0x4C, 0x57, 0x09, 0xEA, 0x4C, 0x66, 0x09, 0xEA, 0x4C, 0xA9, 0x09, 0xEA, 0x4C, + 0xB8, 0x09, 0xA5, 0xDB, 0x4C, 0x15, 0x0A, 0xA5, 0xDB, 0x85, 0xDD, 0xBD, 0x90, 0x02, 0x4C, 0xD8, + 0x09, 0xBD, 0x90, 0x02, 0x18, 0x65, 0xDB, 0x9D, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xBD, 0x9C, 0x02, + 0x18, 0x65, 0xDB, 0x9D, 0x9C, 0x02, 0xBD, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xBD, 0xF0, 0x02, 0x10, + 0x0C, 0xBC, 0x90, 0x02, 0xB1, 0xD5, 0x18, 0x7D, 0xF8, 0x02, 0x4C, 0x87, 0x09, 0xBD, 0x90, 0x02, + 0x18, 0x7D, 0xF8, 0x02, 0xC9, 0x3D, 0x90, 0x02, 0xA9, 0x3F, 0xA8, 0xB1, 0xD5, 0x9D, 0xA0, 0x02, + 0xA4, 0xDB, 0xD0, 0x03, 0x9D, 0xA4, 0x02, 0x98, 0x4A, 0x4A, 0x4A, 0x4A, 0x9D, 0xA8, 0x02, 0x9D, + 0xAC, 0x02, 0xA5, 0xDB, 0x29, 0x0F, 0x9D, 0xB0, 0x02, 0xBD, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xA5, + 0xDB, 0x18, 0x7D, 0x14, 0x03, 0x9D, 0x14, 0x03, 0xBD, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xA5, 0xDB, + 0xC9, 0x80, 0xF0, 0x06, 0x9D, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xBD, 0x1C, 0x03, 0x09, 0xF0, 0x9D, + 0x1C, 0x03, 0xBD, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xBD, 0x90, 0x02, 0x18, 0x65, 0xDB, 0xBC, 0xF0, + 0x02, 0x30, 0x1F, 0x18, 0x7D, 0xF8, 0x02, 0xC9, 0x3D, 0x90, 0x07, 0xA9, 0x00, 0x9D, 0x1C, 0x03, + 0xA9, 0x3F, 0x9D, 0x10, 0x03, 0xA8, 0xB1, 0xD5, 0x18, 0x7D, 0x9C, 0x02, 0x18, 0x65, 0xDD, 0x4C, + 0x15, 0x0A, 0xC9, 0x3D, 0x90, 0x07, 0xA9, 0x00, 0x9D, 0x1C, 0x03, 0xA9, 0x3F, 0xA8, 0xBD, 0x9C, + 0x02, 0x18, 0x7D, 0xF8, 0x02, 0x18, 0x71, 0xD5, 0x18, 0x65, 0xDD, 0x9D, 0x18, 0x03, 0xBD, 0xAC, + 0x02, 0xF0, 0x32, 0xDE, 0xAC, 0x02, 0xD0, 0x2D, 0xBD, 0xA8, 0x02, 0x9D, 0xAC, 0x02, 0xBD, 0xA4, + 0x02, 0xDD, 0xA0, 0x02, 0xF0, 0x1F, 0xB0, 0x0D, 0x7D, 0xB0, 0x02, 0xB0, 0x12, 0xDD, 0xA0, 0x02, + 0xB0, 0x0D, 0x4C, 0x4C, 0x0A, 0xFD, 0xB0, 0x02, 0x90, 0x05, 0xDD, 0xA0, 0x02, 0xB0, 0x03, 0xBD, + 0xA0, 0x02, 0x9D, 0xA4, 0x02, 0xA5, 0xDA, 0x29, 0x01, 0xF0, 0x0A, 0xBD, 0xA4, 0x02, 0x18, 0x7D, + 0x9C, 0x02, 0x9D, 0x18, 0x03, 0xCA, 0x30, 0x03, 0x4C, 0x27, 0x08, 0xAD, 0x20, 0x03, 0x0D, 0x21, + 0x03, 0x0D, 0x22, 0x03, 0x0D, 0x23, 0x03, 0xAA, 0x8E, 0x2C, 0x0B, 0xAD, 0x0C, 0x03, 0x10, 0x21, + 0xAD, 0x1C, 0x03, 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x18, 0x03, 0x18, 0x6D, 0x14, 0x03, 0x8D, 0x1A, + 0x03, 0xAD, 0x1E, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x1E, 0x03, 0x8A, 0x09, 0x04, + 0xAA, 0xAD, 0x0D, 0x03, 0x10, 0x21, 0xAD, 0x1D, 0x03, 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x19, 0x03, + 0x18, 0x6D, 0x15, 0x03, 0x8D, 0x1B, 0x03, 0xAD, 0x1F, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, + 0x8D, 0x1F, 0x03, 0x8A, 0x09, 0x02, 0xAA, 0xEC, 0x2C, 0x0B, 0xD0, 0x5E, 0xAD, 0x0D, 0x03, 0x29, + 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x1D, 0x03, 0x29, 0x0F, 0xF0, 0x1F, 0xAC, 0x11, 0x03, 0xB9, + 0xC0, 0x03, 0x8D, 0x18, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x19, 0x03, 0xAD, 0x1C, 0x03, 0x29, 0x10, + 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x1C, 0x03, 0x8A, 0x09, 0x50, 0xAA, 0xAD, 0x0F, 0x03, 0x29, 0x0E, + 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x1F, 0x03, 0x29, 0x0F, 0xF0, 0x1F, 0xAC, 0x13, 0x03, 0xB9, 0xC0, + 0x03, 0x8D, 0x1A, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x1B, 0x03, 0xAD, 0x1E, 0x03, 0x29, 0x10, 0xD0, + 0x05, 0xA9, 0x00, 0x8D, 0x1E, 0x03, 0x8A, 0x09, 0x28, 0xAA, 0x8E, 0x2C, 0x0B, 0xAD, 0x26, 0x03, + 0x60, 0xA0, 0xFF, 0xAD, 0x18, 0x03, 0xAE, 0x1C, 0x03, 0x8D, 0x00, 0xD2, 0x8E, 0x01, 0xD2, 0xAD, + 0x19, 0x03, 0xAE, 0x1D, 0x03, 0x8D, 0x02, 0xD2, 0x8E, 0x03, 0xD2, 0xAD, 0x1A, 0x03, 0xAE, 0x1E, + 0x03, 0x8D, 0x04, 0xD2, 0x8E, 0x05, 0xD2, 0xAD, 0x1B, 0x03, 0xAE, 0x1F, 0x03, 0x8D, 0x06, 0xD2, + 0x8E, 0x07, 0xD2, 0x8C, 0x08, 0xD2, 0x60 +}; +static const unsigned char rmt8_obx[] = { + 0xFF, 0xFF, 0x90, 0x03, 0x6C, 0x0C, 0x80, 0x00, 0x80, 0x20, 0x80, 0x40, 0x00, 0xC0, 0x80, 0x80, + 0x80, 0xA0, 0x00, 0xC0, 0x40, 0xC0, 0x00, 0x01, 0x05, 0x0B, 0x15, 0x00, 0x01, 0xFF, 0xFF, 0x01, + 0x01, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x01, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF2, 0x33, 0x96, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, + 0xEF, 0x80, 0x08, 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, + 0x22, 0xF4, 0xC8, 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, + 0x38, 0x27, 0x15, 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, + 0x78, 0x70, 0x6A, 0x64, 0x5E, 0x00, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0xF2, 0xE6, + 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0x7A, 0x71, 0x6B, 0x65, 0x5F, 0x5C, + 0x56, 0x50, 0x4D, 0x47, 0x44, 0x3E, 0x3C, 0x38, 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, + 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, + 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0xFF, 0xF1, 0xE4, 0xD8, 0xCA, 0xC0, 0xB5, 0xAB, 0xA2, 0x99, + 0x8E, 0x87, 0x7F, 0x79, 0x73, 0x70, 0x66, 0x61, 0x5A, 0x55, 0x52, 0x4B, 0x48, 0x43, 0x3F, 0x3C, + 0x39, 0x37, 0x33, 0x30, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x1C, 0x1B, 0x19, 0x17, + 0x16, 0x15, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xF3, 0xE6, 0xD9, 0xCC, 0xC1, 0xB5, 0xAD, 0xA2, 0x99, 0x90, + 0x88, 0x80, 0x79, 0x72, 0x6C, 0x66, 0x60, 0x5B, 0x55, 0x51, 0x4C, 0x48, 0x44, 0x40, 0x3C, 0x39, + 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, + 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x0D, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, + 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, + 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, + 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, + 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, + 0x07, 0x07, 0x08, 0x09, 0x09, 0x0A, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, + 0x07, 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x0D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x4C, 0x0F, 0x06, 0x4C, 0x09, 0x08, 0x4C, 0x2E, 0x08, 0x4C, + 0x5C, 0x06, 0x4C, 0x02, 0x0C, 0x86, 0xD3, 0x84, 0xD4, 0x48, 0xA0, 0x00, 0x98, 0x99, 0x00, 0x02, + 0x99, 0x4C, 0x02, 0xC8, 0xD0, 0xF7, 0xA0, 0x04, 0xB1, 0xD3, 0x8D, 0x22, 0x08, 0xC8, 0xB1, 0xD3, + 0x8D, 0x48, 0x03, 0xC8, 0xB1, 0xD3, 0x8D, 0x12, 0x08, 0x8D, 0x4A, 0x03, 0xA0, 0x08, 0xB1, 0xD3, + 0x99, 0xC3, 0x00, 0xC8, 0xC0, 0x10, 0xD0, 0xF6, 0x68, 0x48, 0x0A, 0x0A, 0x0A, 0x18, 0x65, 0xD1, + 0x85, 0xD1, 0x68, 0x08, 0x29, 0xE0, 0x0A, 0x2A, 0x2A, 0x2A, 0x28, 0x65, 0xD2, 0x85, 0xD2, 0x20, + 0x7B, 0x06, 0xA9, 0x00, 0x8D, 0x08, 0xD2, 0x8D, 0x18, 0xD2, 0xA0, 0x03, 0x8C, 0x0F, 0xD2, 0x8C, + 0x1F, 0xD2, 0xA0, 0x08, 0x99, 0x00, 0xD2, 0x99, 0x10, 0xD2, 0x88, 0x10, 0xF7, 0xAD, 0x12, 0x08, + 0x60, 0xA2, 0x00, 0x8E, 0x4B, 0x03, 0x8A, 0xA8, 0xB1, 0xD1, 0xC9, 0xFE, 0xB0, 0x2D, 0xA8, 0xB1, + 0xCD, 0x9D, 0x00, 0x02, 0xB1, 0xCF, 0x9D, 0x08, 0x02, 0xA9, 0x00, 0x9D, 0x10, 0x02, 0xA9, 0x01, + 0x9D, 0x18, 0x02, 0xA9, 0x80, 0x9D, 0x68, 0x02, 0xE8, 0xE0, 0x08, 0xD0, 0xD9, 0xA5, 0xD1, 0x18, + 0x69, 0x08, 0x85, 0xD1, 0x90, 0x1B, 0xE6, 0xD2, 0x4C, 0xCB, 0x06, 0xF0, 0x04, 0xA9, 0x00, 0xF0, + 0xDF, 0xA0, 0x02, 0xB1, 0xD1, 0xAA, 0xC8, 0xB1, 0xD1, 0x85, 0xD2, 0x86, 0xD1, 0xA2, 0x00, 0xF0, + 0xB5, 0xAD, 0x48, 0x03, 0x8D, 0x23, 0x07, 0xA2, 0xFF, 0xE8, 0xDE, 0x18, 0x02, 0xD0, 0x45, 0xBD, + 0x00, 0x02, 0x85, 0xD3, 0xBD, 0x08, 0x02, 0x85, 0xD4, 0xBC, 0x10, 0x02, 0xFE, 0x10, 0x02, 0xB1, + 0xD3, 0x85, 0xD9, 0x29, 0x3F, 0xC9, 0x3D, 0xF0, 0x11, 0xB0, 0x38, 0x9D, 0x20, 0x02, 0x9D, 0x20, + 0x03, 0xC8, 0xB1, 0xD3, 0x4A, 0x29, 0x7E, 0x9D, 0x68, 0x02, 0xA9, 0x01, 0x9D, 0x18, 0x02, 0xBC, + 0x10, 0x02, 0xFE, 0x10, 0x02, 0xB1, 0xD3, 0x4A, 0x66, 0xD9, 0x4A, 0x66, 0xD9, 0xA5, 0xD9, 0x29, + 0xF0, 0x9D, 0x28, 0x02, 0xE0, 0x07, 0xD0, 0xB1, 0xA9, 0xFF, 0x8D, 0x48, 0x03, 0x8D, 0x49, 0x03, + 0x4C, 0x72, 0x07, 0xC9, 0x3F, 0xF0, 0x1B, 0xA5, 0xD9, 0x29, 0xC0, 0xF0, 0x09, 0x0A, 0x2A, 0x2A, + 0x9D, 0x18, 0x02, 0x4C, 0x1E, 0x07, 0xC8, 0xB1, 0xD3, 0x9D, 0x18, 0x02, 0xFE, 0x10, 0x02, 0x4C, + 0x1E, 0x07, 0xA5, 0xD9, 0x30, 0x0C, 0xC8, 0xB1, 0xD3, 0x8D, 0x23, 0x07, 0xFE, 0x10, 0x02, 0x4C, + 0xE3, 0x06, 0xC9, 0xFF, 0xF0, 0x09, 0xC8, 0xB1, 0xD3, 0x9D, 0x10, 0x02, 0x4C, 0xE3, 0x06, 0x4C, + 0x7B, 0x06, 0x4C, 0x2E, 0x08, 0xCA, 0x30, 0xFA, 0xBC, 0x68, 0x02, 0x30, 0xF8, 0xB1, 0xCB, 0x9D, + 0x70, 0x02, 0x85, 0xD7, 0xC8, 0xB1, 0xCB, 0x9D, 0x78, 0x02, 0x85, 0xD8, 0xA9, 0x01, 0x9D, 0x28, + 0x03, 0xA8, 0xB1, 0xD7, 0x9D, 0x08, 0x03, 0xC8, 0xB1, 0xD7, 0x9D, 0x88, 0x02, 0xC8, 0xB1, 0xD7, + 0x9D, 0x90, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xE0, 0x02, 0x29, 0x3F, 0x9D, 0x10, 0x03, 0xB1, 0xD7, + 0x29, 0x40, 0x9D, 0xE8, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0x40, 0x03, 0xC8, 0xB1, 0xD7, 0x9D, 0xA0, + 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xB0, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xB8, 0x02, 0xC8, 0xB1, 0xD7, + 0xA8, 0xB9, 0xA0, 0x03, 0x9D, 0xC0, 0x02, 0x9D, 0xC8, 0x02, 0xB9, 0xA1, 0x03, 0x9D, 0xD0, 0x02, + 0xA0, 0x0A, 0xB1, 0xD7, 0x9D, 0xD8, 0x02, 0xA9, 0x80, 0x9D, 0xA8, 0x02, 0x9D, 0x68, 0x02, 0x0A, + 0x9D, 0x98, 0x02, 0x9D, 0x38, 0x02, 0xA8, 0xB1, 0xD7, 0x9D, 0x00, 0x03, 0x69, 0x00, 0x9D, 0x80, + 0x02, 0xA9, 0x0C, 0x9D, 0xF8, 0x02, 0xA8, 0xB1, 0xD7, 0x9D, 0xF0, 0x02, 0x4C, 0x6F, 0x07, 0x20, + 0x02, 0x0C, 0xCE, 0x4A, 0x03, 0xD0, 0x1D, 0xA9, 0xFF, 0x8D, 0x4A, 0x03, 0xCE, 0x49, 0x03, 0xD0, + 0x13, 0xEE, 0x4B, 0x03, 0xAD, 0x4B, 0x03, 0xC9, 0xFF, 0xF0, 0x03, 0x4C, 0xCB, 0x06, 0x4C, 0x7B, + 0x06, 0x4C, 0x74, 0x0A, 0xA9, 0x04, 0x85, 0xD6, 0xA2, 0x07, 0xBD, 0x78, 0x02, 0xF0, 0xF2, 0x85, + 0xD4, 0xBD, 0x70, 0x02, 0x85, 0xD3, 0xBC, 0x80, 0x02, 0xB1, 0xD3, 0x85, 0xD9, 0xC8, 0xB1, 0xD3, + 0x85, 0xDA, 0xC8, 0xB1, 0xD3, 0x85, 0xDB, 0xC8, 0x98, 0xDD, 0x88, 0x02, 0x90, 0x0A, 0xF0, 0x08, + 0xA9, 0x80, 0x9D, 0x98, 0x02, 0xBD, 0x90, 0x02, 0x9D, 0x80, 0x02, 0xA5, 0xD9, 0xE0, 0x04, 0x90, + 0x04, 0x4A, 0x4A, 0x4A, 0x4A, 0x29, 0x0F, 0x1D, 0x28, 0x02, 0xA8, 0xB9, 0x00, 0x05, 0x85, 0xDC, + 0xA5, 0xDA, 0x29, 0x0E, 0xA8, 0xB9, 0x90, 0x03, 0x85, 0xD5, 0xA5, 0xDC, 0x19, 0x91, 0x03, 0x9D, + 0x38, 0x03, 0xBD, 0xB8, 0x02, 0xF0, 0x28, 0xC9, 0x01, 0xD0, 0x21, 0xBD, 0x38, 0x02, 0x18, 0x7D, + 0xD8, 0x02, 0x18, 0xBC, 0xC0, 0x02, 0x79, 0xA5, 0x03, 0x9D, 0x38, 0x02, 0xC8, 0x98, 0xDD, 0xD0, + 0x02, 0xD0, 0x03, 0xBD, 0xC8, 0x02, 0x9D, 0xC0, 0x02, 0x4C, 0xB9, 0x08, 0xDE, 0xB8, 0x02, 0xBC, + 0x00, 0x03, 0xC0, 0x0D, 0x90, 0x3C, 0xBD, 0x10, 0x03, 0x10, 0x31, 0x98, 0xDD, 0xF8, 0x02, 0xD0, + 0x08, 0xBD, 0x08, 0x03, 0x9D, 0xF8, 0x02, 0xD0, 0x03, 0xFE, 0xF8, 0x02, 0xBD, 0x70, 0x02, 0x85, + 0xD7, 0xBD, 0x78, 0x02, 0x85, 0xD8, 0xBC, 0xF8, 0x02, 0xB1, 0xD7, 0xBC, 0xE8, 0x02, 0xF0, 0x04, + 0x18, 0x7D, 0xF0, 0x02, 0x9D, 0xF0, 0x02, 0xBD, 0xE0, 0x02, 0x29, 0x3F, 0x38, 0xE9, 0x01, 0x9D, + 0x10, 0x03, 0xBD, 0x98, 0x02, 0x10, 0x1F, 0xBD, 0x28, 0x02, 0xF0, 0x1A, 0xDD, 0xB0, 0x02, 0xF0, + 0x15, 0x90, 0x13, 0xA8, 0xBD, 0xA8, 0x02, 0x18, 0x7D, 0xA0, 0x02, 0x9D, 0xA8, 0x02, 0x90, 0x06, + 0x98, 0xE9, 0x10, 0x9D, 0x28, 0x02, 0xA9, 0x00, 0x85, 0xDD, 0xA5, 0xDA, 0x9D, 0x18, 0x03, 0x29, + 0x70, 0x4A, 0x4A, 0x8D, 0x31, 0x09, 0x90, 0xFE, 0x4C, 0xE7, 0x09, 0xEA, 0x4C, 0x51, 0x09, 0xEA, + 0x4C, 0x56, 0x09, 0xEA, 0x4C, 0x60, 0x09, 0xEA, 0x4C, 0x6C, 0x09, 0xEA, 0x4C, 0x7B, 0x09, 0xEA, + 0x4C, 0xBE, 0x09, 0xEA, 0x4C, 0xCD, 0x09, 0xA5, 0xDB, 0x4C, 0x2A, 0x0A, 0xA5, 0xDB, 0x85, 0xDD, + 0xBD, 0x20, 0x02, 0x4C, 0xED, 0x09, 0xBD, 0x20, 0x02, 0x18, 0x65, 0xDB, 0x9D, 0x20, 0x02, 0x4C, + 0xED, 0x09, 0xBD, 0x38, 0x02, 0x18, 0x65, 0xDB, 0x9D, 0x38, 0x02, 0xBD, 0x20, 0x02, 0x4C, 0xED, + 0x09, 0xBD, 0xE0, 0x02, 0x10, 0x0C, 0xBC, 0x20, 0x02, 0xB1, 0xD5, 0x18, 0x7D, 0xF0, 0x02, 0x4C, + 0x9C, 0x09, 0xBD, 0x20, 0x02, 0x18, 0x7D, 0xF0, 0x02, 0xC9, 0x3D, 0x90, 0x02, 0xA9, 0x3F, 0xA8, + 0xB1, 0xD5, 0x9D, 0x40, 0x02, 0xA4, 0xDB, 0xD0, 0x03, 0x9D, 0x48, 0x02, 0x98, 0x4A, 0x4A, 0x4A, + 0x4A, 0x9D, 0x50, 0x02, 0x9D, 0x58, 0x02, 0xA5, 0xDB, 0x29, 0x0F, 0x9D, 0x60, 0x02, 0xBD, 0x20, + 0x02, 0x4C, 0xED, 0x09, 0xA5, 0xDB, 0x18, 0x7D, 0x28, 0x03, 0x9D, 0x28, 0x03, 0xBD, 0x20, 0x02, + 0x4C, 0xED, 0x09, 0xA5, 0xDB, 0xC9, 0x80, 0xF0, 0x06, 0x9D, 0x20, 0x02, 0x4C, 0xED, 0x09, 0xBD, + 0x38, 0x03, 0x09, 0xF0, 0x9D, 0x38, 0x03, 0xBD, 0x20, 0x02, 0x4C, 0xED, 0x09, 0xBD, 0x20, 0x02, + 0x18, 0x65, 0xDB, 0xBC, 0xE0, 0x02, 0x30, 0x1F, 0x18, 0x7D, 0xF0, 0x02, 0xC9, 0x3D, 0x90, 0x07, + 0xA9, 0x00, 0x9D, 0x38, 0x03, 0xA9, 0x3F, 0x9D, 0x20, 0x03, 0xA8, 0xB1, 0xD5, 0x18, 0x7D, 0x38, + 0x02, 0x18, 0x65, 0xDD, 0x4C, 0x2A, 0x0A, 0xC9, 0x3D, 0x90, 0x07, 0xA9, 0x00, 0x9D, 0x38, 0x03, + 0xA9, 0x3F, 0xA8, 0xBD, 0x38, 0x02, 0x18, 0x7D, 0xF0, 0x02, 0x18, 0x71, 0xD5, 0x18, 0x65, 0xDD, + 0x9D, 0x30, 0x03, 0xBD, 0x58, 0x02, 0xF0, 0x32, 0xDE, 0x58, 0x02, 0xD0, 0x2D, 0xBD, 0x50, 0x02, + 0x9D, 0x58, 0x02, 0xBD, 0x48, 0x02, 0xDD, 0x40, 0x02, 0xF0, 0x1F, 0xB0, 0x0D, 0x7D, 0x60, 0x02, + 0xB0, 0x12, 0xDD, 0x40, 0x02, 0xB0, 0x0D, 0x4C, 0x61, 0x0A, 0xFD, 0x60, 0x02, 0x90, 0x05, 0xDD, + 0x40, 0x02, 0xB0, 0x03, 0xBD, 0x40, 0x02, 0x9D, 0x48, 0x02, 0xA5, 0xDA, 0x29, 0x01, 0xF0, 0x0A, + 0xBD, 0x48, 0x02, 0x18, 0x7D, 0x38, 0x02, 0x9D, 0x30, 0x03, 0xCA, 0x30, 0x03, 0x4C, 0x34, 0x08, + 0xAD, 0x40, 0x03, 0x0D, 0x41, 0x03, 0x0D, 0x42, 0x03, 0x0D, 0x43, 0x03, 0xAA, 0x8E, 0x65, 0x0C, + 0xAD, 0x18, 0x03, 0x10, 0x21, 0xAD, 0x38, 0x03, 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x30, 0x03, 0x18, + 0x6D, 0x28, 0x03, 0x8D, 0x32, 0x03, 0xAD, 0x3A, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, + 0x3A, 0x03, 0x8A, 0x09, 0x04, 0xAA, 0xAD, 0x19, 0x03, 0x10, 0x21, 0xAD, 0x39, 0x03, 0x29, 0x0F, + 0xF0, 0x1A, 0xAD, 0x31, 0x03, 0x18, 0x6D, 0x29, 0x03, 0x8D, 0x33, 0x03, 0xAD, 0x3B, 0x03, 0x29, + 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3B, 0x03, 0x8A, 0x09, 0x02, 0xAA, 0xEC, 0x65, 0x0C, 0xD0, + 0x5E, 0xAD, 0x19, 0x03, 0x29, 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x39, 0x03, 0x29, 0x0F, 0xF0, + 0x1F, 0xAC, 0x21, 0x03, 0xB9, 0xC0, 0x03, 0x8D, 0x30, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x31, 0x03, + 0xAD, 0x38, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x38, 0x03, 0x8A, 0x09, 0x50, 0xAA, + 0xAD, 0x1B, 0x03, 0x29, 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x3B, 0x03, 0x29, 0x0F, 0xF0, 0x1F, + 0xAC, 0x23, 0x03, 0xB9, 0xC0, 0x03, 0x8D, 0x32, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x33, 0x03, 0xAD, + 0x3A, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3A, 0x03, 0x8A, 0x09, 0x28, 0xAA, 0x8E, + 0x65, 0x0C, 0xAD, 0x44, 0x03, 0x0D, 0x45, 0x03, 0x0D, 0x46, 0x03, 0x0D, 0x47, 0x03, 0xAA, 0x8E, + 0x03, 0x0C, 0xAD, 0x1C, 0x03, 0x10, 0x21, 0xAD, 0x3C, 0x03, 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x34, + 0x03, 0x18, 0x6D, 0x2C, 0x03, 0x8D, 0x36, 0x03, 0xAD, 0x3E, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, + 0x00, 0x8D, 0x3E, 0x03, 0x8A, 0x09, 0x04, 0xAA, 0xAD, 0x1D, 0x03, 0x10, 0x21, 0xAD, 0x3D, 0x03, + 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x35, 0x03, 0x18, 0x6D, 0x2D, 0x03, 0x8D, 0x37, 0x03, 0xAD, 0x3F, + 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3F, 0x03, 0x8A, 0x09, 0x02, 0xAA, 0xEC, 0x03, + 0x0C, 0xD0, 0x5E, 0xAD, 0x1D, 0x03, 0x29, 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x3D, 0x03, 0x29, + 0x0F, 0xF0, 0x1F, 0xAC, 0x25, 0x03, 0xB9, 0xC0, 0x03, 0x8D, 0x34, 0x03, 0xB9, 0xC0, 0x04, 0x8D, + 0x35, 0x03, 0xAD, 0x3C, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3C, 0x03, 0x8A, 0x09, + 0x50, 0xAA, 0xAD, 0x1F, 0x03, 0x29, 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x3F, 0x03, 0x29, 0x0F, + 0xF0, 0x1F, 0xAC, 0x27, 0x03, 0xB9, 0xC0, 0x03, 0x8D, 0x36, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x37, + 0x03, 0xAD, 0x3E, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3E, 0x03, 0x8A, 0x09, 0x28, + 0xAA, 0x8E, 0x03, 0x0C, 0xAD, 0x4A, 0x03, 0x60, 0xA0, 0xFF, 0xAD, 0x34, 0x03, 0xAE, 0x30, 0x03, + 0x8D, 0x10, 0xD2, 0x8E, 0x00, 0xD2, 0xAD, 0x3C, 0x03, 0xAE, 0x38, 0x03, 0x8D, 0x11, 0xD2, 0x8E, + 0x01, 0xD2, 0xAD, 0x35, 0x03, 0xAE, 0x31, 0x03, 0x8D, 0x12, 0xD2, 0x8E, 0x02, 0xD2, 0xAD, 0x3D, + 0x03, 0xAE, 0x39, 0x03, 0x8D, 0x13, 0xD2, 0x8E, 0x03, 0xD2, 0xAD, 0x36, 0x03, 0xAE, 0x32, 0x03, + 0x8D, 0x14, 0xD2, 0x8E, 0x04, 0xD2, 0xAD, 0x3E, 0x03, 0xAE, 0x3A, 0x03, 0x8D, 0x15, 0xD2, 0x8E, + 0x05, 0xD2, 0xAD, 0x37, 0x03, 0xAE, 0x33, 0x03, 0x8D, 0x16, 0xD2, 0x8E, 0x06, 0xD2, 0xAD, 0x3F, + 0x03, 0xAE, 0x3B, 0x03, 0x8D, 0x17, 0xD2, 0x8E, 0x07, 0xD2, 0xA9, 0xFF, 0x8C, 0x18, 0xD2, 0x8D, + 0x08, 0xD2, 0x60 +}; +static const unsigned char tmc_obx[] = { + 0xFF, 0xFF, 0x00, 0x05, 0x68, 0x0F, 0x4C, 0xCE, 0x0D, 0x4C, 0xD0, 0x08, 0x4C, 0xEF, 0x09, 0x0F, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, + 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, + 0x04, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, + 0x05, 0x05, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, + 0x06, 0x06, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, + 0x07, 0x07, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, + 0x07, 0x08, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x08, 0x09, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, 0x07, 0x07, 0x08, 0x09, + 0x09, 0x0A, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, 0x09, 0x0A, + 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0A, + 0x0B, 0x0C, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0A, 0x0B, + 0x0C, 0x0D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, + 0x0D, 0x0E, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, + 0x0E, 0x0F, 0x00, 0xF1, 0xE4, 0xD7, 0xCB, 0xC0, 0xB5, 0xAA, 0xA1, 0x98, 0x8F, 0x87, 0x7F, 0x78, + 0x72, 0x6B, 0x65, 0x5F, 0x5A, 0x55, 0x50, 0x4B, 0x47, 0x43, 0x3F, 0x3C, 0x38, 0x35, 0x32, 0x2F, + 0x2C, 0x2A, 0x27, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, + 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x00, 0x00, 0xF2, 0xE6, 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0x7A, + 0x71, 0x6B, 0x65, 0x5F, 0x5C, 0x56, 0x50, 0x4D, 0x47, 0x44, 0x3E, 0x3C, 0x38, 0x35, 0x32, 0x2F, + 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, + 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x00, 0x00, 0xFF, 0xF1, 0xE4, 0xD8, 0xCA, 0xC0, 0xB5, 0xAB, 0xA2, 0x99, 0x8E, 0x87, 0x7F, + 0x79, 0x73, 0x70, 0x66, 0x61, 0x5A, 0x55, 0x52, 0x4B, 0x48, 0x43, 0x3F, 0x3C, 0x39, 0x37, 0x33, + 0x30, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x1C, 0x1B, 0x19, 0x17, 0x16, 0x15, 0x13, + 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x00, 0xF3, 0xE6, 0xD9, 0xCC, 0xC1, 0xB5, 0xAD, 0xA2, 0x99, 0x90, 0x88, 0x80, 0x79, + 0x72, 0x6C, 0x66, 0x60, 0x5B, 0x55, 0x51, 0x4C, 0x48, 0x44, 0x40, 0x3C, 0x39, 0x35, 0x32, 0x2F, + 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, + 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x00, 0x00, 0xF2, 0x33, 0x96, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, 0xEF, 0x80, 0x08, + 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, 0x22, 0xF4, 0xC8, + 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, 0x38, 0x27, 0x15, + 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, 0x78, 0x70, 0x6A, + 0x64, 0x5E, 0x00, 0x0D, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, + 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x02, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x08, 0x00, 0x10, 0x00, 0x08, 0xAD, 0xB7, 0x08, 0xF0, 0x5E, 0xAD, 0xB6, 0x08, 0xC9, 0x40, + 0x90, 0x5A, 0xCE, 0xB5, 0x08, 0xF0, 0x03, 0x4C, 0xEF, 0x09, 0xA2, 0x07, 0xA9, 0x00, 0x9D, 0xC4, + 0x07, 0x9D, 0xCC, 0x07, 0xCA, 0x10, 0xF7, 0x8D, 0xB6, 0x08, 0xAA, 0xA0, 0x0F, 0xB1, 0xFE, 0x10, + 0x20, 0x88, 0xB1, 0xFE, 0x10, 0x03, 0x4C, 0x5F, 0x0E, 0x86, 0xFC, 0x0A, 0x0A, 0x26, 0xFC, 0x0A, + 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x69, 0x00, 0x85, 0xFE, 0xA5, 0xFC, 0x69, 0x00, 0x85, 0xFF, 0x90, + 0xDA, 0x9D, 0xD4, 0x07, 0x88, 0xB1, 0xFE, 0x9D, 0xDC, 0x07, 0xE8, 0x88, 0x10, 0xCF, 0x18, 0xA5, + 0xFE, 0x69, 0x10, 0x85, 0xFE, 0x90, 0x02, 0xE6, 0xFF, 0x4C, 0xEF, 0x09, 0xCE, 0xB5, 0x08, 0x10, + 0xF8, 0xEE, 0xB6, 0x08, 0xAD, 0xB4, 0x08, 0x8D, 0xB5, 0x08, 0xA2, 0x07, 0xDE, 0xCC, 0x07, 0x30, + 0x03, 0x4C, 0xE9, 0x09, 0xBC, 0xD4, 0x07, 0xB9, 0xFF, 0xFF, 0x85, 0xFC, 0xB9, 0xFF, 0xFF, 0x85, + 0xFD, 0xBC, 0xC4, 0x07, 0xB1, 0xFC, 0xD0, 0x06, 0x20, 0x6D, 0x0D, 0x4C, 0xE6, 0x09, 0xC9, 0x40, + 0xB0, 0x12, 0x7D, 0xDC, 0x07, 0x9D, 0xE4, 0x07, 0x20, 0x6D, 0x0D, 0xBC, 0x2A, 0x05, 0x20, 0xBC, + 0x0E, 0x4C, 0xE6, 0x09, 0xD0, 0x22, 0xC8, 0xFE, 0xC4, 0x07, 0xB1, 0xFC, 0x10, 0x07, 0x85, 0xFB, + 0x20, 0x6D, 0x0D, 0xA5, 0xFB, 0x29, 0x7F, 0xD0, 0x07, 0xA9, 0x40, 0x8D, 0xB6, 0x08, 0xD0, 0x4C, + 0x8D, 0xB4, 0x08, 0x8D, 0xB5, 0x08, 0xD0, 0x44, 0xC9, 0x80, 0xB0, 0x2B, 0x29, 0x3F, 0x7D, 0xDC, + 0x07, 0x9D, 0xE4, 0x07, 0xC8, 0xFE, 0xC4, 0x07, 0xB1, 0xFC, 0x29, 0x7F, 0xD0, 0x07, 0xA9, 0x40, + 0x8D, 0xB6, 0x08, 0xD0, 0x06, 0x8D, 0xB4, 0x08, 0x8D, 0xB5, 0x08, 0x20, 0x6D, 0x0D, 0xBC, 0x2A, + 0x05, 0x20, 0xBC, 0x0E, 0x4C, 0xE6, 0x09, 0xC9, 0xC0, 0xB0, 0x0C, 0x29, 0x3F, 0x9D, 0x2A, 0x05, + 0xC8, 0xFE, 0xC4, 0x07, 0x4C, 0x5E, 0x09, 0x29, 0x3F, 0x9D, 0xCC, 0x07, 0xFE, 0xC4, 0x07, 0xCA, + 0x30, 0x03, 0x4C, 0x46, 0x09, 0xA2, 0x07, 0xBD, 0xBC, 0x07, 0xF0, 0x21, 0x20, 0x2E, 0x0B, 0xBD, + 0x32, 0x05, 0x3D, 0xC0, 0x08, 0xF0, 0x16, 0xA0, 0x47, 0xB1, 0xFC, 0x18, 0x7D, 0x22, 0x05, 0x9D, + 0x24, 0x05, 0xA8, 0xB9, 0x3C, 0x06, 0x38, 0x7D, 0x64, 0x08, 0x9D, 0xF6, 0x07, 0xCA, 0x10, 0xD7, + 0x0E, 0x09, 0x05, 0x0E, 0x09, 0x05, 0x0E, 0x09, 0x05, 0x0E, 0x09, 0x05, 0xE8, 0x86, 0xFC, 0x86, + 0xFD, 0xA2, 0x07, 0x8A, 0xA8, 0xB9, 0xFC, 0x07, 0xD0, 0x0C, 0xBC, 0xB8, 0x08, 0xB9, 0x04, 0x08, + 0xD0, 0x04, 0x8A, 0xA8, 0xA9, 0x00, 0x85, 0xFA, 0x98, 0x9D, 0x1A, 0x05, 0xB9, 0xF4, 0x07, 0x9D, + 0x12, 0x05, 0xB9, 0x32, 0x05, 0x85, 0xFB, 0x05, 0xFD, 0x85, 0xFD, 0xA5, 0xFB, 0x3D, 0xC0, 0x08, + 0xF0, 0x06, 0xB9, 0xF6, 0x07, 0x9D, 0x14, 0x05, 0xA5, 0xFB, 0x3D, 0xC8, 0x08, 0xF0, 0x12, 0xB9, + 0x22, 0x05, 0x29, 0x3F, 0xA8, 0xC8, 0x84, 0xFC, 0xB9, 0x7B, 0x07, 0x9D, 0x12, 0x05, 0x4C, 0x89, + 0x0A, 0xA4, 0xFC, 0xF0, 0x0A, 0xB9, 0x3B, 0x07, 0x9D, 0x12, 0x05, 0xA9, 0x00, 0x85, 0xFC, 0xA5, + 0xFA, 0x0D, 0x09, 0x05, 0xA8, 0xB9, 0x3C, 0x05, 0xBC, 0x1A, 0x05, 0x19, 0xEC, 0x07, 0x9D, 0x0A, + 0x05, 0xE0, 0x04, 0xD0, 0x09, 0xA5, 0xFD, 0x8D, 0x3B, 0x05, 0xA9, 0x00, 0x85, 0xFD, 0xCA, 0x10, + 0x82, 0x4E, 0x09, 0x05, 0x4E, 0x09, 0x05, 0x4E, 0x09, 0x05, 0x4E, 0x09, 0x05, 0xA5, 0xFD, 0xA2, + 0x03, 0x8E, 0x1F, 0xD2, 0x8E, 0x0F, 0xD2, 0xAE, 0x16, 0x05, 0xAC, 0x12, 0x05, 0x8E, 0x10, 0xD2, + 0x8C, 0x00, 0xD2, 0xAE, 0x0E, 0x05, 0xAC, 0x0A, 0x05, 0x8E, 0x11, 0xD2, 0x8C, 0x01, 0xD2, 0xAE, + 0x17, 0x05, 0xAC, 0x13, 0x05, 0x8E, 0x12, 0xD2, 0x8C, 0x02, 0xD2, 0xAE, 0x0F, 0x05, 0xAC, 0x0B, + 0x05, 0x8E, 0x13, 0xD2, 0x8C, 0x03, 0xD2, 0xAE, 0x18, 0x05, 0xAC, 0x14, 0x05, 0x8E, 0x14, 0xD2, + 0x8C, 0x04, 0xD2, 0xAE, 0x10, 0x05, 0xAC, 0x0C, 0x05, 0x8E, 0x15, 0xD2, 0x8C, 0x05, 0xD2, 0xAE, + 0x19, 0x05, 0xAC, 0x15, 0x05, 0x8E, 0x16, 0xD2, 0x8C, 0x06, 0xD2, 0xAE, 0x11, 0x05, 0xAC, 0x0D, + 0x05, 0x8E, 0x17, 0xD2, 0x8C, 0x07, 0xD2, 0x8D, 0x3A, 0x05, 0xAE, 0x3B, 0x05, 0x8E, 0x18, 0xD2, + 0x8D, 0x08, 0xD2, 0x60, 0xBD, 0x1C, 0x08, 0x85, 0xFC, 0xBD, 0x24, 0x08, 0x85, 0xFD, 0xBC, 0x2C, + 0x08, 0xC0, 0x3F, 0xF0, 0x7B, 0xFE, 0x2C, 0x08, 0xFE, 0x2C, 0x08, 0xFE, 0x2C, 0x08, 0xB1, 0xFC, + 0x29, 0xF0, 0x9D, 0xEC, 0x07, 0xB1, 0xFC, 0x29, 0x0F, 0x38, 0xFD, 0x0C, 0x08, 0x10, 0x02, 0xA9, + 0x00, 0x9D, 0xFC, 0x07, 0xC8, 0xB1, 0xFC, 0x29, 0x0F, 0x38, 0xFD, 0x14, 0x08, 0x10, 0x02, 0xA9, + 0x00, 0x9D, 0x04, 0x08, 0xB1, 0xFC, 0x29, 0xF0, 0xF0, 0x74, 0x10, 0x0B, 0xA0, 0x49, 0xB1, 0xFC, + 0xBC, 0x2C, 0x08, 0x88, 0x88, 0x10, 0x02, 0xA9, 0x00, 0x9D, 0x32, 0x05, 0xB1, 0xFC, 0x29, 0x70, + 0xF0, 0x63, 0x4A, 0x4A, 0x8D, 0x9A, 0x0B, 0xA9, 0x00, 0x9D, 0x64, 0x08, 0xC8, 0xB1, 0xFC, 0x90, + 0xFE, 0xEA, 0xEA, 0xEA, 0xEA, 0x4C, 0x38, 0x0D, 0xEA, 0x4C, 0x35, 0x0D, 0xEA, 0x4C, 0x3C, 0x0D, + 0xEA, 0x4C, 0x4A, 0x0D, 0xEA, 0x4C, 0x54, 0x0D, 0xEA, 0x4C, 0x5F, 0x0D, 0xEA, 0x4C, 0x51, 0x0D, + 0xBD, 0x34, 0x08, 0xF0, 0x12, 0xDE, 0x44, 0x08, 0xD0, 0x0D, 0x9D, 0x44, 0x08, 0xBD, 0xFC, 0x07, + 0x29, 0x0F, 0xF0, 0x03, 0xDE, 0xFC, 0x07, 0xBD, 0x3C, 0x08, 0xF0, 0x12, 0xDE, 0x4C, 0x08, 0xD0, + 0x0D, 0x9D, 0x4C, 0x08, 0xBD, 0x04, 0x08, 0x29, 0x0F, 0xF0, 0x03, 0xDE, 0x04, 0x08, 0xA0, 0x48, + 0xB1, 0xFC, 0x9D, 0x32, 0x05, 0xBD, 0x94, 0x08, 0x18, 0x69, 0x3F, 0xA8, 0xB1, 0xFC, 0x7D, 0xE4, + 0x07, 0x9D, 0x22, 0x05, 0xA8, 0xB9, 0x3C, 0x06, 0x9D, 0xF4, 0x07, 0xDE, 0xA4, 0x08, 0x10, 0x33, + 0xBD, 0x9C, 0x08, 0x9D, 0xA4, 0x08, 0xBD, 0xAC, 0x08, 0xF0, 0x18, 0x18, 0x7D, 0x94, 0x08, 0x9D, + 0x94, 0x08, 0xF0, 0x07, 0xDD, 0x8C, 0x08, 0xD0, 0x1A, 0xA9, 0xFE, 0x18, 0x69, 0x01, 0x9D, 0xAC, + 0x08, 0xD0, 0x10, 0xFE, 0x94, 0x08, 0xBD, 0x8C, 0x08, 0xDD, 0x94, 0x08, 0xB0, 0x05, 0xA9, 0x00, + 0x9D, 0x94, 0x08, 0xBD, 0x74, 0x08, 0xF0, 0x04, 0xDE, 0x74, 0x08, 0x60, 0xBD, 0x6C, 0x08, 0x85, + 0xFA, 0xBD, 0x5C, 0x08, 0x85, 0xFB, 0x20, 0x69, 0x0C, 0xDE, 0x84, 0x08, 0x10, 0x10, 0xA5, 0xFA, + 0x9D, 0x6C, 0x08, 0xA5, 0xFB, 0x9D, 0x5C, 0x08, 0xBD, 0x7C, 0x08, 0x9D, 0x84, 0x08, 0x60, 0xBD, + 0x54, 0x08, 0x8D, 0x70, 0x0C, 0x10, 0xFE, 0x4C, 0xA7, 0x0C, 0xEA, 0x4C, 0x90, 0x0C, 0xEA, 0x4C, + 0xAE, 0x0C, 0xEA, 0x4C, 0xB4, 0x0C, 0xEA, 0x4C, 0xBE, 0x0C, 0xEA, 0x4C, 0xD2, 0x0C, 0xEA, 0x4C, + 0xE2, 0x0C, 0xEA, 0x4C, 0xF4, 0x0C, 0xA5, 0xFA, 0xE6, 0xFA, 0x29, 0x03, 0x4A, 0x90, 0x0F, 0xD0, + 0x47, 0xA5, 0xFB, 0x9D, 0x64, 0x08, 0x18, 0x7D, 0xF4, 0x07, 0x9D, 0xF4, 0x07, 0x60, 0xA9, 0x00, + 0x9D, 0x64, 0x08, 0x60, 0x20, 0x1D, 0x0D, 0x4C, 0x9D, 0x0C, 0x20, 0x1D, 0x0D, 0x18, 0x7D, 0x22, + 0x05, 0x4C, 0x54, 0x0D, 0xA5, 0xFA, 0x9D, 0x64, 0x08, 0x18, 0x7D, 0xF4, 0x07, 0x9D, 0xF4, 0x07, + 0xA5, 0xFA, 0x18, 0x65, 0xFB, 0x85, 0xFA, 0x60, 0xBD, 0x22, 0x05, 0x38, 0xE5, 0xFA, 0x9D, 0x22, + 0x05, 0xA8, 0xB9, 0x3C, 0x06, 0x4C, 0xC7, 0x0C, 0xBD, 0xF4, 0x07, 0x38, 0xE5, 0xFB, 0x9D, 0xF4, + 0x07, 0x38, 0xA9, 0x00, 0xE5, 0xFB, 0x9D, 0x64, 0x08, 0x60, 0xBD, 0x84, 0x08, 0xD0, 0xAE, 0xA5, + 0xFB, 0x10, 0x10, 0xBD, 0x04, 0x08, 0xF0, 0xA5, 0xBD, 0xFC, 0x07, 0xC9, 0x0F, 0xF0, 0x9E, 0xFE, + 0xFC, 0x07, 0x60, 0xBD, 0xFC, 0x07, 0xF0, 0x95, 0xBD, 0x04, 0x08, 0xC9, 0x0F, 0xF0, 0x8E, 0xFE, + 0x04, 0x08, 0x60, 0xA4, 0xFA, 0xA5, 0xFB, 0x30, 0x02, 0xC8, 0xC8, 0x88, 0x98, 0x85, 0xFA, 0xC5, + 0xFB, 0xD0, 0x06, 0xA5, 0xFB, 0x49, 0xFF, 0x85, 0xFB, 0x98, 0x60, 0x7D, 0xF4, 0x07, 0x9D, 0xF4, + 0x07, 0x60, 0xBC, 0xE4, 0x07, 0x79, 0x3C, 0x06, 0x9D, 0xF4, 0x07, 0x98, 0x9D, 0x22, 0x05, 0x60, + 0x2D, 0x0A, 0xD2, 0x9D, 0xF4, 0x07, 0x60, 0x7D, 0xE4, 0x07, 0x9D, 0x22, 0x05, 0xA8, 0xB9, 0x3C, + 0x06, 0x9D, 0xF4, 0x07, 0x60, 0x9D, 0x22, 0x05, 0xA8, 0xBD, 0xF4, 0x07, 0x79, 0x3C, 0x06, 0x9D, + 0xF4, 0x07, 0x60, 0xC8, 0xFE, 0xC4, 0x07, 0xB1, 0xFC, 0x4A, 0x4A, 0x4A, 0x4A, 0x9D, 0x0C, 0x08, + 0xB1, 0xFC, 0x29, 0x0F, 0x9D, 0x14, 0x08, 0x60, 0x20, 0x5F, 0x0E, 0xA0, 0x0F, 0xA9, 0x00, 0x85, + 0xFE, 0xA9, 0x00, 0x85, 0xFF, 0x8A, 0xF0, 0x2E, 0xB1, 0xFE, 0x10, 0x01, 0xCA, 0x18, 0xA5, 0xFE, + 0x69, 0x10, 0x85, 0xFE, 0x90, 0xEF, 0xE6, 0xFF, 0xB0, 0xEB, 0x20, 0x5F, 0x0E, 0xA9, 0x00, 0x85, + 0xFC, 0x8A, 0x0A, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x69, 0x00, 0x85, 0xFE, + 0xA5, 0xFC, 0x69, 0x00, 0x85, 0xFF, 0xA9, 0x40, 0x8D, 0xB6, 0x08, 0xA9, 0x01, 0x8D, 0xB5, 0x08, + 0x8D, 0xB7, 0x08, 0x60, 0xC9, 0x10, 0x90, 0xB0, 0xC9, 0x20, 0x90, 0xCE, 0xC9, 0x30, 0xB0, 0x03, + 0x4C, 0xAE, 0x0E, 0xC9, 0x40, 0xB0, 0x09, 0x8A, 0x29, 0x0F, 0xF0, 0x03, 0x8D, 0xB4, 0x08, 0x60, + 0xC9, 0x50, 0x90, 0x71, 0xC9, 0x60, 0xB0, 0x06, 0xA9, 0x00, 0x8D, 0xB7, 0x08, 0x60, 0xC9, 0x70, + 0x90, 0xF8, 0xA9, 0x01, 0x8D, 0xB5, 0x08, 0xA9, 0x40, 0x8D, 0xB6, 0x08, 0x84, 0xFC, 0x86, 0xFD, + 0xA0, 0x1E, 0xB1, 0xFC, 0x8D, 0xB4, 0x08, 0xA5, 0xFC, 0x18, 0x69, 0x20, 0x8D, 0xC2, 0x0E, 0x90, + 0x01, 0xE8, 0x8E, 0xC3, 0x0E, 0x18, 0x69, 0x40, 0x8D, 0xCA, 0x0E, 0x90, 0x01, 0xE8, 0x8E, 0xCB, + 0x0E, 0x18, 0x69, 0x40, 0x8D, 0x52, 0x09, 0x90, 0x01, 0xE8, 0x8E, 0x53, 0x09, 0x18, 0x69, 0x80, + 0x8D, 0x57, 0x09, 0x90, 0x01, 0xE8, 0x8E, 0x58, 0x09, 0x18, 0x69, 0x80, 0x85, 0xFE, 0x8D, 0x10, + 0x09, 0x8D, 0x88, 0x0D, 0x8D, 0xB7, 0x0D, 0x90, 0x01, 0xE8, 0x86, 0xFF, 0x8E, 0x16, 0x09, 0x8E, + 0x8C, 0x0D, 0x8E, 0xBD, 0x0D, 0xA0, 0x07, 0xA9, 0x00, 0x8D, 0xB7, 0x08, 0x99, 0x00, 0xD2, 0x99, + 0x10, 0xD2, 0x99, 0x0A, 0x05, 0x99, 0xFC, 0x07, 0x99, 0x04, 0x08, 0x99, 0x32, 0x05, 0x99, 0xBC, + 0x07, 0x88, 0x10, 0xE8, 0x8D, 0x08, 0xD2, 0x8D, 0x18, 0xD2, 0x8D, 0x3A, 0x05, 0x8D, 0x3B, 0x05, + 0x60, 0x9D, 0xFC, 0x07, 0x9D, 0x04, 0x08, 0x9D, 0x32, 0x05, 0xBD, 0xE4, 0x07, 0x9D, 0x22, 0x05, + 0x60, 0x98, 0x49, 0xF0, 0x4A, 0x4A, 0x4A, 0x4A, 0x9D, 0x0C, 0x08, 0x98, 0x29, 0x0F, 0x49, 0x0F, + 0x9D, 0x14, 0x08, 0x60, 0x29, 0x07, 0x85, 0xFC, 0x8A, 0xA6, 0xFC, 0x29, 0x3F, 0xF0, 0xE2, 0x9D, + 0xE4, 0x07, 0xA9, 0x00, 0x9D, 0xBC, 0x07, 0xB9, 0xFF, 0xFF, 0x9D, 0x1C, 0x08, 0x85, 0xFC, 0xB9, + 0xFF, 0xFF, 0x9D, 0x24, 0x08, 0x85, 0xFD, 0x05, 0xFC, 0xF0, 0xB6, 0xA0, 0x4A, 0xB1, 0xFC, 0x9D, + 0x34, 0x08, 0x9D, 0x44, 0x08, 0xC8, 0xB1, 0xFC, 0x9D, 0x3C, 0x08, 0x9D, 0x4C, 0x08, 0xC8, 0xB1, + 0xFC, 0x29, 0x70, 0x4A, 0x4A, 0x9D, 0x54, 0x08, 0xB1, 0xFC, 0x29, 0x0F, 0x9D, 0x5C, 0x08, 0xB1, + 0xFC, 0x10, 0x0B, 0xBD, 0x5C, 0x08, 0x49, 0xFF, 0x18, 0x69, 0x01, 0x9D, 0x5C, 0x08, 0xC8, 0xB1, + 0xFC, 0x9D, 0x74, 0x08, 0xC8, 0xB1, 0xFC, 0x29, 0x3F, 0x9D, 0x7C, 0x08, 0x9D, 0x84, 0x08, 0xC8, + 0xB1, 0xFC, 0x29, 0x80, 0xF0, 0x02, 0xA9, 0x01, 0x9D, 0xAC, 0x08, 0xB1, 0xFC, 0x29, 0x70, 0x4A, + 0x4A, 0x4A, 0x4A, 0x9D, 0x8C, 0x08, 0xD0, 0x03, 0x9D, 0xAC, 0x08, 0xB1, 0xFC, 0x29, 0x0F, 0x9D, + 0x9C, 0x08, 0x9D, 0xA4, 0x08, 0x88, 0xB1, 0xFC, 0x29, 0xC0, 0x18, 0x7D, 0xE4, 0x07, 0x9D, 0xE4, + 0x07, 0x9D, 0x22, 0x05, 0xA8, 0xB9, 0x3C, 0x06, 0x9D, 0xF4, 0x07, 0xA9, 0x00, 0x9D, 0x2C, 0x08, + 0x9D, 0x64, 0x08, 0x9D, 0x6C, 0x08, 0x9D, 0x94, 0x08, 0xA9, 0x01, 0x9D, 0xBC, 0x07, 0x60 +}; +static const unsigned char tm2_obx[] = { + 0xFF, 0xFF, 0x00, 0x02, 0x6B, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, + 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, + 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, + 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, + 0x07, 0x07, 0x08, 0x09, 0x09, 0x0A, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, + 0x07, 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x0D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0xF1, 0xE4, 0xD7, 0xCB, 0xC0, 0xB5, 0xAA, 0xA1, 0x98, + 0x8F, 0x87, 0x7F, 0x78, 0x72, 0x6B, 0x65, 0x5F, 0x5A, 0x55, 0x50, 0x4B, 0x47, 0x43, 0x3F, 0x3C, + 0x38, 0x35, 0x32, 0x2F, 0x2C, 0x2A, 0x27, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, + 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0xF2, 0xE9, 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, + 0x8F, 0x89, 0x80, 0x7A, 0x71, 0x6B, 0x65, 0x5F, 0x5C, 0x56, 0x50, 0x4D, 0x47, 0x44, 0x3E, 0x3C, + 0x38, 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, + 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0xFF, 0xF1, 0xE4, 0xD8, 0xCA, 0xC0, 0xB5, 0xAB, 0xA2, + 0x99, 0x8E, 0x87, 0x7F, 0x79, 0x73, 0x70, 0x66, 0x61, 0x5A, 0x55, 0x52, 0x4B, 0x48, 0x43, 0x3F, + 0x3C, 0x39, 0x37, 0x33, 0x30, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x1C, 0x1B, 0x19, + 0x17, 0x16, 0x15, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, + 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xF3, 0xE6, 0xD9, 0xCC, 0xC1, 0xB5, 0xAD, 0xA2, 0x99, + 0x90, 0x88, 0x80, 0x79, 0x72, 0x6C, 0x66, 0x60, 0x5B, 0x55, 0x51, 0x4C, 0x48, 0x44, 0x40, 0x3C, + 0x39, 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, + 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, 0xEF, 0x80, 0x08, + 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, 0x22, 0xF4, 0xC8, + 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, 0x38, 0x27, 0x15, + 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, 0x78, 0x70, 0x6A, + 0x64, 0x5E, 0x57, 0x52, 0x32, 0x0A, 0x00, 0xF2, 0x33, 0x96, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, + 0x6A, 0xEF, 0x80, 0x08, 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, + 0x52, 0x22, 0xF4, 0xC8, 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, + 0x4E, 0x38, 0x27, 0x15, 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, + 0x7F, 0x78, 0x70, 0x6A, 0x64, 0x5E, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, + 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4C, 0xE4, 0x0D, 0x4C, 0xE3, 0x06, 0x4C, 0x9F, 0x08, 0x01, + 0x10, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, + 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x02, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x08, 0x00, 0x10, 0x00, 0x08, 0x85, 0xD3, 0x81, 0xA9, 0x85, 0xD3, 0x81, 0xA9, 0x88, 0xB1, + 0xFA, 0x8D, 0x17, 0x05, 0xA2, 0x00, 0x86, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, + 0xFC, 0x0A, 0x26, 0xFC, 0x6D, 0x17, 0x05, 0x90, 0x02, 0xE6, 0xFC, 0x18, 0x69, 0x00, 0x85, 0xFA, + 0xA5, 0xFC, 0x69, 0x00, 0x85, 0xFB, 0x4C, 0x07, 0x07, 0x20, 0xB5, 0x09, 0xAD, 0x16, 0x05, 0xF0, + 0x05, 0xCE, 0x1C, 0x05, 0x30, 0x03, 0x4C, 0xA2, 0x08, 0xCE, 0x1D, 0x05, 0xD0, 0x52, 0xA2, 0x00, + 0xEE, 0x17, 0x05, 0xAD, 0x19, 0x05, 0x85, 0xFA, 0xAD, 0x1A, 0x05, 0x85, 0xFB, 0xA0, 0x10, 0xB1, + 0xFA, 0x30, 0xAB, 0xD0, 0x03, 0x4C, 0x2C, 0x0F, 0x8D, 0x1D, 0x05, 0x88, 0xB1, 0xFA, 0x88, 0x84, + 0xFC, 0xA8, 0xB9, 0xFF, 0xFF, 0x9D, 0x50, 0x05, 0xB9, 0xFF, 0xFF, 0x9D, 0x58, 0x05, 0xA9, 0x00, + 0x9D, 0x70, 0x05, 0x9D, 0x60, 0x05, 0xA4, 0xFC, 0xB1, 0xFA, 0x9D, 0x68, 0x05, 0xE8, 0x88, 0x10, + 0xDB, 0xA9, 0x11, 0x18, 0x65, 0xFA, 0x8D, 0x19, 0x05, 0xA9, 0x00, 0x65, 0xFB, 0x8D, 0x1A, 0x05, + 0xAD, 0x1B, 0x05, 0x8D, 0x1C, 0x05, 0xA2, 0x07, 0xDE, 0x70, 0x05, 0x30, 0x06, 0xCA, 0x10, 0xF8, + 0x4C, 0xA2, 0x08, 0xBD, 0x50, 0x05, 0x85, 0xFA, 0xBD, 0x58, 0x05, 0x85, 0xFB, 0xBC, 0x60, 0x05, + 0xB1, 0xFA, 0xD0, 0x1C, 0xC8, 0xB1, 0xFA, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, 0xB1, + 0xFA, 0x0A, 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0x4C, 0x57, 0x07, + 0xC9, 0x40, 0xB0, 0x4F, 0x7D, 0x68, 0x05, 0x9D, 0x98, 0x05, 0xC8, 0xB1, 0xFA, 0x10, 0x25, 0x29, + 0x7F, 0x85, 0xFC, 0xC8, 0xB1, 0xFA, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, 0xB1, 0xFA, + 0x0A, 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0xA4, 0xFC, 0x20, 0x9C, + 0x0F, 0x4C, 0x57, 0x07, 0xA8, 0xFE, 0x60, 0x05, 0xFE, 0x60, 0x05, 0xBD, 0xD0, 0x05, 0x29, 0xF0, + 0x9D, 0xD8, 0x05, 0xBD, 0xD0, 0x05, 0x0A, 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0x20, 0x9C, 0x0F, + 0x4C, 0x57, 0x07, 0xC9, 0x80, 0xB0, 0x25, 0x29, 0x3F, 0x18, 0x7D, 0x68, 0x05, 0x9D, 0x98, 0x05, + 0xC8, 0xB1, 0xFA, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, 0xB1, 0xFA, 0x0A, 0x0A, 0x0A, + 0x0A, 0x9D, 0xE0, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xD0, 0x0E, 0xC8, 0xB1, + 0xFA, 0x9D, 0x70, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xC9, 0xC0, 0xB0, 0x0F, + 0x29, 0x3F, 0x18, 0x7D, 0x68, 0x05, 0x9D, 0x98, 0x05, 0xFE, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xC9, + 0xD0, 0xB0, 0x0F, 0xC8, 0xFE, 0x60, 0x05, 0x29, 0x0F, 0x8D, 0x1B, 0x05, 0x8D, 0x1C, 0x05, 0x4C, + 0x6A, 0x07, 0xC9, 0xE0, 0xB0, 0x16, 0xB1, 0xFA, 0x85, 0xFC, 0xC8, 0xB1, 0xFA, 0x85, 0xFD, 0xC8, + 0x98, 0x9D, 0x60, 0x05, 0xA5, 0xFC, 0x20, 0x0E, 0x0E, 0x4C, 0x57, 0x07, 0xC9, 0xF0, 0xB0, 0x2E, + 0xB1, 0xFA, 0x85, 0xFC, 0xC8, 0xB1, 0xFA, 0x85, 0xFD, 0xA5, 0xFC, 0x20, 0x0E, 0x0E, 0xBC, 0x60, + 0x05, 0xC8, 0xC8, 0xB1, 0xFA, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, 0xB1, 0xFA, 0x0A, + 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xC9, 0xFF, + 0xB0, 0x0B, 0xE9, 0xEF, 0x9D, 0x70, 0x05, 0xFE, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xA9, 0x40, 0x9D, + 0x70, 0x05, 0x4C, 0x57, 0x07, 0x20, 0xB5, 0x09, 0xA2, 0x07, 0xBD, 0x78, 0x05, 0xF0, 0x73, 0x4C, + 0xD9, 0x0A, 0xBD, 0x0E, 0x05, 0xF0, 0x0E, 0xA9, 0x00, 0x9D, 0x20, 0x05, 0x9D, 0x28, 0x05, 0xCA, + 0x10, 0xE8, 0x4C, 0x1F, 0x09, 0xA4, 0xFD, 0xB9, 0x00, 0x03, 0x18, 0x65, 0xFC, 0x9D, 0x38, 0x05, + 0x98, 0x9D, 0xA0, 0x05, 0xBD, 0xB0, 0x05, 0x3D, 0xA8, 0x06, 0xF0, 0x28, 0xA5, 0xFD, 0x29, 0x7F, + 0xA8, 0xB9, 0x00, 0x04, 0x18, 0x65, 0xFC, 0x9D, 0x37, 0x05, 0xB9, 0x80, 0x04, 0x69, 0x00, 0x9D, + 0x38, 0x05, 0xA9, 0x00, 0x9D, 0x1F, 0x05, 0xBC, 0x98, 0x06, 0x99, 0x27, 0x05, 0xCA, 0xCA, 0x10, + 0xA9, 0x4C, 0x1F, 0x09, 0xBD, 0xB0, 0x05, 0x3D, 0xA0, 0x06, 0xF0, 0x16, 0xBD, 0x68, 0x06, 0x18, + 0x65, 0xFD, 0x9D, 0xA2, 0x05, 0xA8, 0xB9, 0x00, 0x03, 0x18, 0x65, 0xFC, 0x38, 0x65, 0xFE, 0x9D, + 0x3A, 0x05, 0xCA, 0x10, 0x85, 0xE8, 0x86, 0xFC, 0xA2, 0x03, 0xAD, 0x09, 0x05, 0xF0, 0x06, 0x29, + 0x40, 0xD0, 0x3C, 0xA2, 0x07, 0x8A, 0xA8, 0xB9, 0x20, 0x05, 0xD0, 0x0C, 0xBC, 0x98, 0x06, 0xB9, + 0x28, 0x05, 0xD0, 0x04, 0x8A, 0xA8, 0xA9, 0x00, 0x19, 0xA8, 0x05, 0x9D, 0x30, 0x05, 0xB9, 0x38, + 0x05, 0x9D, 0x48, 0x05, 0xB9, 0xA0, 0x05, 0x9D, 0x40, 0x05, 0xB9, 0xB0, 0x05, 0x05, 0xFC, 0x85, + 0xFC, 0xE0, 0x04, 0xD0, 0x03, 0x8D, 0x1F, 0x05, 0xCA, 0x10, 0xCA, 0x8D, 0x1E, 0x05, 0x60, 0xBD, + 0x20, 0x05, 0x1D, 0xA8, 0x05, 0x9D, 0x30, 0x05, 0xBD, 0x2C, 0x05, 0x1D, 0xAC, 0x05, 0x9D, 0x34, + 0x05, 0xBD, 0x38, 0x05, 0x9D, 0x48, 0x05, 0xBD, 0x3C, 0x05, 0x9D, 0x4C, 0x05, 0xBD, 0xA0, 0x05, + 0x9D, 0x40, 0x05, 0xBD, 0xA4, 0x05, 0x9D, 0x44, 0x05, 0xCA, 0x10, 0xD3, 0xAD, 0xB0, 0x05, 0x0D, + 0xB1, 0x05, 0x0D, 0xB2, 0x05, 0x0D, 0xB3, 0x05, 0x8D, 0x1E, 0x05, 0xAD, 0xB4, 0x05, 0x0D, 0xB5, + 0x05, 0x0D, 0xB6, 0x05, 0x0D, 0xB7, 0x05, 0x8D, 0x1F, 0x05, 0x60, 0xAD, 0x09, 0x05, 0xD0, 0x03, + 0x4C, 0x90, 0x0A, 0x30, 0x03, 0x4C, 0x48, 0x0A, 0xAD, 0x0D, 0x05, 0xAA, 0x4A, 0x4A, 0x29, 0x01, + 0xA8, 0xB9, 0x1E, 0x05, 0x8D, 0x38, 0xD2, 0x8A, 0x29, 0x04, 0xA8, 0xB9, 0x38, 0x05, 0x8D, 0x30, + 0xD2, 0xBD, 0x20, 0x05, 0x8D, 0x31, 0xD2, 0xB9, 0x39, 0x05, 0x8D, 0x32, 0xD2, 0xBD, 0x21, 0x05, + 0x8D, 0x33, 0xD2, 0xB9, 0x3A, 0x05, 0x8D, 0x34, 0xD2, 0xBD, 0x22, 0x05, 0x8D, 0x35, 0xD2, 0xB9, + 0x3B, 0x05, 0x8D, 0x36, 0xD2, 0xBD, 0x23, 0x05, 0x8D, 0x37, 0xD2, 0xAD, 0x0C, 0x05, 0xAA, 0x4A, + 0x4A, 0x29, 0x01, 0xA8, 0xB9, 0x1E, 0x05, 0x8D, 0x28, 0xD2, 0x8A, 0x29, 0x04, 0xA8, 0xB9, 0x38, + 0x05, 0x8D, 0x20, 0xD2, 0xBD, 0x20, 0x05, 0x8D, 0x21, 0xD2, 0xB9, 0x39, 0x05, 0x8D, 0x22, 0xD2, + 0xBD, 0x21, 0x05, 0x8D, 0x23, 0xD2, 0xB9, 0x3A, 0x05, 0x8D, 0x24, 0xD2, 0xBD, 0x22, 0x05, 0x8D, + 0x25, 0xD2, 0xB9, 0x3B, 0x05, 0x8D, 0x26, 0xD2, 0xBD, 0x23, 0x05, 0x8D, 0x27, 0xD2, 0xAD, 0x0B, + 0x05, 0xAA, 0x4A, 0x4A, 0x29, 0x01, 0xA8, 0xB9, 0x1E, 0x05, 0x8D, 0x18, 0xD2, 0x8A, 0xAC, 0x09, + 0x05, 0x10, 0x02, 0x29, 0x04, 0xA8, 0xB9, 0x38, 0x05, 0x8D, 0x10, 0xD2, 0xBD, 0x20, 0x05, 0x8D, + 0x11, 0xD2, 0xB9, 0x39, 0x05, 0x8D, 0x12, 0xD2, 0xBD, 0x21, 0x05, 0x8D, 0x13, 0xD2, 0xB9, 0x3A, + 0x05, 0x8D, 0x14, 0xD2, 0xBD, 0x22, 0x05, 0x8D, 0x15, 0xD2, 0xB9, 0x3B, 0x05, 0x8D, 0x16, 0xD2, + 0xBD, 0x23, 0x05, 0x8D, 0x17, 0xD2, 0xAD, 0x0A, 0x05, 0xAA, 0x4A, 0x4A, 0x29, 0x01, 0xA8, 0xB9, + 0x1E, 0x05, 0x8D, 0x08, 0xD2, 0x8A, 0xAC, 0x09, 0x05, 0x10, 0x02, 0x29, 0x04, 0xA8, 0xB9, 0x38, + 0x05, 0x8D, 0x00, 0xD2, 0xBD, 0x20, 0x05, 0x8D, 0x01, 0xD2, 0xB9, 0x39, 0x05, 0x8D, 0x02, 0xD2, + 0xBD, 0x21, 0x05, 0x8D, 0x03, 0xD2, 0xB9, 0x3A, 0x05, 0x8D, 0x04, 0xD2, 0xBD, 0x22, 0x05, 0x8D, + 0x05, 0xD2, 0xB9, 0x3B, 0x05, 0x8D, 0x06, 0xD2, 0xBD, 0x23, 0x05, 0x8D, 0x07, 0xD2, 0x60, 0xBD, + 0x80, 0x05, 0x85, 0xFA, 0xBD, 0x88, 0x05, 0x85, 0xFB, 0xBD, 0x80, 0x06, 0x85, 0xFC, 0xBD, 0x88, + 0x06, 0x85, 0xFD, 0xBD, 0x90, 0x06, 0x85, 0xFE, 0xBD, 0xB8, 0x05, 0xDD, 0xC0, 0x05, 0x90, 0x0C, + 0x9D, 0x08, 0x06, 0xBD, 0xC8, 0x05, 0x9D, 0xB8, 0x05, 0x4C, 0x0B, 0x0B, 0xBD, 0x08, 0x06, 0xF0, + 0x30, 0xBD, 0xE8, 0x05, 0xF0, 0x13, 0xDE, 0xF8, 0x05, 0xD0, 0x0E, 0x9D, 0xF8, 0x05, 0xBD, 0xD8, + 0x05, 0xF0, 0x06, 0x38, 0xE9, 0x10, 0x9D, 0xD8, 0x05, 0xBD, 0xF0, 0x05, 0xF0, 0x13, 0xDE, 0x00, + 0x06, 0xD0, 0x0E, 0x9D, 0x00, 0x06, 0xBD, 0xE0, 0x05, 0xF0, 0x06, 0x38, 0xE9, 0x10, 0x9D, 0xE0, + 0x05, 0xBC, 0x48, 0x06, 0xB1, 0xFA, 0x18, 0x7D, 0x98, 0x05, 0x18, 0x65, 0xFD, 0x85, 0xFD, 0xDE, + 0x58, 0x06, 0x10, 0x39, 0xBD, 0x50, 0x06, 0x9D, 0x58, 0x06, 0xBD, 0x60, 0x06, 0xF0, 0x1E, 0x18, + 0x7D, 0x48, 0x06, 0x9D, 0x48, 0x06, 0xF0, 0x0D, 0xDD, 0x40, 0x06, 0x90, 0x20, 0xA9, 0xFF, 0x9D, + 0x60, 0x06, 0x4C, 0x87, 0x0B, 0xA9, 0x01, 0x9D, 0x60, 0x06, 0x4C, 0x87, 0x0B, 0xFE, 0x48, 0x06, + 0xBD, 0x40, 0x06, 0xDD, 0x48, 0x06, 0xB0, 0x05, 0xA9, 0x00, 0x9D, 0x48, 0x06, 0xA9, 0x13, 0x18, + 0x65, 0xFA, 0x85, 0xFA, 0x90, 0x02, 0xE6, 0xFB, 0xBC, 0xB8, 0x05, 0xB1, 0xFA, 0x29, 0xF0, 0x9D, + 0xA8, 0x05, 0xB1, 0xFA, 0x29, 0x0F, 0x1D, 0xD8, 0x05, 0xA8, 0xB9, 0x00, 0x02, 0x05, 0xFF, 0xA8, + 0xB9, 0x00, 0x02, 0x9D, 0x20, 0x05, 0xBC, 0xB8, 0x05, 0xC8, 0xB1, 0xFA, 0x29, 0x0F, 0x1D, 0xE0, + 0x05, 0xA8, 0xB9, 0x00, 0x02, 0x05, 0xFF, 0xA8, 0xB9, 0x00, 0x02, 0x9D, 0x28, 0x05, 0xBD, 0x28, + 0x06, 0xD0, 0x27, 0xBD, 0x10, 0x06, 0x8D, 0xD4, 0x0B, 0x10, 0xFE, 0x4C, 0xD1, 0x0C, 0xEA, 0x4C, + 0x6C, 0x0C, 0xEA, 0x4C, 0xA7, 0x0C, 0xEA, 0x4C, 0xD4, 0x0C, 0xEA, 0x4C, 0x01, 0x0D, 0xEA, 0x4C, + 0x21, 0x0D, 0xEA, 0x4C, 0x41, 0x0D, 0xEA, 0x4C, 0x49, 0x0D, 0xDE, 0x28, 0x06, 0xBC, 0xB8, 0x05, + 0xC8, 0xB1, 0xFA, 0x29, 0x70, 0x4A, 0x4A, 0x4A, 0x8D, 0x22, 0x0C, 0xB1, 0xFA, 0x30, 0x06, 0xBD, + 0x70, 0x06, 0x4C, 0x12, 0x0C, 0xBD, 0x78, 0x06, 0x3D, 0xB0, 0x06, 0x9D, 0xB0, 0x05, 0xC8, 0xC8, + 0x98, 0x9D, 0xB8, 0x05, 0x88, 0xB1, 0xFA, 0x90, 0xFE, 0x90, 0x16, 0x90, 0x0C, 0x90, 0x22, 0x90, + 0x18, 0x90, 0x2E, 0x90, 0x24, 0x90, 0x32, 0x90, 0x34, 0x7D, 0x80, 0x06, 0x9D, 0x80, 0x06, 0xB1, + 0xFA, 0x18, 0x65, 0xFC, 0x85, 0xFC, 0x4C, 0xAC, 0x08, 0x7D, 0x88, 0x06, 0x9D, 0x88, 0x06, 0xB1, + 0xFA, 0x18, 0x65, 0xFD, 0x85, 0xFD, 0x4C, 0xAC, 0x08, 0x7D, 0x90, 0x06, 0x9D, 0x90, 0x06, 0xB1, + 0xFA, 0x18, 0x65, 0xFE, 0x85, 0xFE, 0x4C, 0xAC, 0x08, 0x85, 0xFC, 0xA9, 0x00, 0x85, 0xFD, 0x4C, + 0xAC, 0x08, 0xBD, 0x20, 0x06, 0x29, 0x03, 0x4A, 0x90, 0x0A, 0xD0, 0x19, 0xBD, 0x18, 0x06, 0x18, + 0x65, 0xFC, 0x85, 0xFC, 0xDE, 0x38, 0x06, 0x10, 0x4E, 0xFE, 0x20, 0x06, 0xBD, 0x30, 0x06, 0x9D, + 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xA5, 0xFC, 0xFD, 0x18, 0x06, 0x85, 0xFC, 0xDE, 0x38, 0x06, 0x10, + 0x36, 0xFE, 0x20, 0x06, 0xBD, 0x30, 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xBC, 0x20, 0x06, + 0xBD, 0x18, 0x06, 0x30, 0x02, 0xC8, 0xC8, 0x88, 0x98, 0x18, 0x65, 0xFC, 0x85, 0xFC, 0xDE, 0x38, + 0x06, 0x10, 0x14, 0x98, 0x9D, 0x20, 0x06, 0xDD, 0x18, 0x06, 0xD0, 0x05, 0x49, 0xFF, 0x9D, 0x18, + 0x06, 0xBD, 0x30, 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xBC, 0x20, 0x06, 0xBD, 0x18, 0x06, + 0x30, 0x02, 0xC8, 0xC8, 0x88, 0x98, 0x18, 0x65, 0xFD, 0x85, 0xFD, 0xDE, 0x38, 0x06, 0x10, 0xE7, + 0x98, 0x9D, 0x20, 0x06, 0xDD, 0x18, 0x06, 0xD0, 0xD8, 0x49, 0xFF, 0x9D, 0x18, 0x06, 0xBD, 0x30, + 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xBD, 0x20, 0x06, 0x18, 0x65, 0xFC, 0x85, 0xFC, 0xDE, + 0x38, 0x06, 0x10, 0xC3, 0xBD, 0x18, 0x06, 0x18, 0x7D, 0x20, 0x06, 0x9D, 0x20, 0x06, 0xBD, 0x30, + 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xA5, 0xFD, 0x38, 0xFD, 0x20, 0x06, 0x85, 0xFD, 0xDE, + 0x38, 0x06, 0x10, 0xA3, 0xBD, 0x18, 0x06, 0x18, 0x7D, 0x20, 0x06, 0x9D, 0x20, 0x06, 0xBD, 0x30, + 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xBD, 0x18, 0x06, 0x18, 0x65, 0xFC, 0x85, 0xFC, 0x4C, + 0xF7, 0x0B, 0xA0, 0x10, 0xA9, 0x00, 0x85, 0xFA, 0xA9, 0x00, 0x85, 0xFB, 0xA9, 0x00, 0x8D, 0x17, + 0x05, 0x8A, 0xF0, 0x3F, 0xB1, 0xFA, 0xF0, 0x02, 0x10, 0x01, 0xCA, 0xA9, 0x11, 0x18, 0x65, 0xFA, + 0x85, 0xFA, 0x90, 0x02, 0xE6, 0xFB, 0xEE, 0x17, 0x05, 0xD0, 0xE6, 0xA2, 0x00, 0xA9, 0x00, 0x85, + 0xFC, 0x8A, 0x8D, 0x17, 0x05, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, + 0xFC, 0x6D, 0x17, 0x05, 0x90, 0x02, 0xE6, 0xFC, 0x18, 0x69, 0x00, 0x85, 0xFA, 0xA5, 0xFC, 0x69, + 0x00, 0x85, 0xFB, 0x20, 0x2C, 0x0F, 0xA5, 0xFA, 0x8D, 0x19, 0x05, 0xA5, 0xFB, 0x8D, 0x1A, 0x05, + 0xA2, 0x07, 0xA9, 0xFF, 0x9D, 0xD0, 0x05, 0xA9, 0xF0, 0x9D, 0xD8, 0x05, 0x9D, 0xE0, 0x05, 0xCA, + 0x10, 0xF0, 0xA9, 0x03, 0x8D, 0x0F, 0xD2, 0x8D, 0x1F, 0xD2, 0x8D, 0x2F, 0xD2, 0x8D, 0x3F, 0xD2, + 0xCE, 0x17, 0x05, 0xE8, 0x8E, 0x1C, 0x05, 0xE8, 0x8E, 0x1D, 0x05, 0x8E, 0x16, 0x05, 0x60, 0x8A, + 0x29, 0x0F, 0x8D, 0x1B, 0x05, 0x60, 0x8E, 0x16, 0x05, 0x60, 0xC9, 0x10, 0xB0, 0x03, 0x4C, 0x4C, + 0x0D, 0xC9, 0x20, 0x90, 0x88, 0xC9, 0x30, 0xB0, 0x03, 0x4C, 0x85, 0x0F, 0xC9, 0x40, 0x90, 0xDF, + 0xC9, 0x50, 0xB0, 0x03, 0x4C, 0x2C, 0x0F, 0xC9, 0x60, 0x90, 0xDB, 0xC9, 0x70, 0x90, 0x03, 0x4C, + 0xB4, 0x0E, 0x84, 0xFD, 0x29, 0x0F, 0x0A, 0x8D, 0x17, 0x0E, 0xA5, 0xFD, 0x90, 0xFE, 0x90, 0x1E, + 0x90, 0x38, 0x90, 0x59, 0x90, 0x60, 0x90, 0x1A, 0x90, 0x1C, 0x90, 0x1E, 0x90, 0x20, 0x90, 0x22, + 0x90, 0x24, 0x90, 0x0D, 0x90, 0x0B, 0x90, 0x09, 0x90, 0x07, 0x90, 0x05, 0x90, 0x03, 0x8D, 0x18, + 0x05, 0x60, 0x9D, 0x68, 0x06, 0x60, 0x9D, 0x70, 0x06, 0x60, 0x9D, 0x78, 0x06, 0x60, 0x9D, 0x90, + 0x06, 0x60, 0x9D, 0x80, 0x06, 0x60, 0x9D, 0x88, 0x06, 0x60, 0x29, 0x70, 0x4A, 0x4A, 0x9D, 0x10, + 0x06, 0x29, 0x30, 0xD0, 0x03, 0x9D, 0x20, 0x06, 0xA5, 0xFD, 0x30, 0x06, 0x29, 0x0F, 0x9D, 0x18, + 0x06, 0x60, 0x29, 0x0F, 0x49, 0xFF, 0x18, 0x69, 0x01, 0x9D, 0x18, 0x06, 0x60, 0x29, 0x3F, 0x9D, + 0x30, 0x06, 0x9D, 0x38, 0x06, 0x60, 0x29, 0x80, 0x0A, 0x2A, 0x9D, 0x60, 0x06, 0xA5, 0xFD, 0x29, + 0x70, 0x4A, 0x4A, 0x4A, 0x4A, 0x9D, 0x40, 0x06, 0xD0, 0x03, 0x9D, 0x60, 0x06, 0xA5, 0xFD, 0x29, + 0x0F, 0x9D, 0x50, 0x06, 0x9D, 0x58, 0x06, 0xBD, 0x48, 0x06, 0xDD, 0x40, 0x06, 0x90, 0x8F, 0xBD, + 0x40, 0x06, 0xF0, 0x02, 0xE9, 0x01, 0x9D, 0x48, 0x06, 0x60, 0x84, 0xFA, 0x86, 0xFB, 0xA0, 0x19, + 0xB1, 0xFA, 0xC8, 0x8D, 0x09, 0x05, 0xB1, 0xFA, 0xC8, 0x8D, 0x0A, 0x05, 0xB1, 0xFA, 0xC8, 0x8D, + 0x0B, 0x05, 0xB1, 0xFA, 0xC8, 0x8D, 0x0C, 0x05, 0xB1, 0xFA, 0xC8, 0x8D, 0x0D, 0x05, 0xB1, 0xFA, + 0x8D, 0x1B, 0x05, 0xA5, 0xFA, 0x49, 0x80, 0x30, 0x01, 0xE8, 0x8D, 0xAC, 0x0F, 0x8E, 0xAD, 0x0F, + 0x49, 0x80, 0x30, 0x01, 0xE8, 0x8D, 0x1D, 0x07, 0x8E, 0x1E, 0x07, 0xE8, 0x8D, 0x23, 0x07, 0x8E, + 0x24, 0x07, 0xE8, 0x8D, 0xA2, 0x0F, 0x8E, 0xA3, 0x0F, 0x49, 0x80, 0x30, 0x01, 0xE8, 0x8D, 0x19, + 0x05, 0x8D, 0xD7, 0x06, 0x8D, 0x4F, 0x0D, 0x8D, 0x94, 0x0D, 0x8E, 0x1A, 0x05, 0x8E, 0xDD, 0x06, + 0x8E, 0x53, 0x0D, 0x8E, 0x9A, 0x0D, 0xA9, 0xF0, 0x85, 0xFF, 0xA9, 0x00, 0x8D, 0x16, 0x05, 0x8D, + 0x18, 0x05, 0xA2, 0x07, 0xA9, 0x00, 0x8D, 0x16, 0x05, 0x9D, 0x78, 0x05, 0x9D, 0xB0, 0x05, 0x9D, + 0x20, 0x05, 0x9D, 0x28, 0x05, 0x9D, 0x30, 0x05, 0x9D, 0x30, 0xD2, 0x9D, 0x20, 0xD2, 0x9D, 0x10, + 0xD2, 0x9D, 0x00, 0xD2, 0xCA, 0x10, 0xE2, 0x8D, 0x18, 0xD2, 0x8D, 0x08, 0xD2, 0x8D, 0x38, 0xD2, + 0x8D, 0x28, 0xD2, 0x8D, 0x1E, 0x05, 0x8D, 0x1F, 0x05, 0x60, 0x9D, 0x20, 0x05, 0x9D, 0x28, 0x05, + 0x9D, 0x30, 0x05, 0x9D, 0xB0, 0x05, 0x60, 0x98, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, + 0xBD, 0xD0, 0x05, 0x0A, 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0x60, 0x29, 0x07, 0x85, 0xFA, 0x8A, + 0xA6, 0xFA, 0x29, 0x3F, 0xF0, 0xE1, 0x9D, 0x98, 0x05, 0x98, 0x30, 0xEE, 0xBD, 0xD0, 0x05, 0x20, + 0x75, 0x0F, 0xA9, 0x00, 0x9D, 0x78, 0x05, 0xB9, 0xFF, 0xFF, 0xF0, 0xBE, 0x9D, 0x88, 0x05, 0x85, + 0xFB, 0xB9, 0xFF, 0xFF, 0x9D, 0x80, 0x05, 0x85, 0xFA, 0x98, 0x9D, 0x90, 0x05, 0xA0, 0x08, 0xB1, + 0xFA, 0xC8, 0x9D, 0xC0, 0x05, 0xB1, 0xFA, 0xC8, 0x9D, 0xC8, 0x05, 0xB1, 0xFA, 0xC8, 0x9D, 0x68, + 0x06, 0xB1, 0xFA, 0xC8, 0x9D, 0x70, 0x06, 0xB1, 0xFA, 0xC8, 0x9D, 0x78, 0x06, 0xB1, 0xFA, 0xC8, + 0x9D, 0xE8, 0x05, 0x9D, 0xF8, 0x05, 0xB1, 0xFA, 0xC8, 0x9D, 0xF0, 0x05, 0x9D, 0x00, 0x06, 0xB1, + 0xFA, 0x29, 0x70, 0x4A, 0x4A, 0x9D, 0x10, 0x06, 0xB1, 0xFA, 0xC8, 0x30, 0x08, 0x29, 0x0F, 0x9D, + 0x18, 0x06, 0x4C, 0x09, 0x10, 0x29, 0x0F, 0x49, 0xFF, 0x18, 0x69, 0x01, 0x9D, 0x18, 0x06, 0xB1, + 0xFA, 0xC8, 0x9D, 0x28, 0x06, 0xB1, 0xFA, 0xC8, 0x29, 0x3F, 0x9D, 0x30, 0x06, 0x9D, 0x38, 0x06, + 0xB1, 0xFA, 0x29, 0x80, 0x0A, 0x2A, 0x9D, 0x60, 0x06, 0xB1, 0xFA, 0x29, 0x70, 0x4A, 0x4A, 0x4A, + 0x4A, 0x9D, 0x40, 0x06, 0xD0, 0x03, 0x9D, 0x60, 0x06, 0xB1, 0xFA, 0x88, 0x29, 0x0F, 0x9D, 0x50, + 0x06, 0x9D, 0x58, 0x06, 0xB1, 0xFA, 0x29, 0xC0, 0x1D, 0x98, 0x05, 0x9D, 0x98, 0x05, 0xA8, 0xB9, + 0x00, 0x03, 0x9D, 0x38, 0x05, 0xA9, 0x00, 0x9D, 0xB8, 0x05, 0x9D, 0x20, 0x06, 0x9D, 0x08, 0x06, + 0x9D, 0x48, 0x06, 0x9D, 0x80, 0x06, 0x9D, 0x88, 0x06, 0x9D, 0x90, 0x06, 0xA9, 0x01, 0x9D, 0x78, + 0x05, 0x60 +}; Index: apps/plugins/asap/asap_internal.h =================================================================== --- apps/plugins/asap/asap_internal.h (revision 0) +++ apps/plugins/asap/asap_internal.h (revision 0) @@ -0,0 +1,102 @@ +/* + * asap_internal.h - private interface of the ASAP engine + * + * Copyright (C) 2005-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef _ASAP_INTERNAL_H_ +#define _ASAP_INTERNAL_H_ + +#include "plugin.h" +#define memset rb->memset +#define memcpy rb->memcpy +#define memcmp rb->memcmp +#define strcmp rb->strcmp +#define strcpy rb->strcpy +#define strstr rb->strcasestr +extern const struct plugin_api* rb; + +#if !defined(JAVA) && !defined(CSHARP) + +#include "asap.h" + +#define CONST_LOOKUP(type, name) \ + static const type name[] +#define FILE_FUNC static +#define ASAP_FUNC +#define PTR * +#define ADDRESSOF & +#define ARRAY * +#define VOIDPTR void * +#define UBYTE(data) (data) +#define SBYTE(data) (signed char) (data) +#define STRING const char * +#define ZERO_ARRAY(array) memset(array, 0, sizeof(array)) +#define COPY_ARRAY(dest, dest_offset, src, src_offset, len) \ + memcpy(dest + dest_offset, src + src_offset, len) +#define NEW_ARRAY(type, name, size) \ + type name[size] +#define INIT_ARRAY(array) memset(array, 0, sizeof(array)) + +#define AST ast-> +#define PST pst-> +#define MODULE_INFO module_info-> +#define ASAP_OBX const byte * +#define GET_OBX(name) name##_obx + +int ASAP_GetByte(ASAP_State *ast, int addr); +void ASAP_PutByte(ASAP_State *ast, int addr, int data); + +void Cpu_RunScanlines(ASAP_State *ast, int scanlines); + +void PokeySound_Initialize(ASAP_State *ast); +void PokeySound_StartFrame(ASAP_State *ast); +void PokeySound_PutByte(ASAP_State *ast, int addr, int data); +int PokeySound_GetRandom(ASAP_State *ast, int addr); +void PokeySound_EndFrame(ASAP_State *ast, int cycle_limit); +int PokeySound_Generate(ASAP_State *ast, byte buffer[], int buffer_offset, int blocks, ASAP_SampleFormat format); +abool PokeySound_IsSilent(const PokeyState *pst); +void PokeySound_Mute(const ASAP_State *ast, PokeyState *pst, int mask); + +#ifdef ASAPSCAN +abool call_6502_player(ASAP_State *ast); +extern abool cpu_trace; +void print_cpu_state(const ASAP_State *ast, int pc, int a, int x, int y, int s, int nz, int vdi, int c); +#endif + +#endif /* !defined(JAVA) && !defined(CSHARP) */ + +#define ASAP_MAIN_CLOCK 1773447 + +#define V_FLAG 0x40 +#define D_FLAG 0x08 +#define I_FLAG 0x04 +#define Z_FLAG 0x02 + +#define NEVER 0x800000 + +#define dGetByte(addr) UBYTE(AST memory[addr]) +#define dPutByte(addr, data) AST memory[addr] = (byte) (data) +#define dGetWord(addr) (dGetByte(addr) + (dGetByte((addr) + 1) << 8)) +#define GetByte(addr) (((addr) & 0xf900) == 0xd000 ? ASAP_GetByte(ast, addr) : dGetByte(addr)) +#define PutByte(addr, data) do { if (((addr) & 0xf900) == 0xd000) ASAP_PutByte(ast, addr, data); else dPutByte(addr, data); } while (FALSE) +#define RMW_GetByte(dest, addr) do { if (((addr) >> 8) == 0xd2) { dest = ASAP_GetByte(ast, addr); AST cycle--; ASAP_PutByte(ast, addr, dest); AST cycle++; } else dest = dGetByte(addr); } while (FALSE) + +#endif /* _ASAP_INTERNAL_H_ */ Index: apps/plugins/asap/raw2c.pl =================================================================== --- apps/plugins/asap/raw2c.pl (revision 0) +++ apps/plugins/asap/raw2c.pl (revision 0) @@ -0,0 +1,16 @@ +#!/usr/bin/perl -w +# Turns binary files into C source code (static const unsigned char arrays). +use strict; +for (@ARGV) { + open INPUT, $_ and binmode INPUT or die "$_: $!\n"; + s!.*[/\\]!!; + y/0-9A-Za-z/_/c; + print "static const unsigned char ${_}[] = {\n\t"; + my $buf; + print join ', ', map sprintf('0x%02X', $_), unpack 'C*', $buf + if read INPUT, $buf, 16; + print ",\n\t", join ', ', map sprintf('0x%02X', $_), unpack 'C*', $buf + while read INPUT, $buf, 16; + close INPUT; + print "\n};\n" +} Index: apps/plugins/asap/acpu.c =================================================================== --- apps/plugins/asap/acpu.c (revision 0) +++ apps/plugins/asap/acpu.c (revision 0) @@ -0,0 +1,1262 @@ +/* + * acpu.c - another 6502 CPU emulator + * + * Copyright (C) 2007-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "asap_internal.h" + +CONST_LOOKUP(int, opcode_cycles) = +{ +/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ + 7, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6, /* 0x */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 1x */ + 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6, /* 2x */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 3x */ + 6, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6, /* 4x */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 5x */ + 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6, /* 6x */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 7x */ + 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* 8x */ + 2, 6, 2, 6, 4, 4, 4, 4, 2, 5, 2, 5, 5, 5, 5, 5, /* 9x */ + 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* Ax */ + 2, 5, 2, 5, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4, /* Bx */ + 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* Cx */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* Dx */ + 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* Ex */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7 /* Fx */ +}; + +#define DO_ADC \ + if ((vdi & D_FLAG) == 0) { \ + /* binary mode */ \ + int tmp = a + data + c; \ + c = tmp >> 8; \ + vdi &= D_FLAG | I_FLAG; \ + if (((a ^ data) & 0x80) == 0 && ((data ^ tmp) & 0x80) != 0) \ + vdi += V_FLAG; \ + nz = a = tmp & 0xff; \ + } \ + else { \ + /* decimal mode */ \ + int tmp = (a & 0x0f) + (data & 0x0f) + c; \ + if (tmp >= 10) \ + tmp = (tmp - 10) | 0x10; \ + tmp += (a & 0xf0) + (data & 0xf0); \ + nz = ((tmp & 0x80) << 1) + ((a + data + c) & 0xff); \ + vdi &= D_FLAG | I_FLAG; \ + if (((a ^ data) & 0x80) == 0 && ((data ^ tmp) & 0x80) != 0) \ + vdi += V_FLAG; \ + if (tmp > 0x9f) \ + tmp += 0x60; \ + c = (tmp > 0xff) ? 1 : 0; \ + a = tmp & 0xff; \ + } + +#define DO_SBC \ + if ((vdi & D_FLAG) == 0) { \ + /* binary mode */ \ + int tmp = a - data - 1 + c; \ + c = (tmp >= 0) ? 1 : 0; \ + vdi &= D_FLAG | I_FLAG; \ + if (((a ^ tmp) & 0x80) != 0 && ((a ^ data) & 0x80) != 0) \ + vdi += V_FLAG; \ + nz = a = tmp & 0xff; \ + } \ + else { \ + /* decimal mode */ \ + int tmp = a - data - 1 + c; \ + int al = (a & 0x0f) - (data & 0x0f) - 1 + c; \ + int ah = (a >> 4) - (data >> 4); \ + if ((al & 0x10) != 0) { \ + al -= 6; \ + ah--; \ + } \ + if ((ah & 0x10) != 0) \ + ah -= 6; \ + c = tmp >= 0 ? 1 : 0; \ + vdi &= D_FLAG | I_FLAG; \ + if (((a ^ tmp) & 0x80) != 0 && ((a ^ data) & 0x80) != 0) \ + vdi += V_FLAG; \ + nz = tmp & 0xff; \ + a = ((ah & 0xf) << 4) + (al & 0x0f); \ + } + +#define zGetByte(addr) dGetByte((addr) & 0xff) + +#define PEEK dGetByte(pc) +#define FETCH dGetByte(pc++) + +#define ABSOLUTE addr = FETCH; addr += FETCH << 8 +#define ABSOLUTE_X addr = FETCH; addr = (addr + (FETCH << 8) + x) & 0xffff +#define ABSOLUTE_Y addr = FETCH; addr = (addr + (FETCH << 8) + y) & 0xffff +#define ZPAGE addr = FETCH +#define ZPAGE_X addr = (FETCH + x) & 0xff +#define ZPAGE_Y addr = (FETCH + y) & 0xff +#define INDIRECT_X addr = (FETCH + x) & 0xff; addr = dGetByte(addr) + (zGetByte(addr + 1) << 8) +#define INDIRECT_Y addr = FETCH; addr = (dGetByte(addr) + (zGetByte(addr + 1) << 8) + y) & 0xffff +#define NCYCLES_X if ((addr & 0xff) < x) AST cycle++ +#define NCYCLES_Y if ((addr & 0xff) < y) AST cycle++ + +#define PL(dest) s = (s + 1) & 0xff; dest = dGetByte(0x0100 + s) +#define PLP PL(vdi); nz = ((vdi & 0x80) << 1) + (~vdi & Z_FLAG); c = vdi & 1; vdi &= V_FLAG | D_FLAG | I_FLAG +#define PH(data) dPutByte(0x0100 + s, data); s = (s - 1) & 0xff +#define PHW(data) PH((data) >> 8); PH(data) +#define PHP(bflag) PH(((nz | (nz >> 1)) & 0x80) + vdi + ((nz & 0xff) == 0 ? Z_FLAG : 0) + c + bflag) +#define PHPB0 PHP(0x20) /* push flags with B flag clear (NMI, IRQ) */ +#define PHPB1 PHP(0x30) /* push flags with B flag set (PHP, BRK) */ +#define PHPC PHW(pc) + +#define LDA nz = a = GetByte(addr) +#define LDA_ZP nz = a = dGetByte(addr) +#define LDX nz = x = GetByte(addr) +#define LDX_ZP nz = x = dGetByte(addr) +#define LDY nz = y = GetByte(addr) +#define LDY_ZP nz = y = dGetByte(addr) +#define LAX nz = x = a = GetByte(addr) +#define LAX_ZP nz = x = a = dGetByte(addr) +#define STA PutByte(addr, a) +#define STA_ZP dPutByte(addr, a) +#define STX PutByte(addr, x) +#define STX_ZP dPutByte(addr, x) +#define STY PutByte(addr, y) +#define STY_ZP dPutByte(addr, y) +#define SAX data = a & x; PutByte(addr, data) +#define SAX_ZP data = a & x; dPutByte(addr, data) +#define CMP nz = GetByte(addr); c = (a >= nz) ? 1 : 0; nz = (a - nz) & 0xff +#define CMP_ZP nz = dGetByte(addr); c = (a >= nz) ? 1 : 0; nz = (a - nz) & 0xff +#define CPX nz = GetByte(addr); c = (x >= nz) ? 1 : 0; nz = (x - nz) & 0xff +#define CPX_ZP nz = dGetByte(addr); c = (x >= nz) ? 1 : 0; nz = (x - nz) & 0xff +#define CPY nz = GetByte(addr); c = (y >= nz) ? 1 : 0; nz = (y - nz) & 0xff +#define CPY_ZP nz = dGetByte(addr); c = (y >= nz) ? 1 : 0; nz = (y - nz) & 0xff +#define AND nz = a &= GetByte(addr) +#define AND_ZP nz = a &= dGetByte(addr) +#define ORA nz = a |= GetByte(addr) +#define ORA_ZP nz = a |= dGetByte(addr) +#define EOR nz = a ^= GetByte(addr) +#define EOR_ZP nz = a ^= dGetByte(addr) +#define ADC data = GetByte(addr); DO_ADC +#define ADC_ZP data = dGetByte(addr); DO_ADC +#define SBC data = GetByte(addr); DO_SBC +#define SBC_ZP data = dGetByte(addr); DO_SBC + +#define ASL RMW_GetByte(nz, addr); c = nz >> 7; nz = (nz << 1) & 0xff; PutByte(addr, nz) +#define ASL_ZP nz = dGetByte(addr); c = nz >> 7; nz = (nz << 1) & 0xff; dPutByte(addr, nz) +#define ROL RMW_GetByte(nz, addr); nz = (nz << 1) + c; c = nz >> 8; nz &= 0xff; PutByte(addr, nz) +#define ROL_ZP nz = dGetByte(addr); nz = (nz << 1) + c; c = nz >> 8; nz &= 0xff; dPutByte(addr, nz) +#define LSR RMW_GetByte(nz, addr); c = nz & 1; nz >>= 1; PutByte(addr, nz) +#define LSR_ZP nz = dGetByte(addr); c = nz & 1; nz >>= 1; dPutByte(addr, nz) +#define ROR \ + RMW_GetByte(nz, addr); \ + if (c == 0) { \ + c = nz & 1; \ + nz >>= 1; \ + } \ + else { \ + c = nz & 1; \ + nz = (nz >> 1) + 128; \ + } \ + PutByte(addr, nz) +#define ROR_ZP \ + nz = dGetByte(addr); \ + if (c == 0) { \ + c = nz & 1; \ + nz >>= 1; \ + } \ + else { \ + c = nz & 1; \ + nz = (nz >> 1) + 128; \ + } \ + dPutByte(addr, nz) +#define DEC RMW_GetByte(nz, addr); nz = (nz - 1) & 0xff; PutByte(addr, nz) +#define DEC_ZP nz = dGetByte(addr); nz = (nz - 1) & 0xff; dPutByte(addr, nz) +#define INC RMW_GetByte(nz, addr); nz = (nz + 1) & 0xff; PutByte(addr, nz) +#define INC_ZP nz = dGetByte(addr); nz = (nz + 1) & 0xff; dPutByte(addr, nz) + +#define ASO ASL; nz = a |= nz +#define ASO_ZP ASL_ZP; nz = a |= nz +#define RLA ROL; nz = a &= nz +#define RLA_ZP ROL_ZP; nz = a &= nz +#define LSE LSR; nz = a ^= nz +#define LSE_ZP LSR_ZP; nz = a ^= nz +#define RRA ROR; data = nz; DO_ADC +#define RRA_ZP ROR_ZP; data = nz; DO_ADC +#define DCM DEC; c = (a >= nz) ? 1 : 0; nz = (a - nz) & 0xff +#define DCM_ZP DEC_ZP; c = (a >= nz) ? 1 : 0; nz = (a - nz) & 0xff +#define INS INC; data = nz; DO_SBC +#define INS_ZP INC_ZP; data = nz; DO_SBC + +#define BRANCH(cond) \ + if (cond) { \ + addr = SBYTE(FETCH); \ + addr += pc; \ + if (((addr ^ pc) & 0xff00) != 0) \ + AST cycle++; \ + AST cycle++; \ + pc = addr; \ + break; \ + } \ + pc++; \ + break + +#define CHECK_IRQ \ + if ((vdi & I_FLAG) == 0 && AST irqst != 0xff) { \ + PHPC; \ + PHPB0; \ + vdi |= I_FLAG; \ + pc = dGetWord(0xfffe); \ + AST cycle += 7; \ + } + +ASAP_FUNC void Cpu_RunScanlines(ASAP_State PTR ast, int scanlines) +{ + int pc; + int nz; + int a; + int x; + int y; + int c; + int s; + int vdi; + int next_event_cycle; + int cycle_limit; + pc = AST cpu_pc; + nz = AST cpu_nz; + a = AST cpu_a; + x = AST cpu_x; + y = AST cpu_y; + c = AST cpu_c; + s = AST cpu_s; + vdi = AST cpu_vdi; + AST next_scanline_cycle = 114; + next_event_cycle = 114; + cycle_limit = 114 * scanlines; + if (next_event_cycle > AST timer1_cycle) + next_event_cycle = AST timer1_cycle; + if (next_event_cycle > AST timer2_cycle) + next_event_cycle = AST timer2_cycle; + if (next_event_cycle > AST timer4_cycle) + next_event_cycle = AST timer4_cycle; + AST nearest_event_cycle = next_event_cycle; + for (;;) { + int cycle; + int addr; + int data; + cycle = AST cycle; + if (cycle >= AST nearest_event_cycle) { + if (cycle >= AST next_scanline_cycle) { + if (++AST scanline_number == 312) + AST scanline_number = 0; + AST cycle = cycle += 9; + AST next_scanline_cycle += 114; + if (--scanlines <= 0) + break; + } + next_event_cycle = AST next_scanline_cycle; +#define CHECK_TIMER_IRQ(ch) \ + if (cycle >= AST timer##ch##_cycle) { \ + AST irqst &= ~ch; \ + AST timer##ch##_cycle = NEVER; \ + } \ + else if (next_event_cycle > AST timer##ch##_cycle) \ + next_event_cycle = AST timer##ch##_cycle; + CHECK_TIMER_IRQ(1); + CHECK_TIMER_IRQ(2); + CHECK_TIMER_IRQ(4); + AST nearest_event_cycle = next_event_cycle; + CHECK_IRQ; + } +#ifdef ASAPSCAN + if (cpu_trace) + print_cpu_state(as, pc, a, x, y, s, nz, vdi, c); +#endif + data = FETCH; + AST cycle += opcode_cycles[data]; + switch (data) { + case 0x00: /* BRK */ + pc++; + PHPC; + PHPB1; + vdi |= I_FLAG; + pc = dGetWord(0xfffe); + break; + case 0x01: /* ORA (ab,x) */ + INDIRECT_X; + ORA; + break; + case 0x02: /* CIM [unofficial] */ + case 0x12: + case 0x22: + case 0x32: + case 0x42: + case 0x52: + case 0x62: + case 0x72: + case 0x92: + case 0xb2: + case 0xd2: + case 0xf2: + AST scanline_number = (AST scanline_number + scanlines - 1) % 312; + scanlines = 1; + AST cycle = cycle_limit; + break; + case 0x03: /* ASO (ab,x) [unofficial] */ + INDIRECT_X; + ASO; + break; + case 0x04: /* NOP ab [unofficial] */ + case 0x44: + case 0x64: + case 0x14: /* NOP ab,x [unofficial] */ + case 0x34: + case 0x54: + case 0x74: + case 0xd4: + case 0xf4: + case 0x80: /* NOP #ab [unofficial] */ + case 0x82: + case 0x89: + case 0xc2: + case 0xe2: + pc++; + break; + case 0x05: /* ORA ab */ + ZPAGE; + ORA_ZP; + break; + case 0x06: /* ASL ab */ + ZPAGE; + ASL_ZP; + break; + case 0x07: /* ASO ab [unofficial] */ + ZPAGE; + ASO_ZP; + break; + case 0x08: /* PHP */ + PHPB1; + break; + case 0x09: /* ORA #ab */ + nz = a |= FETCH; + break; + case 0x0a: /* ASL */ + c = a >> 7; + nz = a = (a << 1) & 0xff; + break; + case 0x0b: /* ANC #ab [unofficial] */ + case 0x2b: + nz = a &= FETCH; + c = nz >> 7; + break; + case 0x0c: /* NOP abcd [unofficial] */ + pc += 2; + break; + case 0x0d: /* ORA abcd */ + ABSOLUTE; + ORA; + break; + case 0x0e: /* ASL abcd */ + ABSOLUTE; + ASL; + break; + case 0x0f: /* ASO abcd [unofficial] */ + ABSOLUTE; + ASO; + break; + case 0x10: /* BPL */ + BRANCH(nz < 0x80); + case 0x11: /* ORA (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + ORA; + break; + case 0x13: /* ASO (ab),y [unofficial] */ + INDIRECT_Y; + ASO; + break; + case 0x15: /* ORA ab,x */ + ZPAGE_X; + ORA_ZP; + break; + case 0x16: /* ASL ab,x */ + ZPAGE_X; + ASL_ZP; + break; + case 0x17: /* ASO ab,x [unofficial] */ + ZPAGE_X; + ASO_ZP; + break; + case 0x18: /* CLC */ + c = 0; + break; + case 0x19: /* ORA abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + ORA; + break; + case 0x1b: /* ASO abcd,y [unofficial] */ + ABSOLUTE_Y; + ASO; + break; + case 0x1c: /* NOP abcd,x [unofficial] */ + case 0x3c: + case 0x5c: + case 0x7c: + case 0xdc: + case 0xfc: + if (FETCH + x >= 0x100) + AST cycle++; + pc++; + break; + case 0x1d: /* ORA abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + ORA; + break; + case 0x1e: /* ASL abcd,x */ + ABSOLUTE_X; + ASL; + break; + case 0x1f: /* ASO abcd,x [unofficial] */ + ABSOLUTE_X; + ASO; + break; + case 0x20: /* JSR abcd */ + addr = FETCH; + PHPC; + pc = addr + (PEEK << 8); + break; + case 0x21: /* AND (ab,x) */ + INDIRECT_X; + AND; + break; + case 0x23: /* RLA (ab,x) [unofficial] */ + INDIRECT_X; + RLA; + break; + case 0x24: /* BIT ab */ + ZPAGE; + nz = dGetByte(addr); + vdi = (vdi & (D_FLAG | I_FLAG)) + (nz & V_FLAG); + nz = ((nz & 0x80) << 1) + (nz & a); + break; + case 0x25: /* AND ab */ + ZPAGE; + AND_ZP; + break; + case 0x26: /* ROL ab */ + ZPAGE; + ROL_ZP; + break; + case 0x27: /* RLA ab [unofficial] */ + ZPAGE; + RLA_ZP; + break; + case 0x28: /* PLP */ + PLP; + CHECK_IRQ; + break; + case 0x29: /* AND #ab */ + nz = a &= FETCH; + break; + case 0x2a: /* ROL */ + a = (a << 1) + c; + c = a >> 8; + nz = a &= 0xff; + break; + case 0x2c: /* BIT abcd */ + ABSOLUTE; + nz = GetByte(addr); + vdi = (vdi & (D_FLAG | I_FLAG)) + (nz & V_FLAG); + nz = ((nz & 0x80) << 1) + (nz & a); + break; + case 0x2d: /* AND abcd */ + ABSOLUTE; + AND; + break; + case 0x2e: /* ROL abcd */ + ABSOLUTE; + ROL; + break; + case 0x2f: /* RLA abcd [unofficial] */ + ABSOLUTE; + RLA; + break; + case 0x30: /* BMI */ + BRANCH(nz >= 0x80); + case 0x31: /* AND (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + AND; + break; + case 0x33: /* RLA (ab),y [unofficial] */ + INDIRECT_Y; + RLA; + break; + case 0x35: /* AND ab,x */ + ZPAGE_X; + AND_ZP; + break; + case 0x36: /* ROL ab,x */ + ZPAGE_X; + ROL_ZP; + break; + case 0x37: /* RLA ab,x [unofficial] */ + ZPAGE_X; + RLA_ZP; + break; + case 0x38: /* SEC */ + c = 1; + break; + case 0x39: /* AND abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + AND; + break; + case 0x3b: /* RLA abcd,y [unofficial] */ + ABSOLUTE_Y; + RLA; + break; + case 0x3d: /* AND abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + AND; + break; + case 0x3e: /* ROL abcd,x */ + ABSOLUTE_X; + ROL; + break; + case 0x3f: /* RLA abcd,x [unofficial] */ + ABSOLUTE_X; + RLA; + break; + case 0x40: /* RTI */ + PLP; + PL(pc); + PL(addr); + pc += addr << 8; + CHECK_IRQ; + break; + case 0x41: /* EOR (ab,x) */ + INDIRECT_X; + EOR; + break; + case 0x43: /* LSE (ab,x) [unofficial] */ + INDIRECT_X; + LSE; + break; + case 0x45: /* EOR ab */ + ZPAGE; + EOR_ZP; + break; + case 0x46: /* LSR ab */ + ZPAGE; + LSR_ZP; + break; + case 0x47: /* LSE ab [unofficial] */ + ZPAGE; + LSE_ZP; + break; + case 0x48: /* PHA */ + PH(a); + break; + case 0x49: /* EOR #ab */ + nz = a ^= FETCH; + break; + case 0x4a: /* LSR */ + c = a & 1; + nz = a >>= 1; + break; + case 0x4b: /* ALR #ab [unofficial] */ + a &= FETCH; + c = a & 1; + nz = a >>= 1; + break; + case 0x4c: /* JMP abcd */ + addr = FETCH; + pc = addr + (PEEK << 8); + break; + case 0x4d: /* EOR abcd */ + ABSOLUTE; + EOR; + break; + case 0x4e: /* LSR abcd */ + ABSOLUTE; + LSR; + break; + case 0x4f: /* LSE abcd [unofficial] */ + ABSOLUTE; + LSE; + break; + case 0x50: /* BVC */ + BRANCH((vdi & V_FLAG) == 0); + case 0x51: /* EOR (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + EOR; + break; + case 0x53: /* LSE (ab),y [unofficial] */ + INDIRECT_Y; + LSE; + break; + case 0x55: /* EOR ab,x */ + ZPAGE_X; + EOR_ZP; + break; + case 0x56: /* LSR ab,x */ + ZPAGE_X; + LSR_ZP; + break; + case 0x57: /* LSE ab,x [unofficial] */ + ZPAGE_X; + LSE_ZP; + break; + case 0x58: /* CLI */ + vdi &= V_FLAG | D_FLAG; + CHECK_IRQ; + break; + case 0x59: /* EOR abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + EOR; + break; + case 0x5b: /* LSE abcd,y [unofficial] */ + ABSOLUTE_Y; + LSE; + break; + case 0x5d: /* EOR abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + EOR; + break; + case 0x5e: /* LSR abcd,x */ + ABSOLUTE_X; + LSR; + break; + case 0x5f: /* LSE abcd,x [unofficial] */ + ABSOLUTE_X; + LSE; + break; + case 0x60: /* RTS */ + PL(pc); + PL(addr); + pc += (addr << 8) + 1; + break; + case 0x61: /* ADC (ab,x) */ + INDIRECT_X; + ADC; + break; + case 0x63: /* RRA (ab,x) [unofficial] */ + INDIRECT_X; + RRA; + break; + case 0x65: /* ADC ab */ + ZPAGE; + ADC_ZP; + break; + case 0x66: /* ROR ab */ + ZPAGE; + ROR_ZP; + break; + case 0x67: /* RRA ab [unofficial] */ + ZPAGE; + RRA_ZP; + break; + case 0x68: /* PLA */ + PL(a); + nz = a; + break; + case 0x69: /* ADC #ab */ + data = FETCH; + DO_ADC; + break; + case 0x6a: /* ROR */ + nz = (c << 7) + (a >> 1); + c = a & 1; + a = nz; + break; + case 0x6b: /* ARR #ab [unofficial] */ + data = a & FETCH; + nz = a = (data >> 1) + (c << 7); + vdi = (vdi & (D_FLAG | I_FLAG)) + ((a ^ data) & V_FLAG); + if ((vdi & D_FLAG) == 0) + c = data >> 7; + else { + if ((data & 0xf) + (data & 1) > 5) + a = (a & 0xf0) + ((a + 6) & 0xf); + if (data + (data & 0x10) >= 0x60) { + a += 0x60; + c = 1; + } + else + c = 0; + a &= 0xff; + } + break; + case 0x6c: /* JMP (abcd) */ + ABSOLUTE; + if ((addr & 0xff) == 0xff) + pc = (dGetByte(addr - 0xff) << 8) + dGetByte(addr); + else + pc = dGetWord(addr); + break; + case 0x6d: /* ADC abcd */ + ABSOLUTE; + ADC; + break; + case 0x6e: /* ROR abcd */ + ABSOLUTE; + ROR; + break; + case 0x6f: /* RRA abcd [unofficial] */ + ABSOLUTE; + RRA; + break; + case 0x70: /* BVS */ + BRANCH((vdi & V_FLAG) != 0); + case 0x71: /* ADC (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + ADC; + break; + case 0x73: /* RRA (ab),y [unofficial] */ + INDIRECT_Y; + RRA; + break; + case 0x75: /* ADC ab,x */ + ZPAGE_X; + ADC_ZP; + break; + case 0x76: /* ROR ab,x */ + ZPAGE_X; + ROR_ZP; + break; + case 0x77: /* RRA ab,x [unofficial] */ + ZPAGE_X; + RRA_ZP; + break; + case 0x78: /* SEI */ + vdi |= I_FLAG; + break; + case 0x79: /* ADC abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + ADC; + break; + case 0x7b: /* RRA abcd,y [unofficial] */ + ABSOLUTE_Y; + RRA; + break; + case 0x7d: /* ADC abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + ADC; + break; + case 0x7e: /* ROR abcd,x */ + ABSOLUTE_X; + ROR; + break; + case 0x7f: /* RRA abcd,x [unofficial] */ + ABSOLUTE_X; + RRA; + break; + case 0x81: /* STA (ab,x) */ + INDIRECT_X; + STA; + break; + case 0x83: /* SAX (ab,x) [unofficial] */ + INDIRECT_X; + SAX; + break; + case 0x84: /* STY ab */ + ZPAGE; + STY_ZP; + break; + case 0x85: /* STA ab */ + ZPAGE; + STA_ZP; + break; + case 0x86: /* STX ab */ + ZPAGE; + STX_ZP; + break; + case 0x87: /* SAX ab [unofficial] */ + ZPAGE; + SAX_ZP; + break; + case 0x88: /* DEY */ + nz = y = (y - 1) & 0xff; + break; + case 0x8a: /* TXA */ + nz = a = x; + break; + case 0x8b: /* ANE #ab [unofficial] */ + data = FETCH; + a &= x; + nz = a & data; + a &= data | 0xef; + break; + case 0x8c: /* STY abcd */ + ABSOLUTE; + STY; + break; + case 0x8d: /* STA abcd */ + ABSOLUTE; + STA; + break; + case 0x8e: /* STX abcd */ + ABSOLUTE; + STX; + break; + case 0x8f: /* SAX abcd [unofficial] */ + ABSOLUTE; + SAX; + break; + case 0x90: /* BCC */ + BRANCH(c == 0); + case 0x91: /* STA (ab),y */ + INDIRECT_Y; + STA; + break; + case 0x93: /* SHA (ab),y [unofficial, unstable] */ + ZPAGE; + data = zGetByte(addr + 1); + addr = (dGetByte(addr) + (data << 8) + y) & 0xffff; + data = a & x & (data + 1); + PutByte(addr, data); + break; + case 0x94: /* STY ab,x */ + ZPAGE_X; + STY_ZP; + break; + case 0x95: /* STA ab,x */ + ZPAGE_X; + STA_ZP; + break; + case 0x96: /* STX ab,y */ + ZPAGE_Y; + STX_ZP; + break; + case 0x97: /* SAX ab,y [unofficial] */ + ZPAGE_Y; + SAX_ZP; + break; + case 0x98: /* TYA */ + nz = a = y; + break; + case 0x99: /* STA abcd,y */ + ABSOLUTE_Y; + STA; + break; + case 0x9a: /* TXS */ + s = x; + break; + case 0x9b: /* SHS abcd,y [unofficial, unstable] */ + /* S seems to be stable, only memory values vary */ + addr = FETCH; + data = FETCH; + addr = (addr + (data << 8) + y) & 0xffff; + s = a & x; + data = s & (data + 1); + PutByte(addr, data); + break; + case 0x9c: /* SHY abcd,x [unofficial] */ + addr = FETCH; + data = FETCH; + addr = (addr + (data << 8) + x) & 0xffff; + data = y & (data + 1); + PutByte(addr, data); + break; + case 0x9d: /* STA abcd,x */ + ABSOLUTE_X; + STA; + break; + case 0x9e: /* SHX abcd,y [unofficial] */ + addr = FETCH; + data = FETCH; + addr = (addr + (data << 8) + y) & 0xffff; + data = x & (data + 1); + PutByte(addr, data); + break; + case 0x9f: /* SHA abcd,y [unofficial, unstable] */ + addr = FETCH; + data = FETCH; + addr = (addr + (data << 8) + y) & 0xffff; + data = a & x & (data + 1); + PutByte(addr, data); + break; + case 0xa0: /* LDY #ab */ + nz = y = FETCH; + break; + case 0xa1: /* LDA (ab,x) */ + INDIRECT_X; + LDA; + break; + case 0xa2: /* LDX #ab */ + nz = x = FETCH; + break; + case 0xa3: /* LAX (ab,x) [unofficial] */ + INDIRECT_X; + LAX; + break; + case 0xa4: /* LDY ab */ + ZPAGE; + LDY_ZP; + break; + case 0xa5: /* LDA ab */ + ZPAGE; + LDA_ZP; + break; + case 0xa6: /* LDX ab */ + ZPAGE; + LDX_ZP; + break; + case 0xa7: /* LAX ab [unofficial] */ + ZPAGE; + LAX_ZP; + break; + case 0xa8: /* TAY */ + nz = y = a; + break; + case 0xa9: /* LDA #ab */ + nz = a = FETCH; + break; + case 0xaa: /* TAX */ + nz = x = a; + break; + case 0xab: /* ANX #ab [unofficial] */ + nz = x = a &= FETCH; + break; + case 0xac: /* LDY abcd */ + ABSOLUTE; + LDY; + break; + case 0xad: /* LDA abcd */ + ABSOLUTE; + LDA; + break; + case 0xae: /* LDX abcd */ + ABSOLUTE; + LDX; + break; + case 0xaf: /* LAX abcd [unofficial] */ + ABSOLUTE; + LAX; + break; + case 0xb0: /* BCS */ + BRANCH(c != 0); + case 0xb1: /* LDA (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + LDA; + break; + case 0xb3: /* LAX (ab),y [unofficial] */ + INDIRECT_Y; + NCYCLES_Y; + LAX; + break; + case 0xb4: /* LDY ab,x */ + ZPAGE_X; + LDY_ZP; + break; + case 0xb5: /* LDA ab,x */ + ZPAGE_X; + LDA_ZP; + break; + case 0xb6: /* LDX ab,y */ + ZPAGE_Y; + LDX_ZP; + break; + case 0xb7: /* LAX ab,y [unofficial] */ + ZPAGE_Y; + LAX_ZP; + break; + case 0xb8: /* CLV */ + vdi &= D_FLAG | I_FLAG; + break; + case 0xb9: /* LDA abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + LDA; + break; + case 0xba: /* TSX */ + nz = x = s; + break; + case 0xbb: /* LAS abcd,y [unofficial] */ + ABSOLUTE_Y; + NCYCLES_Y; + nz = x = a = s &= GetByte(addr); + break; + case 0xbc: /* LDY abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + LDY; + break; + case 0xbd: /* LDA abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + LDA; + break; + case 0xbe: /* LDX abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + LDX; + break; + case 0xbf: /* LAX abcd,y [unofficial] */ + ABSOLUTE_Y; + NCYCLES_Y; + LAX; + break; + case 0xc0: /* CPY #ab */ + nz = FETCH; + c = (y >= nz) ? 1 : 0; + nz = (y - nz) & 0xff; + break; + case 0xc1: /* CMP (ab,x) */ + INDIRECT_X; + CMP; + break; + case 0xc3: /* DCM (ab,x) [unofficial] */ + INDIRECT_X; + DCM; + break; + case 0xc4: /* CPY ab */ + ZPAGE; + CPY_ZP; + break; + case 0xc5: /* CMP ab */ + ZPAGE; + CMP_ZP; + break; + case 0xc6: /* DEC ab */ + ZPAGE; + DEC_ZP; + break; + case 0xc7: /* DCM ab [unofficial] */ + ZPAGE; + DCM_ZP; + break; + case 0xc8: /* INY */ + nz = y = (y + 1) & 0xff; + break; + case 0xc9: /* CMP #ab */ + nz = FETCH; + c = (a >= nz) ? 1 : 0; + nz = (a - nz) & 0xff; + break; + case 0xca: /* DEX */ + nz = x = (x - 1) & 0xff; + break; + case 0xcb: /* SBX #ab [unofficial] */ + nz = FETCH; + x &= a; + c = (x >= nz) ? 1 : 0; + nz = x = (x - nz) & 0xff; + break; + case 0xcc: /* CPY abcd */ + ABSOLUTE; + CPY; + break; + case 0xcd: /* CMP abcd */ + ABSOLUTE; + CMP; + break; + case 0xce: /* DEC abcd */ + ABSOLUTE; + DEC; + break; + case 0xcf: /* DCM abcd [unofficial] */ + ABSOLUTE; + DCM; + break; + case 0xd0: /* BNE */ + BRANCH((nz & 0xff) != 0); + case 0xd1: /* CMP (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + CMP; + break; + case 0xd3: /* DCM (ab),y [unofficial] */ + INDIRECT_Y; + DCM; + break; + case 0xd5: /* CMP ab,x */ + ZPAGE_X; + CMP_ZP; + break; + case 0xd6: /* DEC ab,x */ + ZPAGE_X; + DEC_ZP; + break; + case 0xd7: /* DCM ab,x [unofficial] */ + ZPAGE_X; + DCM_ZP; + break; + case 0xd8: /* CLD */ + vdi &= V_FLAG | I_FLAG; + break; + case 0xd9: /* CMP abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + CMP; + break; + case 0xdb: /* DCM abcd,y [unofficial] */ + ABSOLUTE_Y; + DCM; + break; + case 0xdd: /* CMP abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + CMP; + break; + case 0xde: /* DEC abcd,x */ + ABSOLUTE_X; + DEC; + break; + case 0xdf: /* DCM abcd,x [unofficial] */ + ABSOLUTE_X; + DCM; + break; + case 0xe0: /* CPX #ab */ + nz = FETCH; + c = (x >= nz) ? 1 : 0; + nz = (x - nz) & 0xff; + break; + case 0xe1: /* SBC (ab,x) */ + INDIRECT_X; + SBC; + break; + case 0xe3: /* INS (ab,x) [unofficial] */ + INDIRECT_X; + INS; + break; + case 0xe4: /* CPX ab */ + ZPAGE; + CPX_ZP; + break; + case 0xe5: /* SBC ab */ + ZPAGE; + SBC_ZP; + break; + case 0xe6: /* INC ab */ + ZPAGE; + INC_ZP; + break; + case 0xe7: /* INS ab [unofficial] */ + ZPAGE; + INS_ZP; + break; + case 0xe8: /* INX */ + nz = x = (x + 1) & 0xff; + break; + case 0xe9: /* SBC #ab */ + case 0xeb: /* SBC #ab [unofficial] */ + data = FETCH; + DO_SBC; + break; + case 0xea: /* NOP */ + case 0x1a: /* NOP [unofficial] */ + case 0x3a: + case 0x5a: + case 0x7a: + case 0xda: + case 0xfa: + break; + case 0xec: /* CPX abcd */ + ABSOLUTE; + CPX; + break; + case 0xed: /* SBC abcd */ + ABSOLUTE; + SBC; + break; + case 0xee: /* INC abcd */ + ABSOLUTE; + INC; + break; + case 0xef: /* INS abcd [unofficial] */ + ABSOLUTE; + INS; + break; + case 0xf0: /* BEQ */ + BRANCH((nz & 0xff) == 0); + case 0xf1: /* SBC (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + SBC; + break; + case 0xf3: /* INS (ab),y [unofficial] */ + INDIRECT_Y; + INS; + break; + case 0xf5: /* SBC ab,x */ + ZPAGE_X; + SBC_ZP; + break; + case 0xf6: /* INC ab,x */ + ZPAGE_X; + INC_ZP; + break; + case 0xf7: /* INS ab,x [unofficial] */ + ZPAGE_X; + INS_ZP; + break; + case 0xf8: /* SED */ + vdi |= D_FLAG; + break; + case 0xf9: /* SBC abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + SBC; + break; + case 0xfb: /* INS abcd,y [unofficial] */ + ABSOLUTE_Y; + INS; + break; + case 0xfd: /* SBC abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + SBC; + break; + case 0xfe: /* INC abcd,x */ + ABSOLUTE_X; + INC; + break; + case 0xff: /* INS abcd,x */ + ABSOLUTE_X; + INS; + break; + } + } + AST cpu_pc = pc; + AST cpu_nz = nz; + AST cpu_a = a; + AST cpu_x = x; + AST cpu_y = y; + AST cpu_c = c; + AST cpu_s = s; + AST cpu_vdi = vdi; + AST cycle -= cycle_limit; + if (AST timer1_cycle != NEVER) + AST timer1_cycle -= cycle_limit; + if (AST timer2_cycle != NEVER) + AST timer2_cycle -= cycle_limit; + if (AST timer4_cycle != NEVER) + AST timer4_cycle -= cycle_limit; +} Index: apps/plugins/asap/asap.h =================================================================== --- apps/plugins/asap/asap.h (revision 0) +++ apps/plugins/asap/asap.h (revision 0) @@ -0,0 +1,299 @@ +/* + * asap.h - public interface of the ASAP engine + * + * Copyright (C) 2005-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef _ASAP_H_ +#define _ASAP_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ASAP version. */ +#define ASAP_VERSION_MAJOR 1 +#define ASAP_VERSION_MINOR 2 +#define ASAP_VERSION_MICRO 0 +#define ASAP_VERSION "1.2.0" + +/* Short credits of the ASAP engine. */ +#define ASAP_YEARS "2005-2008" +#define ASAP_CREDITS \ + "Another Slight Atari Player (C) 2005-2008 Piotr Fusik\n" \ + "CMC, MPT, TMC players (C) 1994-2005 Marcin Lewandowski\n" \ + "RMT player (C) 2002-2005 Radek Sterba\n" + +/* Short GPL notice. + Display after the credits. */ +#define ASAP_COPYRIGHT \ + "This program is free software; you can redistribute it and/or modify\n" \ + "it under the terms of the GNU General Public License as published\n" \ + "by the Free Software Foundation; either version 2 of the License,\n" \ + "or (at your option) any later version." + +/* Useful type definitions. */ +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef TRUE +#define TRUE 1 +#endif +typedef int abool; +typedef unsigned char byte; + +/* Information about a file. */ +typedef struct { + char author[128]; /* author's name */ + char name[128]; /* title */ + char date[128]; /* creation date */ + int channels; /* 1 for mono or 2 for stereo */ + int songs; /* number of subsongs */ + int default_song; /* 0-based index of the "main" subsong */ + int durations[32]; /* lengths of songs, in milliseconds, -1 = unspecified */ + abool loops[32]; /* whether songs repeat or not */ + /* the following technical information should not be used outside ASAP. */ + char type; + int fastplay; + int music; + int init; + int player; + int header_len; + byte song_pos[128]; +} ASAP_ModuleInfo; + +/* POKEY state. + Not for use outside the ASAP engine. */ +typedef struct { + int audctl; + abool init; + int poly_index; + int div_cycles; + int mute1; + int mute2; + int mute3; + int mute4; + int audf1; + int audf2; + int audf3; + int audf4; + int audc1; + int audc2; + int audc3; + int audc4; + int tick_cycle1; + int tick_cycle2; + int tick_cycle3; + int tick_cycle4; + int period_cycles1; + int period_cycles2; + int period_cycles3; + int period_cycles4; + int reload_cycles1; + int reload_cycles3; + int out1; + int out2; + int out3; + int out4; + int delta1; + int delta2; + int delta3; + int delta4; + int skctl; + char delta_buffer[888]; +} PokeyState; + +/* Player state. + Only module_info is meant to be read outside the ASAP engine. */ +typedef struct { + int cycle; + int cpu_pc; + int cpu_a; + int cpu_x; + int cpu_y; + int cpu_s; + int cpu_nz; + int cpu_c; + int cpu_vdi; + int scanline_number; + int nearest_event_cycle; + int next_scanline_cycle; + int timer1_cycle; + int timer2_cycle; + int timer4_cycle; + int irqst; + int extra_pokey_mask; + PokeyState base_pokey; + PokeyState extra_pokey; + int sample_offset; + int sample_index; + int samples; + int iir_acc_left; + int iir_acc_right; + ASAP_ModuleInfo module_info; + int tmc_per_frame; + int tmc_per_frame_counter; + int current_song; + int current_duration; + int blocks_played; + int silence_cycles; + int silence_cycles_counter; + byte poly9_lookup[511]; + byte poly17_lookup[16385]; + byte memory[65536]; +} ASAP_State; + +/* Maximum length of a "mm:ss.xxx" string including the terminator. */ +#define ASAP_DURATION_CHARS 10 + +/* Maximum length of a supported input file. + You can assume that files longer than this are not supported by ASAP. */ +#define ASAP_MODULE_MAX 65000 + +/* Output sample rate. */ +#define ASAP_SAMPLE_RATE 44100 + +/* Output formats. */ +typedef enum { + ASAP_FORMAT_U8 = 8, /* unsigned char */ + ASAP_FORMAT_S16_LE = 16, /* signed short, little-endian */ + ASAP_FORMAT_S16_BE = -16 /* signed short, big-endian */ +} ASAP_SampleFormat; + +/* Parses the string in the "mm:ss.xxx" format + and returns the number of milliseconds or -1 if an error occurs. */ +int ASAP_ParseDuration(const char *s); + +/* Converts number of milliseconds to a string in the "mm:ss.xxx" format. */ +void ASAP_DurationToString(char *s, int duration); + +/* Checks whether the extension of the passed filename is known to ASAP. */ +abool ASAP_IsOurFile(const char *filename); + +/* Checks whether the filename extension is known to ASAP. */ +abool ASAP_IsOurExt(const char *ext); + +/* Changes the filename extension, returns true on success. */ +abool ASAP_ChangeExt(char *filename, const char *ext); + +/* Gets information about a module. + "module_info" is the structure where the information is returned. + "filename" determines file format. + "module" is the music data (contents of the file). + "module_len" is the number of data bytes. + ASAP_GetModuleInfo() returns true on success. */ +abool ASAP_GetModuleInfo(ASAP_ModuleInfo *module_info, const char *filename, + const byte module[], int module_len); + +/* Loads music data. + "as" is the destination structure. + "filename" determines file format. + "module" is the music data (contents of the file). + "module_len" is the number of data bytes. + ASAP does not make copies of the passed pointers. You can overwrite + or free "filename" and "module" once this function returns. + ASAP_Load() returns true on success. + If false is returned, the structure is invalid and you cannot + call the following functions. */ +abool ASAP_Load(ASAP_State *as, const char *filename, + const byte module[], int module_len); + +/* Enables silence detection. + Makes ASAP finish playing after the specified period of silence. + "as" is ASAP state initialized by ASAP_Load(). + "seconds" is the minimum length of silence that ends playback. */ +void ASAP_DetectSilence(ASAP_State *as, int seconds); + +/* Prepares ASAP to play the specified song of the loaded module. + "as" is ASAP state initialized by ASAP_Load(). + "song" is a zero-based index which must be less than the "songs" field + of the ASAP_ModuleInfo structure. + "duration" is playback time in milliseconds - use durations[song] + unless you want to override it. -1 means indefinitely. */ +void ASAP_PlaySong(ASAP_State *as, int song, int duration); + +/* Mutes the selected POKEY channels. + This is only useful for people who want to grab samples of individual + instruments. + "as" is ASAP state after calling ASAP_PlaySong(). + "mask" is a bit mask which selects POKEY channels to be muted. + Bits 0-3 control the base POKEY channels, + bits 4-7 control the extra POKEY channels. */ +void ASAP_MutePokeyChannels(ASAP_State *as, int mask); + +/* Rewinds the current song. + "as" is ASAP state initialized by ASAP_PlaySong(). + "position" is the requested absolute position in milliseconds. */ +void ASAP_Seek(ASAP_State *as, int position); + +/* Fills the specified buffer with generated samples. + "as" is ASAP state initialized by ASAP_PlaySong(). + "buffer" is the destination buffer. + "buffer_len" is the length of this buffer in bytes. + "format" is the format of samples. + ASAP_Generate() returns number of bytes actually written + (less than buffer_len if reached the end of the song). + Normally you use a buffer of a few kilobytes or less, + and call ASAP_Generate() in a loop or via a callback. */ +int ASAP_Generate(ASAP_State *as, void *buffer, int buffer_len, + ASAP_SampleFormat format); + +/* Checks whether information in the specified file can be edited. */ +abool ASAP_CanSetModuleInfo(const char *filename); + +/* Updates the specified module with author, name, date, stereo + and song durations as specified in "module_info". + "module_info" contains the new module information. + "module" is the source file contents. + "module_len" is the source file length. + "out_module" is the destination buffer of size ASAP_MODULE_MAX. + ASAP_SetModuleInfo() returns the resulting file length (number of bytes + written to "out_module") or -1 if illegal characters were found. */ +int ASAP_SetModuleInfo(const ASAP_ModuleInfo *module_info, const byte module[], + int module_len, byte out_module[]); + +/* Checks whether the specified module can be converted to another format. + "filename" determines the source format. + "module_info" contains the information about the source module, + with possibly modified public fields. + "module" is the source file contents. + "module_len" is the source file length. + ASAP_CanConvert() returns the extension of the target format + or NULL if there's no possible conversion. */ +const char *ASAP_CanConvert(const char *filename, const ASAP_ModuleInfo *module_info, + const byte module[], int module_len); + +/* Converts the specified module to the format returned by ASAP_CanConvert(). + "filename" determines the source format. + "module_info" contains the information about the source module, + with possibly modified public fields. + "module" is the source file contents. + "module_len" is the source file length. + "out_module" is the destination buffer of size ASAP_MODULE_MAX. + ASAP_Convert() returns the resulting file length (number of bytes + written to "out_module") or -1 on error. */ +int ASAP_Convert(const char *filename, const ASAP_ModuleInfo *module_info, + const byte module[], int module_len, byte out_module[]); + +#ifdef __cplusplus +} +#endif + +#endif Index: apps/plugins/asap/Makefile =================================================================== --- apps/plugins/asap/Makefile (revision 0) +++ apps/plugins/asap/Makefile (revision 0) @@ -0,0 +1,105 @@ +# __________ __ ___. +# Open \______ \ ____ ____ | | _\_ |__ _______ ___ +# Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +# Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +# Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +# \/ \/ \/ \/ \/ +# $Id $ +# + +INCLUDES = -I$(APPSDIR) -I.. -I. $(TARGET_INC) -I$(FIRMDIR)/include -I$(FIRMDIR)/export \ + -I$(FIRMDIR)/common -I$(FIRMDIR)/drivers -I$(OUTDIR) -I$(BUILDDIR) + +ifeq ($(CPU),coldfire) + MIDIOPTS = -O2 +else + MIDIOPTS = -O +endif + +PLAYERS_OBX = players/cmc.obx players/mpt.obx players/rmt4.obx players/rmt8.obx players/tmc.obx players/tm2.obx +XASM = xasm -q + +CFLAGS = $(INCLUDES) $(GCCOPTS) $(TARGET) $(EXTRA_DEFINES) $(MIDIOPTS) \ + -DTARGET_ID=$(TARGET_ID) -DMEM=${MEMORYSIZE} -DPLUGIN + +ifdef APPEXTRA + INCLUDES += $(patsubst %,-I$(APPSDIR)/%,$(subst :, ,$(APPEXTRA))) +endif + +LINKFILE := $(OBJDIR)/link.lds +DEPFILE = $(OBJDIR)/dep-asap + +# This sets up 'SRC' based on the files mentioned in SOURCES +include $(TOOLSDIR)/makesrc.inc + +SOURCES = $(SRC) +OBJS := $(SRC:%.c=$(OBJDIR)/%.o) +DIRS = . + +ifndef SIMVER + LDS := ../plugin.lds + OUTPUT = $(OUTDIR)/asap.rock +else ## simulators + OUTPUT = $(OUTDIR)/asap.rock +endif + +all: $(OUTPUT) + +ifndef SIMVER +$(OBJDIR)/asap.elf: $(OBJS) $(LINKFILE) $(BITMAPLIBS) + $(call PRINTS,LD $(@F))$(CC) $(CFLAGS) -o $@ $(OBJS) -L$(BUILDDIR) -lplugin -lgcc \ + $(LINKBITMAPS) -T$(LINKFILE) -Wl,--gc-sections -Wl,-Map,$(OBJDIR)/asap.map + +$(OUTPUT): $(OBJDIR)/asap.elf + $(call PRINTS,OBJCOPY $(@F))$(OC) -O binary $< $@ +else + +################################################### +# This is the SDL simulator version + +$(OUTPUT): $(OBJS) + $(call PRINTS,LD $(@F))$(CC) $(CFLAGS) $(SHARED_FLAG) $(OBJS) -L$(BUILDDIR) -lplugin $(LINKBITMAPS) -o $@ +ifeq ($(findstring CYGWIN,$(UNAME)),CYGWIN) +# 'x' must be kept or you'll have "Win32 error 5" +# $ fgrep 5 /usr/include/w32api/winerror.h | head -1 +# #define ERROR_ACCESS_DENIED 5L +else + @chmod -x $@ +endif + +endif # end of simulator section + +include $(TOOLSDIR)/make.inc + +# MEMORYSIZE should be passed on to this makefile with the chosen memory size +# given in number of MB +$(LINKFILE): $(LDS) + $(call PRINTS,build $(@F))cat $< | $(CC) -DMEMORYSIZE=$(MEMORYSIZE) $(INCLUDES) $(TARGET) \ + $(DEFINES) -E -P - >$@ + +players.h: raw2c.pl ${PLAYERS_OBX} + perl raw2c.pl ${PLAYERS_OBX} >$@ + +players/cmc.obx: players/cmc.asx + ${XASM} -o $@ players/cmc.asx + +players/mpt.obx: players/mpt.asx + ${XASM} -o $@ players/mpt.asx + +players/rmt4.obx: players/rmt.asx + ${XASM} -d STEREOMODE=0 -o $@ players/rmt.asx + +players/rmt8.obx: players/rmt.asx + ${XASM} -d STEREOMODE=1 -o $@ players/rmt.asx + +players/tmc.obx: players/tmc.asx + ${XASM} -o $@ players/tmc.asx + +players/tm2.obx: players/tm2.asx + ${XASM} -o $@ players/tm2.asx + +clean: + $(call PRINTS,cleaning asap)rm -rf $(OBJDIR)/asap + $(SILENT)rm -f $(OBJDIR)/asap.* $(DEPFILE) + +-include $(DEPFILE) Index: apps/plugins/asap/apokeysnd.c =================================================================== --- apps/plugins/asap/apokeysnd.c (revision 0) +++ apps/plugins/asap/apokeysnd.c (revision 0) @@ -0,0 +1,537 @@ +/* + * apokeysnd.c - another POKEY sound emulator + * + * Copyright (C) 2007-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#if !defined(JAVA) && !defined(CSHARP) +#include +#endif + +#include "asap_internal.h" + +#define ULTRASOUND_CYCLES 112 + +#define MUTE_FREQUENCY 1 +#define MUTE_INIT 2 +#define MUTE_USER 4 + +CONST_LOOKUP(byte, poly4_lookup) = + { 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1 }; +CONST_LOOKUP(byte, poly5_lookup) = + { 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, + 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1 }; + +FILE_FUNC void init_state(PokeyState PTR pst) +{ + PST audctl = 0; + PST init = FALSE; + PST poly_index = 15 * 31 * 131071; + PST div_cycles = 28; + PST mute1 = MUTE_FREQUENCY | MUTE_USER; + PST mute2 = MUTE_FREQUENCY | MUTE_USER; + PST mute3 = MUTE_FREQUENCY | MUTE_USER; + PST mute4 = MUTE_FREQUENCY | MUTE_USER; + PST audf1 = 0; + PST audf2 = 0; + PST audf3 = 0; + PST audf4 = 0; + PST audc1 = 0; + PST audc2 = 0; + PST audc3 = 0; + PST audc4 = 0; + PST tick_cycle1 = NEVER; + PST tick_cycle2 = NEVER; + PST tick_cycle3 = NEVER; + PST tick_cycle4 = NEVER; + PST period_cycles1 = 28; + PST period_cycles2 = 28; + PST period_cycles3 = 28; + PST period_cycles4 = 28; + PST reload_cycles1 = 28; + PST reload_cycles3 = 28; + PST out1 = 0; + PST out2 = 0; + PST out3 = 0; + PST out4 = 0; + PST delta1 = 0; + PST delta2 = 0; + PST delta3 = 0; + PST delta4 = 0; + PST skctl = 3; + ZERO_ARRAY(PST delta_buffer); +} + +ASAP_FUNC void PokeySound_Initialize(ASAP_State PTR ast) +{ + int i; + int reg; + reg = 0x1ff; + for (i = 0; i < 511; i++) { + reg = ((((reg >> 5) ^ reg) & 1) << 8) + (reg >> 1); + AST poly9_lookup[i] = (byte) reg; + } + reg = 0x1ffff; + for (i = 0; i < 16385; i++) { + reg = ((((reg >> 5) ^ reg) & 0xff) << 9) + (reg >> 8); + AST poly17_lookup[i] = (byte) (reg >> 1); + } + AST sample_offset = 0; + AST sample_index = 0; + AST samples = 0; + AST iir_acc_left = 0; + AST iir_acc_right = 0; + init_state(ADDRESSOF AST base_pokey); + init_state(ADDRESSOF AST extra_pokey); +} + +#define CYCLE_TO_SAMPLE(cycle) (((cycle) * ASAP_SAMPLE_RATE + AST sample_offset) / ASAP_MAIN_CLOCK) + +#define DO_TICK(ch) \ + if (PST init) { \ + switch (PST audc##ch >> 4) { \ + case 10: \ + case 14: \ + PST out##ch ^= 1; \ + PST delta_buffer[CYCLE_TO_SAMPLE(cycle)] += PST delta##ch = -PST delta##ch; \ + break; \ + default: \ + break; \ + } \ + } \ + else { \ + int poly = cycle + PST poly_index - (ch - 1); \ + int newout = PST out##ch; \ + switch (PST audc##ch >> 4) { \ + case 0: \ + if (poly5_lookup[poly % 31] != 0) { \ + if ((PST audctl & 0x80) != 0) \ + newout = AST poly9_lookup[poly % 511] & 1; \ + else { \ + poly %= 131071; \ + newout = (AST poly17_lookup[poly >> 3] >> (poly & 7)) & 1; \ + } \ + } \ + break; \ + case 2: \ + case 6: \ + newout ^= poly5_lookup[poly % 31]; \ + break; \ + case 4: \ + if (poly5_lookup[poly % 31] != 0) \ + newout = poly4_lookup[poly % 15]; \ + break; \ + case 8: \ + if ((PST audctl & 0x80) != 0) \ + newout = AST poly9_lookup[poly % 511] & 1; \ + else { \ + poly %= 131071; \ + newout = (AST poly17_lookup[poly >> 3] >> (poly & 7)) & 1; \ + } \ + break; \ + case 10: \ + case 14: \ + newout ^= 1; \ + break; \ + case 12: \ + newout = poly4_lookup[poly % 15]; \ + break; \ + default: \ + break; \ + } \ + if (newout != PST out##ch) { \ + PST out##ch = newout; \ + PST delta_buffer[CYCLE_TO_SAMPLE(cycle)] += PST delta##ch = -PST delta##ch; \ + } \ + } + +FILE_FUNC void generate(ASAP_State PTR ast, PokeyState PTR pst, int current_cycle) +{ + for (;;) { + int cycle = current_cycle; + if (cycle > PST tick_cycle1) + cycle = PST tick_cycle1; + if (cycle > PST tick_cycle2) + cycle = PST tick_cycle2; + if (cycle > PST tick_cycle3) + cycle = PST tick_cycle3; + if (cycle > PST tick_cycle4) + cycle = PST tick_cycle4; + if (cycle == current_cycle) + break; + if (cycle == PST tick_cycle3) { + PST tick_cycle3 += PST period_cycles3; + if ((PST audctl & 4) != 0 && PST delta1 > 0 && PST mute1 == 0) + PST delta_buffer[CYCLE_TO_SAMPLE(cycle)] += PST delta1 = -PST delta1; + DO_TICK(3); + } + if (cycle == PST tick_cycle4) { + PST tick_cycle4 += PST period_cycles4; + if ((PST audctl & 8) != 0) + PST tick_cycle3 = cycle + PST reload_cycles3; + if ((PST audctl & 2) != 0 && PST delta2 > 0 && PST mute2 == 0) + PST delta_buffer[CYCLE_TO_SAMPLE(cycle)] += PST delta2 = -PST delta2; + DO_TICK(4); + } + if (cycle == PST tick_cycle1) { + PST tick_cycle1 += PST period_cycles1; + if ((PST skctl & 0x88) == 8) + PST tick_cycle2 = cycle + PST period_cycles2; + DO_TICK(1); + } + if (cycle == PST tick_cycle2) { + PST tick_cycle2 += PST period_cycles2; + if ((PST audctl & 0x10) != 0) + PST tick_cycle1 = cycle + PST reload_cycles1; + else if ((PST skctl & 8) != 0) + PST tick_cycle1 = cycle + PST period_cycles1; + DO_TICK(2); + } + } +} + +#define MUTE_CHANNEL(ch, cond, mask) \ + if (cond) { \ + PST mute##ch |= mask; \ + PST tick_cycle##ch = NEVER; \ + } \ + else { \ + PST mute##ch &= ~mask; \ + if (PST tick_cycle##ch == NEVER && PST mute##ch == 0) \ + PST tick_cycle##ch = AST cycle; \ + } + +#define DO_ULTRASOUND(ch) \ + MUTE_CHANNEL(ch, PST period_cycles##ch <= ULTRASOUND_CYCLES && (PST audc##ch >> 4 == 10 || PST audc##ch >> 4 == 14), MUTE_FREQUENCY) + +#define DO_AUDC(ch) \ + if (data == PST audc##ch) \ + break; \ + generate(ast, pst, AST cycle); \ + PST audc##ch = data; \ + if ((data & 0x10) != 0) { \ + data &= 0xf; \ + if ((PST mute##ch & MUTE_USER) == 0) \ + PST delta_buffer[CYCLE_TO_SAMPLE(AST cycle)] \ + += PST delta##ch > 0 ? data - PST delta##ch : data; \ + PST delta##ch = data; \ + } \ + else { \ + data &= 0xf; \ + DO_ULTRASOUND(ch); \ + if (PST delta##ch > 0) { \ + if ((PST mute##ch & MUTE_USER) == 0) \ + PST delta_buffer[CYCLE_TO_SAMPLE(AST cycle)] \ + += data - PST delta##ch; \ + PST delta##ch = data; \ + } \ + else \ + PST delta##ch = -data; \ + } \ + break; + +#define DO_INIT(ch, cond) \ + MUTE_CHANNEL(ch, PST init && cond, MUTE_INIT) + +ASAP_FUNC void PokeySound_PutByte(ASAP_State PTR ast, int addr, int data) +{ + PokeyState PTR pst = (addr & AST extra_pokey_mask) != 0 + ? ADDRESSOF AST extra_pokey : ADDRESSOF AST base_pokey; + switch (addr & 0xf) { + case 0x00: + if (data == PST audf1) + break; + generate(ast, pst, AST cycle); + PST audf1 = data; + switch (PST audctl & 0x50) { + case 0x00: + PST period_cycles1 = PST div_cycles * (data + 1); + break; + case 0x10: + PST period_cycles2 = PST div_cycles * (data + 256 * PST audf2 + 1); + PST reload_cycles1 = PST div_cycles * (data + 1); + DO_ULTRASOUND(2); + break; + case 0x40: + PST period_cycles1 = data + 4; + break; + case 0x50: + PST period_cycles2 = data + 256 * PST audf2 + 7; + PST reload_cycles1 = data + 4; + DO_ULTRASOUND(2); + break; + } + DO_ULTRASOUND(1); + break; + case 0x01: + DO_AUDC(1) + case 0x02: + if (data == PST audf2) + break; + generate(ast, pst, AST cycle); + PST audf2 = data; + switch (PST audctl & 0x50) { + case 0x00: + case 0x40: + PST period_cycles2 = PST div_cycles * (data + 1); + break; + case 0x10: + PST period_cycles2 = PST div_cycles * (PST audf1 + 256 * data + 1); + break; + case 0x50: + PST period_cycles2 = PST audf1 + 256 * data + 7; + break; + } + DO_ULTRASOUND(2); + break; + case 0x03: + DO_AUDC(2) + case 0x04: + if (data == PST audf3) + break; + generate(ast, pst, AST cycle); + PST audf3 = data; + switch (PST audctl & 0x28) { + case 0x00: + PST period_cycles3 = PST div_cycles * (data + 1); + break; + case 0x08: + PST period_cycles4 = PST div_cycles * (data + 256 * PST audf4 + 1); + PST reload_cycles3 = PST div_cycles * (data + 1); + DO_ULTRASOUND(4); + break; + case 0x20: + PST period_cycles3 = data + 4; + break; + case 0x28: + PST period_cycles4 = data + 256 * PST audf4 + 7; + PST reload_cycles3 = data + 4; + DO_ULTRASOUND(4); + break; + } + DO_ULTRASOUND(3); + break; + case 0x05: + DO_AUDC(3) + case 0x06: + if (data == PST audf4) + break; + generate(ast, pst, AST cycle); + PST audf4 = data; + switch (PST audctl & 0x28) { + case 0x00: + case 0x20: + PST period_cycles4 = PST div_cycles * (data + 1); + break; + case 0x08: + PST period_cycles4 = PST div_cycles * (PST audf3 + 256 * data + 1); + break; + case 0x28: + PST period_cycles4 = PST audf3 + 256 * data + 7; + break; + } + DO_ULTRASOUND(4); + break; + case 0x07: + DO_AUDC(4) + case 0x08: + if (data == PST audctl) + break; + generate(ast, pst, AST cycle); + PST audctl = data; + PST div_cycles = ((data & 1) != 0) ? 114 : 28; + /* TODO: tick_cycles */ + switch (data & 0x50) { + case 0x00: + PST period_cycles1 = PST div_cycles * (PST audf1 + 1); + PST period_cycles2 = PST div_cycles * (PST audf2 + 1); + break; + case 0x10: + PST period_cycles1 = PST div_cycles * 256; + PST period_cycles2 = PST div_cycles * (PST audf1 + 256 * PST audf2 + 1); + PST reload_cycles1 = PST div_cycles * (PST audf1 + 1); + break; + case 0x40: + PST period_cycles1 = PST audf1 + 4; + PST period_cycles2 = PST div_cycles * (PST audf2 + 1); + break; + case 0x50: + PST period_cycles1 = 256; + PST period_cycles2 = PST audf1 + 256 * PST audf2 + 7; + PST reload_cycles1 = PST audf1 + 4; + break; + } + DO_ULTRASOUND(1); + DO_ULTRASOUND(2); + switch (data & 0x28) { + case 0x00: + PST period_cycles3 = PST div_cycles * (PST audf3 + 1); + PST period_cycles4 = PST div_cycles * (PST audf4 + 1); + break; + case 0x08: + PST period_cycles3 = PST div_cycles * 256; + PST period_cycles4 = PST div_cycles * (PST audf3 + 256 * PST audf4 + 1); + PST reload_cycles3 = PST div_cycles * (PST audf3 + 1); + break; + case 0x20: + PST period_cycles3 = PST audf3 + 4; + PST period_cycles4 = PST div_cycles * (PST audf4 + 1); + break; + case 0x28: + PST period_cycles3 = 256; + PST period_cycles4 = PST audf3 + 256 * PST audf4 + 7; + PST reload_cycles3 = PST audf3 + 4; + break; + } + DO_ULTRASOUND(3); + DO_ULTRASOUND(4); + break; + case 0x09: + /* TODO: STIMER */ + break; + case 0x0f: + PST skctl = data; + PST init = ((data & 3) == 0); + DO_INIT(1, (PST audctl & 0x40) == 0); + DO_INIT(2, (PST audctl & 0x50) != 0x50); + DO_INIT(3, (PST audctl & 0x20) == 0); + DO_INIT(4, (PST audctl & 0x28) != 0x28); + break; + default: + break; + } +} + +ASAP_FUNC int PokeySound_GetRandom(ASAP_State PTR ast, int addr) +{ + PokeyState PTR pst = (addr & AST extra_pokey_mask) != 0 + ? ADDRESSOF AST extra_pokey : ADDRESSOF AST base_pokey; + int i; + if (PST init) + return 0xff; + i = AST cycle + PST poly_index; + if ((PST audctl & 0x80) != 0) + return AST poly9_lookup[i % 511]; + else { + int j; + i %= 131071; + j = i >> 3; + i &= 7; + return ((AST poly17_lookup[j] >> i) + (AST poly17_lookup[j + 1] << (8 - i))) & 0xff; + } +} + +FILE_FUNC void end_frame(ASAP_State PTR ast, PokeyState PTR pst, int cycle_limit) +{ + int m; + generate(ast, pst, cycle_limit); + PST poly_index += cycle_limit; + m = ((PST audctl & 0x80) != 0) ? 15 * 31 * 511 : 15 * 31 * 131071; + if (PST poly_index >= 2 * m) + PST poly_index -= m; + if (PST tick_cycle1 != NEVER) + PST tick_cycle1 -= cycle_limit; + if (PST tick_cycle2 != NEVER) + PST tick_cycle2 -= cycle_limit; + if (PST tick_cycle3 != NEVER) + PST tick_cycle3 -= cycle_limit; + if (PST tick_cycle4 != NEVER) + PST tick_cycle4 -= cycle_limit; +} + +ASAP_FUNC void PokeySound_StartFrame(ASAP_State PTR ast) +{ + ZERO_ARRAY(AST base_pokey.delta_buffer); + if (AST extra_pokey_mask != 0) + ZERO_ARRAY(AST extra_pokey.delta_buffer); +} + +ASAP_FUNC void PokeySound_EndFrame(ASAP_State PTR ast, int current_cycle) +{ + end_frame(ast, ADDRESSOF AST base_pokey, current_cycle); + if (AST extra_pokey_mask != 0) + end_frame(ast, ADDRESSOF AST extra_pokey, current_cycle); + AST sample_offset += current_cycle * ASAP_SAMPLE_RATE; + AST sample_index = 0; + AST samples = AST sample_offset / ASAP_MAIN_CLOCK; + AST sample_offset %= ASAP_MAIN_CLOCK; +} + +ASAP_FUNC int PokeySound_Generate(ASAP_State PTR ast, byte ARRAY buffer, int buffer_offset, int blocks, ASAP_SampleFormat format) +{ + int i = AST sample_index; + int samples = AST samples; + int acc_left = AST iir_acc_left; + int acc_right = AST iir_acc_right; + if (blocks < samples - i) + samples = i + blocks; + else + blocks = samples - i; + for (; i < samples; i++) { + int sample; + acc_left += (AST base_pokey.delta_buffer[i] << 20) - (acc_left * 3 >> 10); + sample = acc_left >> 10; +#define STORE_SAMPLE \ + if (sample < -32767) \ + sample = -32767; \ + else if (sample > 32767) \ + sample = 32767; \ + switch (format) { \ + case ASAP_FORMAT_U8: \ + buffer[buffer_offset++] = (byte) ((sample >> 8) + 128); \ + break; \ + case ASAP_FORMAT_S16_LE: \ + buffer[buffer_offset++] = (byte) sample; \ + buffer[buffer_offset++] = (byte) (sample >> 8); \ + break; \ + case ASAP_FORMAT_S16_BE: \ + buffer[buffer_offset++] = (byte) (sample >> 8); \ + buffer[buffer_offset++] = (byte) sample; \ + break; \ + } + STORE_SAMPLE; + if (AST extra_pokey_mask != 0) { + acc_right += (AST extra_pokey.delta_buffer[i] << 20) - (acc_right * 3 >> 10); + sample = acc_right >> 10; + STORE_SAMPLE; + } + } + if (i == AST samples) { + acc_left += AST base_pokey.delta_buffer[i] << 20; + acc_right += AST extra_pokey.delta_buffer[i] << 20; + } + AST sample_index = i; + AST iir_acc_left = acc_left; + AST iir_acc_right = acc_right; + return blocks; +} + +ASAP_FUNC abool PokeySound_IsSilent(const PokeyState PTR pst) +{ + return ((PST audc1 | PST audc2 | PST audc3 | PST audc4) & 0xf) == 0; +} + +ASAP_FUNC void PokeySound_Mute(const ASAP_State PTR ast, PokeyState PTR pst, int mask) +{ + MUTE_CHANNEL(1, (mask & 1) != 0, MUTE_USER); + MUTE_CHANNEL(2, (mask & 2) != 0, MUTE_USER); + MUTE_CHANNEL(3, (mask & 4) != 0, MUTE_USER); + MUTE_CHANNEL(4, (mask & 8) != 0, MUTE_USER); +} Index: apps/plugins/asap/acpu.c =================================================================== --- apps/plugins/asap/acpu.c (revision 0) +++ apps/plugins/asap/acpu.c (revision 0) @@ -0,0 +1,1262 @@ +/* + * acpu.c - another 6502 CPU emulator + * + * Copyright (C) 2007-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "asap_internal.h" + +CONST_LOOKUP(int, opcode_cycles) = +{ +/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ + 7, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6, /* 0x */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 1x */ + 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6, /* 2x */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 3x */ + 6, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6, /* 4x */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 5x */ + 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6, /* 6x */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 7x */ + 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* 8x */ + 2, 6, 2, 6, 4, 4, 4, 4, 2, 5, 2, 5, 5, 5, 5, 5, /* 9x */ + 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* Ax */ + 2, 5, 2, 5, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4, /* Bx */ + 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* Cx */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* Dx */ + 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* Ex */ + 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7 /* Fx */ +}; + +#define DO_ADC \ + if ((vdi & D_FLAG) == 0) { \ + /* binary mode */ \ + int tmp = a + data + c; \ + c = tmp >> 8; \ + vdi &= D_FLAG | I_FLAG; \ + if (((a ^ data) & 0x80) == 0 && ((data ^ tmp) & 0x80) != 0) \ + vdi += V_FLAG; \ + nz = a = tmp & 0xff; \ + } \ + else { \ + /* decimal mode */ \ + int tmp = (a & 0x0f) + (data & 0x0f) + c; \ + if (tmp >= 10) \ + tmp = (tmp - 10) | 0x10; \ + tmp += (a & 0xf0) + (data & 0xf0); \ + nz = ((tmp & 0x80) << 1) + ((a + data + c) & 0xff); \ + vdi &= D_FLAG | I_FLAG; \ + if (((a ^ data) & 0x80) == 0 && ((data ^ tmp) & 0x80) != 0) \ + vdi += V_FLAG; \ + if (tmp > 0x9f) \ + tmp += 0x60; \ + c = (tmp > 0xff) ? 1 : 0; \ + a = tmp & 0xff; \ + } + +#define DO_SBC \ + if ((vdi & D_FLAG) == 0) { \ + /* binary mode */ \ + int tmp = a - data - 1 + c; \ + c = (tmp >= 0) ? 1 : 0; \ + vdi &= D_FLAG | I_FLAG; \ + if (((a ^ tmp) & 0x80) != 0 && ((a ^ data) & 0x80) != 0) \ + vdi += V_FLAG; \ + nz = a = tmp & 0xff; \ + } \ + else { \ + /* decimal mode */ \ + int tmp = a - data - 1 + c; \ + int al = (a & 0x0f) - (data & 0x0f) - 1 + c; \ + int ah = (a >> 4) - (data >> 4); \ + if ((al & 0x10) != 0) { \ + al -= 6; \ + ah--; \ + } \ + if ((ah & 0x10) != 0) \ + ah -= 6; \ + c = tmp >= 0 ? 1 : 0; \ + vdi &= D_FLAG | I_FLAG; \ + if (((a ^ tmp) & 0x80) != 0 && ((a ^ data) & 0x80) != 0) \ + vdi += V_FLAG; \ + nz = tmp & 0xff; \ + a = ((ah & 0xf) << 4) + (al & 0x0f); \ + } + +#define zGetByte(addr) dGetByte((addr) & 0xff) + +#define PEEK dGetByte(pc) +#define FETCH dGetByte(pc++) + +#define ABSOLUTE addr = FETCH; addr += FETCH << 8 +#define ABSOLUTE_X addr = FETCH; addr = (addr + (FETCH << 8) + x) & 0xffff +#define ABSOLUTE_Y addr = FETCH; addr = (addr + (FETCH << 8) + y) & 0xffff +#define ZPAGE addr = FETCH +#define ZPAGE_X addr = (FETCH + x) & 0xff +#define ZPAGE_Y addr = (FETCH + y) & 0xff +#define INDIRECT_X addr = (FETCH + x) & 0xff; addr = dGetByte(addr) + (zGetByte(addr + 1) << 8) +#define INDIRECT_Y addr = FETCH; addr = (dGetByte(addr) + (zGetByte(addr + 1) << 8) + y) & 0xffff +#define NCYCLES_X if ((addr & 0xff) < x) AST cycle++ +#define NCYCLES_Y if ((addr & 0xff) < y) AST cycle++ + +#define PL(dest) s = (s + 1) & 0xff; dest = dGetByte(0x0100 + s) +#define PLP PL(vdi); nz = ((vdi & 0x80) << 1) + (~vdi & Z_FLAG); c = vdi & 1; vdi &= V_FLAG | D_FLAG | I_FLAG +#define PH(data) dPutByte(0x0100 + s, data); s = (s - 1) & 0xff +#define PHW(data) PH((data) >> 8); PH(data) +#define PHP(bflag) PH(((nz | (nz >> 1)) & 0x80) + vdi + ((nz & 0xff) == 0 ? Z_FLAG : 0) + c + bflag) +#define PHPB0 PHP(0x20) /* push flags with B flag clear (NMI, IRQ) */ +#define PHPB1 PHP(0x30) /* push flags with B flag set (PHP, BRK) */ +#define PHPC PHW(pc) + +#define LDA nz = a = GetByte(addr) +#define LDA_ZP nz = a = dGetByte(addr) +#define LDX nz = x = GetByte(addr) +#define LDX_ZP nz = x = dGetByte(addr) +#define LDY nz = y = GetByte(addr) +#define LDY_ZP nz = y = dGetByte(addr) +#define LAX nz = x = a = GetByte(addr) +#define LAX_ZP nz = x = a = dGetByte(addr) +#define STA PutByte(addr, a) +#define STA_ZP dPutByte(addr, a) +#define STX PutByte(addr, x) +#define STX_ZP dPutByte(addr, x) +#define STY PutByte(addr, y) +#define STY_ZP dPutByte(addr, y) +#define SAX data = a & x; PutByte(addr, data) +#define SAX_ZP data = a & x; dPutByte(addr, data) +#define CMP nz = GetByte(addr); c = (a >= nz) ? 1 : 0; nz = (a - nz) & 0xff +#define CMP_ZP nz = dGetByte(addr); c = (a >= nz) ? 1 : 0; nz = (a - nz) & 0xff +#define CPX nz = GetByte(addr); c = (x >= nz) ? 1 : 0; nz = (x - nz) & 0xff +#define CPX_ZP nz = dGetByte(addr); c = (x >= nz) ? 1 : 0; nz = (x - nz) & 0xff +#define CPY nz = GetByte(addr); c = (y >= nz) ? 1 : 0; nz = (y - nz) & 0xff +#define CPY_ZP nz = dGetByte(addr); c = (y >= nz) ? 1 : 0; nz = (y - nz) & 0xff +#define AND nz = a &= GetByte(addr) +#define AND_ZP nz = a &= dGetByte(addr) +#define ORA nz = a |= GetByte(addr) +#define ORA_ZP nz = a |= dGetByte(addr) +#define EOR nz = a ^= GetByte(addr) +#define EOR_ZP nz = a ^= dGetByte(addr) +#define ADC data = GetByte(addr); DO_ADC +#define ADC_ZP data = dGetByte(addr); DO_ADC +#define SBC data = GetByte(addr); DO_SBC +#define SBC_ZP data = dGetByte(addr); DO_SBC + +#define ASL RMW_GetByte(nz, addr); c = nz >> 7; nz = (nz << 1) & 0xff; PutByte(addr, nz) +#define ASL_ZP nz = dGetByte(addr); c = nz >> 7; nz = (nz << 1) & 0xff; dPutByte(addr, nz) +#define ROL RMW_GetByte(nz, addr); nz = (nz << 1) + c; c = nz >> 8; nz &= 0xff; PutByte(addr, nz) +#define ROL_ZP nz = dGetByte(addr); nz = (nz << 1) + c; c = nz >> 8; nz &= 0xff; dPutByte(addr, nz) +#define LSR RMW_GetByte(nz, addr); c = nz & 1; nz >>= 1; PutByte(addr, nz) +#define LSR_ZP nz = dGetByte(addr); c = nz & 1; nz >>= 1; dPutByte(addr, nz) +#define ROR \ + RMW_GetByte(nz, addr); \ + if (c == 0) { \ + c = nz & 1; \ + nz >>= 1; \ + } \ + else { \ + c = nz & 1; \ + nz = (nz >> 1) + 128; \ + } \ + PutByte(addr, nz) +#define ROR_ZP \ + nz = dGetByte(addr); \ + if (c == 0) { \ + c = nz & 1; \ + nz >>= 1; \ + } \ + else { \ + c = nz & 1; \ + nz = (nz >> 1) + 128; \ + } \ + dPutByte(addr, nz) +#define DEC RMW_GetByte(nz, addr); nz = (nz - 1) & 0xff; PutByte(addr, nz) +#define DEC_ZP nz = dGetByte(addr); nz = (nz - 1) & 0xff; dPutByte(addr, nz) +#define INC RMW_GetByte(nz, addr); nz = (nz + 1) & 0xff; PutByte(addr, nz) +#define INC_ZP nz = dGetByte(addr); nz = (nz + 1) & 0xff; dPutByte(addr, nz) + +#define ASO ASL; nz = a |= nz +#define ASO_ZP ASL_ZP; nz = a |= nz +#define RLA ROL; nz = a &= nz +#define RLA_ZP ROL_ZP; nz = a &= nz +#define LSE LSR; nz = a ^= nz +#define LSE_ZP LSR_ZP; nz = a ^= nz +#define RRA ROR; data = nz; DO_ADC +#define RRA_ZP ROR_ZP; data = nz; DO_ADC +#define DCM DEC; c = (a >= nz) ? 1 : 0; nz = (a - nz) & 0xff +#define DCM_ZP DEC_ZP; c = (a >= nz) ? 1 : 0; nz = (a - nz) & 0xff +#define INS INC; data = nz; DO_SBC +#define INS_ZP INC_ZP; data = nz; DO_SBC + +#define BRANCH(cond) \ + if (cond) { \ + addr = SBYTE(FETCH); \ + addr += pc; \ + if (((addr ^ pc) & 0xff00) != 0) \ + AST cycle++; \ + AST cycle++; \ + pc = addr; \ + break; \ + } \ + pc++; \ + break + +#define CHECK_IRQ \ + if ((vdi & I_FLAG) == 0 && AST irqst != 0xff) { \ + PHPC; \ + PHPB0; \ + vdi |= I_FLAG; \ + pc = dGetWord(0xfffe); \ + AST cycle += 7; \ + } + +ASAP_FUNC void Cpu_RunScanlines(ASAP_State PTR ast, int scanlines) +{ + int pc; + int nz; + int a; + int x; + int y; + int c; + int s; + int vdi; + int next_event_cycle; + int cycle_limit; + pc = AST cpu_pc; + nz = AST cpu_nz; + a = AST cpu_a; + x = AST cpu_x; + y = AST cpu_y; + c = AST cpu_c; + s = AST cpu_s; + vdi = AST cpu_vdi; + AST next_scanline_cycle = 114; + next_event_cycle = 114; + cycle_limit = 114 * scanlines; + if (next_event_cycle > AST timer1_cycle) + next_event_cycle = AST timer1_cycle; + if (next_event_cycle > AST timer2_cycle) + next_event_cycle = AST timer2_cycle; + if (next_event_cycle > AST timer4_cycle) + next_event_cycle = AST timer4_cycle; + AST nearest_event_cycle = next_event_cycle; + for (;;) { + int cycle; + int addr; + int data; + cycle = AST cycle; + if (cycle >= AST nearest_event_cycle) { + if (cycle >= AST next_scanline_cycle) { + if (++AST scanline_number == 312) + AST scanline_number = 0; + AST cycle = cycle += 9; + AST next_scanline_cycle += 114; + if (--scanlines <= 0) + break; + } + next_event_cycle = AST next_scanline_cycle; +#define CHECK_TIMER_IRQ(ch) \ + if (cycle >= AST timer##ch##_cycle) { \ + AST irqst &= ~ch; \ + AST timer##ch##_cycle = NEVER; \ + } \ + else if (next_event_cycle > AST timer##ch##_cycle) \ + next_event_cycle = AST timer##ch##_cycle; + CHECK_TIMER_IRQ(1); + CHECK_TIMER_IRQ(2); + CHECK_TIMER_IRQ(4); + AST nearest_event_cycle = next_event_cycle; + CHECK_IRQ; + } +#ifdef ASAPSCAN + if (cpu_trace) + print_cpu_state(as, pc, a, x, y, s, nz, vdi, c); +#endif + data = FETCH; + AST cycle += opcode_cycles[data]; + switch (data) { + case 0x00: /* BRK */ + pc++; + PHPC; + PHPB1; + vdi |= I_FLAG; + pc = dGetWord(0xfffe); + break; + case 0x01: /* ORA (ab,x) */ + INDIRECT_X; + ORA; + break; + case 0x02: /* CIM [unofficial] */ + case 0x12: + case 0x22: + case 0x32: + case 0x42: + case 0x52: + case 0x62: + case 0x72: + case 0x92: + case 0xb2: + case 0xd2: + case 0xf2: + AST scanline_number = (AST scanline_number + scanlines - 1) % 312; + scanlines = 1; + AST cycle = cycle_limit; + break; + case 0x03: /* ASO (ab,x) [unofficial] */ + INDIRECT_X; + ASO; + break; + case 0x04: /* NOP ab [unofficial] */ + case 0x44: + case 0x64: + case 0x14: /* NOP ab,x [unofficial] */ + case 0x34: + case 0x54: + case 0x74: + case 0xd4: + case 0xf4: + case 0x80: /* NOP #ab [unofficial] */ + case 0x82: + case 0x89: + case 0xc2: + case 0xe2: + pc++; + break; + case 0x05: /* ORA ab */ + ZPAGE; + ORA_ZP; + break; + case 0x06: /* ASL ab */ + ZPAGE; + ASL_ZP; + break; + case 0x07: /* ASO ab [unofficial] */ + ZPAGE; + ASO_ZP; + break; + case 0x08: /* PHP */ + PHPB1; + break; + case 0x09: /* ORA #ab */ + nz = a |= FETCH; + break; + case 0x0a: /* ASL */ + c = a >> 7; + nz = a = (a << 1) & 0xff; + break; + case 0x0b: /* ANC #ab [unofficial] */ + case 0x2b: + nz = a &= FETCH; + c = nz >> 7; + break; + case 0x0c: /* NOP abcd [unofficial] */ + pc += 2; + break; + case 0x0d: /* ORA abcd */ + ABSOLUTE; + ORA; + break; + case 0x0e: /* ASL abcd */ + ABSOLUTE; + ASL; + break; + case 0x0f: /* ASO abcd [unofficial] */ + ABSOLUTE; + ASO; + break; + case 0x10: /* BPL */ + BRANCH(nz < 0x80); + case 0x11: /* ORA (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + ORA; + break; + case 0x13: /* ASO (ab),y [unofficial] */ + INDIRECT_Y; + ASO; + break; + case 0x15: /* ORA ab,x */ + ZPAGE_X; + ORA_ZP; + break; + case 0x16: /* ASL ab,x */ + ZPAGE_X; + ASL_ZP; + break; + case 0x17: /* ASO ab,x [unofficial] */ + ZPAGE_X; + ASO_ZP; + break; + case 0x18: /* CLC */ + c = 0; + break; + case 0x19: /* ORA abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + ORA; + break; + case 0x1b: /* ASO abcd,y [unofficial] */ + ABSOLUTE_Y; + ASO; + break; + case 0x1c: /* NOP abcd,x [unofficial] */ + case 0x3c: + case 0x5c: + case 0x7c: + case 0xdc: + case 0xfc: + if (FETCH + x >= 0x100) + AST cycle++; + pc++; + break; + case 0x1d: /* ORA abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + ORA; + break; + case 0x1e: /* ASL abcd,x */ + ABSOLUTE_X; + ASL; + break; + case 0x1f: /* ASO abcd,x [unofficial] */ + ABSOLUTE_X; + ASO; + break; + case 0x20: /* JSR abcd */ + addr = FETCH; + PHPC; + pc = addr + (PEEK << 8); + break; + case 0x21: /* AND (ab,x) */ + INDIRECT_X; + AND; + break; + case 0x23: /* RLA (ab,x) [unofficial] */ + INDIRECT_X; + RLA; + break; + case 0x24: /* BIT ab */ + ZPAGE; + nz = dGetByte(addr); + vdi = (vdi & (D_FLAG | I_FLAG)) + (nz & V_FLAG); + nz = ((nz & 0x80) << 1) + (nz & a); + break; + case 0x25: /* AND ab */ + ZPAGE; + AND_ZP; + break; + case 0x26: /* ROL ab */ + ZPAGE; + ROL_ZP; + break; + case 0x27: /* RLA ab [unofficial] */ + ZPAGE; + RLA_ZP; + break; + case 0x28: /* PLP */ + PLP; + CHECK_IRQ; + break; + case 0x29: /* AND #ab */ + nz = a &= FETCH; + break; + case 0x2a: /* ROL */ + a = (a << 1) + c; + c = a >> 8; + nz = a &= 0xff; + break; + case 0x2c: /* BIT abcd */ + ABSOLUTE; + nz = GetByte(addr); + vdi = (vdi & (D_FLAG | I_FLAG)) + (nz & V_FLAG); + nz = ((nz & 0x80) << 1) + (nz & a); + break; + case 0x2d: /* AND abcd */ + ABSOLUTE; + AND; + break; + case 0x2e: /* ROL abcd */ + ABSOLUTE; + ROL; + break; + case 0x2f: /* RLA abcd [unofficial] */ + ABSOLUTE; + RLA; + break; + case 0x30: /* BMI */ + BRANCH(nz >= 0x80); + case 0x31: /* AND (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + AND; + break; + case 0x33: /* RLA (ab),y [unofficial] */ + INDIRECT_Y; + RLA; + break; + case 0x35: /* AND ab,x */ + ZPAGE_X; + AND_ZP; + break; + case 0x36: /* ROL ab,x */ + ZPAGE_X; + ROL_ZP; + break; + case 0x37: /* RLA ab,x [unofficial] */ + ZPAGE_X; + RLA_ZP; + break; + case 0x38: /* SEC */ + c = 1; + break; + case 0x39: /* AND abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + AND; + break; + case 0x3b: /* RLA abcd,y [unofficial] */ + ABSOLUTE_Y; + RLA; + break; + case 0x3d: /* AND abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + AND; + break; + case 0x3e: /* ROL abcd,x */ + ABSOLUTE_X; + ROL; + break; + case 0x3f: /* RLA abcd,x [unofficial] */ + ABSOLUTE_X; + RLA; + break; + case 0x40: /* RTI */ + PLP; + PL(pc); + PL(addr); + pc += addr << 8; + CHECK_IRQ; + break; + case 0x41: /* EOR (ab,x) */ + INDIRECT_X; + EOR; + break; + case 0x43: /* LSE (ab,x) [unofficial] */ + INDIRECT_X; + LSE; + break; + case 0x45: /* EOR ab */ + ZPAGE; + EOR_ZP; + break; + case 0x46: /* LSR ab */ + ZPAGE; + LSR_ZP; + break; + case 0x47: /* LSE ab [unofficial] */ + ZPAGE; + LSE_ZP; + break; + case 0x48: /* PHA */ + PH(a); + break; + case 0x49: /* EOR #ab */ + nz = a ^= FETCH; + break; + case 0x4a: /* LSR */ + c = a & 1; + nz = a >>= 1; + break; + case 0x4b: /* ALR #ab [unofficial] */ + a &= FETCH; + c = a & 1; + nz = a >>= 1; + break; + case 0x4c: /* JMP abcd */ + addr = FETCH; + pc = addr + (PEEK << 8); + break; + case 0x4d: /* EOR abcd */ + ABSOLUTE; + EOR; + break; + case 0x4e: /* LSR abcd */ + ABSOLUTE; + LSR; + break; + case 0x4f: /* LSE abcd [unofficial] */ + ABSOLUTE; + LSE; + break; + case 0x50: /* BVC */ + BRANCH((vdi & V_FLAG) == 0); + case 0x51: /* EOR (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + EOR; + break; + case 0x53: /* LSE (ab),y [unofficial] */ + INDIRECT_Y; + LSE; + break; + case 0x55: /* EOR ab,x */ + ZPAGE_X; + EOR_ZP; + break; + case 0x56: /* LSR ab,x */ + ZPAGE_X; + LSR_ZP; + break; + case 0x57: /* LSE ab,x [unofficial] */ + ZPAGE_X; + LSE_ZP; + break; + case 0x58: /* CLI */ + vdi &= V_FLAG | D_FLAG; + CHECK_IRQ; + break; + case 0x59: /* EOR abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + EOR; + break; + case 0x5b: /* LSE abcd,y [unofficial] */ + ABSOLUTE_Y; + LSE; + break; + case 0x5d: /* EOR abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + EOR; + break; + case 0x5e: /* LSR abcd,x */ + ABSOLUTE_X; + LSR; + break; + case 0x5f: /* LSE abcd,x [unofficial] */ + ABSOLUTE_X; + LSE; + break; + case 0x60: /* RTS */ + PL(pc); + PL(addr); + pc += (addr << 8) + 1; + break; + case 0x61: /* ADC (ab,x) */ + INDIRECT_X; + ADC; + break; + case 0x63: /* RRA (ab,x) [unofficial] */ + INDIRECT_X; + RRA; + break; + case 0x65: /* ADC ab */ + ZPAGE; + ADC_ZP; + break; + case 0x66: /* ROR ab */ + ZPAGE; + ROR_ZP; + break; + case 0x67: /* RRA ab [unofficial] */ + ZPAGE; + RRA_ZP; + break; + case 0x68: /* PLA */ + PL(a); + nz = a; + break; + case 0x69: /* ADC #ab */ + data = FETCH; + DO_ADC; + break; + case 0x6a: /* ROR */ + nz = (c << 7) + (a >> 1); + c = a & 1; + a = nz; + break; + case 0x6b: /* ARR #ab [unofficial] */ + data = a & FETCH; + nz = a = (data >> 1) + (c << 7); + vdi = (vdi & (D_FLAG | I_FLAG)) + ((a ^ data) & V_FLAG); + if ((vdi & D_FLAG) == 0) + c = data >> 7; + else { + if ((data & 0xf) + (data & 1) > 5) + a = (a & 0xf0) + ((a + 6) & 0xf); + if (data + (data & 0x10) >= 0x60) { + a += 0x60; + c = 1; + } + else + c = 0; + a &= 0xff; + } + break; + case 0x6c: /* JMP (abcd) */ + ABSOLUTE; + if ((addr & 0xff) == 0xff) + pc = (dGetByte(addr - 0xff) << 8) + dGetByte(addr); + else + pc = dGetWord(addr); + break; + case 0x6d: /* ADC abcd */ + ABSOLUTE; + ADC; + break; + case 0x6e: /* ROR abcd */ + ABSOLUTE; + ROR; + break; + case 0x6f: /* RRA abcd [unofficial] */ + ABSOLUTE; + RRA; + break; + case 0x70: /* BVS */ + BRANCH((vdi & V_FLAG) != 0); + case 0x71: /* ADC (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + ADC; + break; + case 0x73: /* RRA (ab),y [unofficial] */ + INDIRECT_Y; + RRA; + break; + case 0x75: /* ADC ab,x */ + ZPAGE_X; + ADC_ZP; + break; + case 0x76: /* ROR ab,x */ + ZPAGE_X; + ROR_ZP; + break; + case 0x77: /* RRA ab,x [unofficial] */ + ZPAGE_X; + RRA_ZP; + break; + case 0x78: /* SEI */ + vdi |= I_FLAG; + break; + case 0x79: /* ADC abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + ADC; + break; + case 0x7b: /* RRA abcd,y [unofficial] */ + ABSOLUTE_Y; + RRA; + break; + case 0x7d: /* ADC abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + ADC; + break; + case 0x7e: /* ROR abcd,x */ + ABSOLUTE_X; + ROR; + break; + case 0x7f: /* RRA abcd,x [unofficial] */ + ABSOLUTE_X; + RRA; + break; + case 0x81: /* STA (ab,x) */ + INDIRECT_X; + STA; + break; + case 0x83: /* SAX (ab,x) [unofficial] */ + INDIRECT_X; + SAX; + break; + case 0x84: /* STY ab */ + ZPAGE; + STY_ZP; + break; + case 0x85: /* STA ab */ + ZPAGE; + STA_ZP; + break; + case 0x86: /* STX ab */ + ZPAGE; + STX_ZP; + break; + case 0x87: /* SAX ab [unofficial] */ + ZPAGE; + SAX_ZP; + break; + case 0x88: /* DEY */ + nz = y = (y - 1) & 0xff; + break; + case 0x8a: /* TXA */ + nz = a = x; + break; + case 0x8b: /* ANE #ab [unofficial] */ + data = FETCH; + a &= x; + nz = a & data; + a &= data | 0xef; + break; + case 0x8c: /* STY abcd */ + ABSOLUTE; + STY; + break; + case 0x8d: /* STA abcd */ + ABSOLUTE; + STA; + break; + case 0x8e: /* STX abcd */ + ABSOLUTE; + STX; + break; + case 0x8f: /* SAX abcd [unofficial] */ + ABSOLUTE; + SAX; + break; + case 0x90: /* BCC */ + BRANCH(c == 0); + case 0x91: /* STA (ab),y */ + INDIRECT_Y; + STA; + break; + case 0x93: /* SHA (ab),y [unofficial, unstable] */ + ZPAGE; + data = zGetByte(addr + 1); + addr = (dGetByte(addr) + (data << 8) + y) & 0xffff; + data = a & x & (data + 1); + PutByte(addr, data); + break; + case 0x94: /* STY ab,x */ + ZPAGE_X; + STY_ZP; + break; + case 0x95: /* STA ab,x */ + ZPAGE_X; + STA_ZP; + break; + case 0x96: /* STX ab,y */ + ZPAGE_Y; + STX_ZP; + break; + case 0x97: /* SAX ab,y [unofficial] */ + ZPAGE_Y; + SAX_ZP; + break; + case 0x98: /* TYA */ + nz = a = y; + break; + case 0x99: /* STA abcd,y */ + ABSOLUTE_Y; + STA; + break; + case 0x9a: /* TXS */ + s = x; + break; + case 0x9b: /* SHS abcd,y [unofficial, unstable] */ + /* S seems to be stable, only memory values vary */ + addr = FETCH; + data = FETCH; + addr = (addr + (data << 8) + y) & 0xffff; + s = a & x; + data = s & (data + 1); + PutByte(addr, data); + break; + case 0x9c: /* SHY abcd,x [unofficial] */ + addr = FETCH; + data = FETCH; + addr = (addr + (data << 8) + x) & 0xffff; + data = y & (data + 1); + PutByte(addr, data); + break; + case 0x9d: /* STA abcd,x */ + ABSOLUTE_X; + STA; + break; + case 0x9e: /* SHX abcd,y [unofficial] */ + addr = FETCH; + data = FETCH; + addr = (addr + (data << 8) + y) & 0xffff; + data = x & (data + 1); + PutByte(addr, data); + break; + case 0x9f: /* SHA abcd,y [unofficial, unstable] */ + addr = FETCH; + data = FETCH; + addr = (addr + (data << 8) + y) & 0xffff; + data = a & x & (data + 1); + PutByte(addr, data); + break; + case 0xa0: /* LDY #ab */ + nz = y = FETCH; + break; + case 0xa1: /* LDA (ab,x) */ + INDIRECT_X; + LDA; + break; + case 0xa2: /* LDX #ab */ + nz = x = FETCH; + break; + case 0xa3: /* LAX (ab,x) [unofficial] */ + INDIRECT_X; + LAX; + break; + case 0xa4: /* LDY ab */ + ZPAGE; + LDY_ZP; + break; + case 0xa5: /* LDA ab */ + ZPAGE; + LDA_ZP; + break; + case 0xa6: /* LDX ab */ + ZPAGE; + LDX_ZP; + break; + case 0xa7: /* LAX ab [unofficial] */ + ZPAGE; + LAX_ZP; + break; + case 0xa8: /* TAY */ + nz = y = a; + break; + case 0xa9: /* LDA #ab */ + nz = a = FETCH; + break; + case 0xaa: /* TAX */ + nz = x = a; + break; + case 0xab: /* ANX #ab [unofficial] */ + nz = x = a &= FETCH; + break; + case 0xac: /* LDY abcd */ + ABSOLUTE; + LDY; + break; + case 0xad: /* LDA abcd */ + ABSOLUTE; + LDA; + break; + case 0xae: /* LDX abcd */ + ABSOLUTE; + LDX; + break; + case 0xaf: /* LAX abcd [unofficial] */ + ABSOLUTE; + LAX; + break; + case 0xb0: /* BCS */ + BRANCH(c != 0); + case 0xb1: /* LDA (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + LDA; + break; + case 0xb3: /* LAX (ab),y [unofficial] */ + INDIRECT_Y; + NCYCLES_Y; + LAX; + break; + case 0xb4: /* LDY ab,x */ + ZPAGE_X; + LDY_ZP; + break; + case 0xb5: /* LDA ab,x */ + ZPAGE_X; + LDA_ZP; + break; + case 0xb6: /* LDX ab,y */ + ZPAGE_Y; + LDX_ZP; + break; + case 0xb7: /* LAX ab,y [unofficial] */ + ZPAGE_Y; + LAX_ZP; + break; + case 0xb8: /* CLV */ + vdi &= D_FLAG | I_FLAG; + break; + case 0xb9: /* LDA abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + LDA; + break; + case 0xba: /* TSX */ + nz = x = s; + break; + case 0xbb: /* LAS abcd,y [unofficial] */ + ABSOLUTE_Y; + NCYCLES_Y; + nz = x = a = s &= GetByte(addr); + break; + case 0xbc: /* LDY abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + LDY; + break; + case 0xbd: /* LDA abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + LDA; + break; + case 0xbe: /* LDX abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + LDX; + break; + case 0xbf: /* LAX abcd,y [unofficial] */ + ABSOLUTE_Y; + NCYCLES_Y; + LAX; + break; + case 0xc0: /* CPY #ab */ + nz = FETCH; + c = (y >= nz) ? 1 : 0; + nz = (y - nz) & 0xff; + break; + case 0xc1: /* CMP (ab,x) */ + INDIRECT_X; + CMP; + break; + case 0xc3: /* DCM (ab,x) [unofficial] */ + INDIRECT_X; + DCM; + break; + case 0xc4: /* CPY ab */ + ZPAGE; + CPY_ZP; + break; + case 0xc5: /* CMP ab */ + ZPAGE; + CMP_ZP; + break; + case 0xc6: /* DEC ab */ + ZPAGE; + DEC_ZP; + break; + case 0xc7: /* DCM ab [unofficial] */ + ZPAGE; + DCM_ZP; + break; + case 0xc8: /* INY */ + nz = y = (y + 1) & 0xff; + break; + case 0xc9: /* CMP #ab */ + nz = FETCH; + c = (a >= nz) ? 1 : 0; + nz = (a - nz) & 0xff; + break; + case 0xca: /* DEX */ + nz = x = (x - 1) & 0xff; + break; + case 0xcb: /* SBX #ab [unofficial] */ + nz = FETCH; + x &= a; + c = (x >= nz) ? 1 : 0; + nz = x = (x - nz) & 0xff; + break; + case 0xcc: /* CPY abcd */ + ABSOLUTE; + CPY; + break; + case 0xcd: /* CMP abcd */ + ABSOLUTE; + CMP; + break; + case 0xce: /* DEC abcd */ + ABSOLUTE; + DEC; + break; + case 0xcf: /* DCM abcd [unofficial] */ + ABSOLUTE; + DCM; + break; + case 0xd0: /* BNE */ + BRANCH((nz & 0xff) != 0); + case 0xd1: /* CMP (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + CMP; + break; + case 0xd3: /* DCM (ab),y [unofficial] */ + INDIRECT_Y; + DCM; + break; + case 0xd5: /* CMP ab,x */ + ZPAGE_X; + CMP_ZP; + break; + case 0xd6: /* DEC ab,x */ + ZPAGE_X; + DEC_ZP; + break; + case 0xd7: /* DCM ab,x [unofficial] */ + ZPAGE_X; + DCM_ZP; + break; + case 0xd8: /* CLD */ + vdi &= V_FLAG | I_FLAG; + break; + case 0xd9: /* CMP abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + CMP; + break; + case 0xdb: /* DCM abcd,y [unofficial] */ + ABSOLUTE_Y; + DCM; + break; + case 0xdd: /* CMP abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + CMP; + break; + case 0xde: /* DEC abcd,x */ + ABSOLUTE_X; + DEC; + break; + case 0xdf: /* DCM abcd,x [unofficial] */ + ABSOLUTE_X; + DCM; + break; + case 0xe0: /* CPX #ab */ + nz = FETCH; + c = (x >= nz) ? 1 : 0; + nz = (x - nz) & 0xff; + break; + case 0xe1: /* SBC (ab,x) */ + INDIRECT_X; + SBC; + break; + case 0xe3: /* INS (ab,x) [unofficial] */ + INDIRECT_X; + INS; + break; + case 0xe4: /* CPX ab */ + ZPAGE; + CPX_ZP; + break; + case 0xe5: /* SBC ab */ + ZPAGE; + SBC_ZP; + break; + case 0xe6: /* INC ab */ + ZPAGE; + INC_ZP; + break; + case 0xe7: /* INS ab [unofficial] */ + ZPAGE; + INS_ZP; + break; + case 0xe8: /* INX */ + nz = x = (x + 1) & 0xff; + break; + case 0xe9: /* SBC #ab */ + case 0xeb: /* SBC #ab [unofficial] */ + data = FETCH; + DO_SBC; + break; + case 0xea: /* NOP */ + case 0x1a: /* NOP [unofficial] */ + case 0x3a: + case 0x5a: + case 0x7a: + case 0xda: + case 0xfa: + break; + case 0xec: /* CPX abcd */ + ABSOLUTE; + CPX; + break; + case 0xed: /* SBC abcd */ + ABSOLUTE; + SBC; + break; + case 0xee: /* INC abcd */ + ABSOLUTE; + INC; + break; + case 0xef: /* INS abcd [unofficial] */ + ABSOLUTE; + INS; + break; + case 0xf0: /* BEQ */ + BRANCH((nz & 0xff) == 0); + case 0xf1: /* SBC (ab),y */ + INDIRECT_Y; + NCYCLES_Y; + SBC; + break; + case 0xf3: /* INS (ab),y [unofficial] */ + INDIRECT_Y; + INS; + break; + case 0xf5: /* SBC ab,x */ + ZPAGE_X; + SBC_ZP; + break; + case 0xf6: /* INC ab,x */ + ZPAGE_X; + INC_ZP; + break; + case 0xf7: /* INS ab,x [unofficial] */ + ZPAGE_X; + INS_ZP; + break; + case 0xf8: /* SED */ + vdi |= D_FLAG; + break; + case 0xf9: /* SBC abcd,y */ + ABSOLUTE_Y; + NCYCLES_Y; + SBC; + break; + case 0xfb: /* INS abcd,y [unofficial] */ + ABSOLUTE_Y; + INS; + break; + case 0xfd: /* SBC abcd,x */ + ABSOLUTE_X; + NCYCLES_X; + SBC; + break; + case 0xfe: /* INC abcd,x */ + ABSOLUTE_X; + INC; + break; + case 0xff: /* INS abcd,x */ + ABSOLUTE_X; + INS; + break; + } + } + AST cpu_pc = pc; + AST cpu_nz = nz; + AST cpu_a = a; + AST cpu_x = x; + AST cpu_y = y; + AST cpu_c = c; + AST cpu_s = s; + AST cpu_vdi = vdi; + AST cycle -= cycle_limit; + if (AST timer1_cycle != NEVER) + AST timer1_cycle -= cycle_limit; + if (AST timer2_cycle != NEVER) + AST timer2_cycle -= cycle_limit; + if (AST timer4_cycle != NEVER) + AST timer4_cycle -= cycle_limit; +} Index: apps/plugins/asap/apokeysnd.c =================================================================== --- apps/plugins/asap/apokeysnd.c (revision 0) +++ apps/plugins/asap/apokeysnd.c (revision 0) @@ -0,0 +1,537 @@ +/* + * apokeysnd.c - another POKEY sound emulator + * + * Copyright (C) 2007-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#if !defined(JAVA) && !defined(CSHARP) +#include +#endif + +#include "asap_internal.h" + +#define ULTRASOUND_CYCLES 112 + +#define MUTE_FREQUENCY 1 +#define MUTE_INIT 2 +#define MUTE_USER 4 + +CONST_LOOKUP(byte, poly4_lookup) = + { 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1 }; +CONST_LOOKUP(byte, poly5_lookup) = + { 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, + 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1 }; + +FILE_FUNC void init_state(PokeyState PTR pst) +{ + PST audctl = 0; + PST init = FALSE; + PST poly_index = 15 * 31 * 131071; + PST div_cycles = 28; + PST mute1 = MUTE_FREQUENCY | MUTE_USER; + PST mute2 = MUTE_FREQUENCY | MUTE_USER; + PST mute3 = MUTE_FREQUENCY | MUTE_USER; + PST mute4 = MUTE_FREQUENCY | MUTE_USER; + PST audf1 = 0; + PST audf2 = 0; + PST audf3 = 0; + PST audf4 = 0; + PST audc1 = 0; + PST audc2 = 0; + PST audc3 = 0; + PST audc4 = 0; + PST tick_cycle1 = NEVER; + PST tick_cycle2 = NEVER; + PST tick_cycle3 = NEVER; + PST tick_cycle4 = NEVER; + PST period_cycles1 = 28; + PST period_cycles2 = 28; + PST period_cycles3 = 28; + PST period_cycles4 = 28; + PST reload_cycles1 = 28; + PST reload_cycles3 = 28; + PST out1 = 0; + PST out2 = 0; + PST out3 = 0; + PST out4 = 0; + PST delta1 = 0; + PST delta2 = 0; + PST delta3 = 0; + PST delta4 = 0; + PST skctl = 3; + ZERO_ARRAY(PST delta_buffer); +} + +ASAP_FUNC void PokeySound_Initialize(ASAP_State PTR ast) +{ + int i; + int reg; + reg = 0x1ff; + for (i = 0; i < 511; i++) { + reg = ((((reg >> 5) ^ reg) & 1) << 8) + (reg >> 1); + AST poly9_lookup[i] = (byte) reg; + } + reg = 0x1ffff; + for (i = 0; i < 16385; i++) { + reg = ((((reg >> 5) ^ reg) & 0xff) << 9) + (reg >> 8); + AST poly17_lookup[i] = (byte) (reg >> 1); + } + AST sample_offset = 0; + AST sample_index = 0; + AST samples = 0; + AST iir_acc_left = 0; + AST iir_acc_right = 0; + init_state(ADDRESSOF AST base_pokey); + init_state(ADDRESSOF AST extra_pokey); +} + +#define CYCLE_TO_SAMPLE(cycle) (((cycle) * ASAP_SAMPLE_RATE + AST sample_offset) / ASAP_MAIN_CLOCK) + +#define DO_TICK(ch) \ + if (PST init) { \ + switch (PST audc##ch >> 4) { \ + case 10: \ + case 14: \ + PST out##ch ^= 1; \ + PST delta_buffer[CYCLE_TO_SAMPLE(cycle)] += PST delta##ch = -PST delta##ch; \ + break; \ + default: \ + break; \ + } \ + } \ + else { \ + int poly = cycle + PST poly_index - (ch - 1); \ + int newout = PST out##ch; \ + switch (PST audc##ch >> 4) { \ + case 0: \ + if (poly5_lookup[poly % 31] != 0) { \ + if ((PST audctl & 0x80) != 0) \ + newout = AST poly9_lookup[poly % 511] & 1; \ + else { \ + poly %= 131071; \ + newout = (AST poly17_lookup[poly >> 3] >> (poly & 7)) & 1; \ + } \ + } \ + break; \ + case 2: \ + case 6: \ + newout ^= poly5_lookup[poly % 31]; \ + break; \ + case 4: \ + if (poly5_lookup[poly % 31] != 0) \ + newout = poly4_lookup[poly % 15]; \ + break; \ + case 8: \ + if ((PST audctl & 0x80) != 0) \ + newout = AST poly9_lookup[poly % 511] & 1; \ + else { \ + poly %= 131071; \ + newout = (AST poly17_lookup[poly >> 3] >> (poly & 7)) & 1; \ + } \ + break; \ + case 10: \ + case 14: \ + newout ^= 1; \ + break; \ + case 12: \ + newout = poly4_lookup[poly % 15]; \ + break; \ + default: \ + break; \ + } \ + if (newout != PST out##ch) { \ + PST out##ch = newout; \ + PST delta_buffer[CYCLE_TO_SAMPLE(cycle)] += PST delta##ch = -PST delta##ch; \ + } \ + } + +FILE_FUNC void generate(ASAP_State PTR ast, PokeyState PTR pst, int current_cycle) +{ + for (;;) { + int cycle = current_cycle; + if (cycle > PST tick_cycle1) + cycle = PST tick_cycle1; + if (cycle > PST tick_cycle2) + cycle = PST tick_cycle2; + if (cycle > PST tick_cycle3) + cycle = PST tick_cycle3; + if (cycle > PST tick_cycle4) + cycle = PST tick_cycle4; + if (cycle == current_cycle) + break; + if (cycle == PST tick_cycle3) { + PST tick_cycle3 += PST period_cycles3; + if ((PST audctl & 4) != 0 && PST delta1 > 0 && PST mute1 == 0) + PST delta_buffer[CYCLE_TO_SAMPLE(cycle)] += PST delta1 = -PST delta1; + DO_TICK(3); + } + if (cycle == PST tick_cycle4) { + PST tick_cycle4 += PST period_cycles4; + if ((PST audctl & 8) != 0) + PST tick_cycle3 = cycle + PST reload_cycles3; + if ((PST audctl & 2) != 0 && PST delta2 > 0 && PST mute2 == 0) + PST delta_buffer[CYCLE_TO_SAMPLE(cycle)] += PST delta2 = -PST delta2; + DO_TICK(4); + } + if (cycle == PST tick_cycle1) { + PST tick_cycle1 += PST period_cycles1; + if ((PST skctl & 0x88) == 8) + PST tick_cycle2 = cycle + PST period_cycles2; + DO_TICK(1); + } + if (cycle == PST tick_cycle2) { + PST tick_cycle2 += PST period_cycles2; + if ((PST audctl & 0x10) != 0) + PST tick_cycle1 = cycle + PST reload_cycles1; + else if ((PST skctl & 8) != 0) + PST tick_cycle1 = cycle + PST period_cycles1; + DO_TICK(2); + } + } +} + +#define MUTE_CHANNEL(ch, cond, mask) \ + if (cond) { \ + PST mute##ch |= mask; \ + PST tick_cycle##ch = NEVER; \ + } \ + else { \ + PST mute##ch &= ~mask; \ + if (PST tick_cycle##ch == NEVER && PST mute##ch == 0) \ + PST tick_cycle##ch = AST cycle; \ + } + +#define DO_ULTRASOUND(ch) \ + MUTE_CHANNEL(ch, PST period_cycles##ch <= ULTRASOUND_CYCLES && (PST audc##ch >> 4 == 10 || PST audc##ch >> 4 == 14), MUTE_FREQUENCY) + +#define DO_AUDC(ch) \ + if (data == PST audc##ch) \ + break; \ + generate(ast, pst, AST cycle); \ + PST audc##ch = data; \ + if ((data & 0x10) != 0) { \ + data &= 0xf; \ + if ((PST mute##ch & MUTE_USER) == 0) \ + PST delta_buffer[CYCLE_TO_SAMPLE(AST cycle)] \ + += PST delta##ch > 0 ? data - PST delta##ch : data; \ + PST delta##ch = data; \ + } \ + else { \ + data &= 0xf; \ + DO_ULTRASOUND(ch); \ + if (PST delta##ch > 0) { \ + if ((PST mute##ch & MUTE_USER) == 0) \ + PST delta_buffer[CYCLE_TO_SAMPLE(AST cycle)] \ + += data - PST delta##ch; \ + PST delta##ch = data; \ + } \ + else \ + PST delta##ch = -data; \ + } \ + break; + +#define DO_INIT(ch, cond) \ + MUTE_CHANNEL(ch, PST init && cond, MUTE_INIT) + +ASAP_FUNC void PokeySound_PutByte(ASAP_State PTR ast, int addr, int data) +{ + PokeyState PTR pst = (addr & AST extra_pokey_mask) != 0 + ? ADDRESSOF AST extra_pokey : ADDRESSOF AST base_pokey; + switch (addr & 0xf) { + case 0x00: + if (data == PST audf1) + break; + generate(ast, pst, AST cycle); + PST audf1 = data; + switch (PST audctl & 0x50) { + case 0x00: + PST period_cycles1 = PST div_cycles * (data + 1); + break; + case 0x10: + PST period_cycles2 = PST div_cycles * (data + 256 * PST audf2 + 1); + PST reload_cycles1 = PST div_cycles * (data + 1); + DO_ULTRASOUND(2); + break; + case 0x40: + PST period_cycles1 = data + 4; + break; + case 0x50: + PST period_cycles2 = data + 256 * PST audf2 + 7; + PST reload_cycles1 = data + 4; + DO_ULTRASOUND(2); + break; + } + DO_ULTRASOUND(1); + break; + case 0x01: + DO_AUDC(1) + case 0x02: + if (data == PST audf2) + break; + generate(ast, pst, AST cycle); + PST audf2 = data; + switch (PST audctl & 0x50) { + case 0x00: + case 0x40: + PST period_cycles2 = PST div_cycles * (data + 1); + break; + case 0x10: + PST period_cycles2 = PST div_cycles * (PST audf1 + 256 * data + 1); + break; + case 0x50: + PST period_cycles2 = PST audf1 + 256 * data + 7; + break; + } + DO_ULTRASOUND(2); + break; + case 0x03: + DO_AUDC(2) + case 0x04: + if (data == PST audf3) + break; + generate(ast, pst, AST cycle); + PST audf3 = data; + switch (PST audctl & 0x28) { + case 0x00: + PST period_cycles3 = PST div_cycles * (data + 1); + break; + case 0x08: + PST period_cycles4 = PST div_cycles * (data + 256 * PST audf4 + 1); + PST reload_cycles3 = PST div_cycles * (data + 1); + DO_ULTRASOUND(4); + break; + case 0x20: + PST period_cycles3 = data + 4; + break; + case 0x28: + PST period_cycles4 = data + 256 * PST audf4 + 7; + PST reload_cycles3 = data + 4; + DO_ULTRASOUND(4); + break; + } + DO_ULTRASOUND(3); + break; + case 0x05: + DO_AUDC(3) + case 0x06: + if (data == PST audf4) + break; + generate(ast, pst, AST cycle); + PST audf4 = data; + switch (PST audctl & 0x28) { + case 0x00: + case 0x20: + PST period_cycles4 = PST div_cycles * (data + 1); + break; + case 0x08: + PST period_cycles4 = PST div_cycles * (PST audf3 + 256 * data + 1); + break; + case 0x28: + PST period_cycles4 = PST audf3 + 256 * data + 7; + break; + } + DO_ULTRASOUND(4); + break; + case 0x07: + DO_AUDC(4) + case 0x08: + if (data == PST audctl) + break; + generate(ast, pst, AST cycle); + PST audctl = data; + PST div_cycles = ((data & 1) != 0) ? 114 : 28; + /* TODO: tick_cycles */ + switch (data & 0x50) { + case 0x00: + PST period_cycles1 = PST div_cycles * (PST audf1 + 1); + PST period_cycles2 = PST div_cycles * (PST audf2 + 1); + break; + case 0x10: + PST period_cycles1 = PST div_cycles * 256; + PST period_cycles2 = PST div_cycles * (PST audf1 + 256 * PST audf2 + 1); + PST reload_cycles1 = PST div_cycles * (PST audf1 + 1); + break; + case 0x40: + PST period_cycles1 = PST audf1 + 4; + PST period_cycles2 = PST div_cycles * (PST audf2 + 1); + break; + case 0x50: + PST period_cycles1 = 256; + PST period_cycles2 = PST audf1 + 256 * PST audf2 + 7; + PST reload_cycles1 = PST audf1 + 4; + break; + } + DO_ULTRASOUND(1); + DO_ULTRASOUND(2); + switch (data & 0x28) { + case 0x00: + PST period_cycles3 = PST div_cycles * (PST audf3 + 1); + PST period_cycles4 = PST div_cycles * (PST audf4 + 1); + break; + case 0x08: + PST period_cycles3 = PST div_cycles * 256; + PST period_cycles4 = PST div_cycles * (PST audf3 + 256 * PST audf4 + 1); + PST reload_cycles3 = PST div_cycles * (PST audf3 + 1); + break; + case 0x20: + PST period_cycles3 = PST audf3 + 4; + PST period_cycles4 = PST div_cycles * (PST audf4 + 1); + break; + case 0x28: + PST period_cycles3 = 256; + PST period_cycles4 = PST audf3 + 256 * PST audf4 + 7; + PST reload_cycles3 = PST audf3 + 4; + break; + } + DO_ULTRASOUND(3); + DO_ULTRASOUND(4); + break; + case 0x09: + /* TODO: STIMER */ + break; + case 0x0f: + PST skctl = data; + PST init = ((data & 3) == 0); + DO_INIT(1, (PST audctl & 0x40) == 0); + DO_INIT(2, (PST audctl & 0x50) != 0x50); + DO_INIT(3, (PST audctl & 0x20) == 0); + DO_INIT(4, (PST audctl & 0x28) != 0x28); + break; + default: + break; + } +} + +ASAP_FUNC int PokeySound_GetRandom(ASAP_State PTR ast, int addr) +{ + PokeyState PTR pst = (addr & AST extra_pokey_mask) != 0 + ? ADDRESSOF AST extra_pokey : ADDRESSOF AST base_pokey; + int i; + if (PST init) + return 0xff; + i = AST cycle + PST poly_index; + if ((PST audctl & 0x80) != 0) + return AST poly9_lookup[i % 511]; + else { + int j; + i %= 131071; + j = i >> 3; + i &= 7; + return ((AST poly17_lookup[j] >> i) + (AST poly17_lookup[j + 1] << (8 - i))) & 0xff; + } +} + +FILE_FUNC void end_frame(ASAP_State PTR ast, PokeyState PTR pst, int cycle_limit) +{ + int m; + generate(ast, pst, cycle_limit); + PST poly_index += cycle_limit; + m = ((PST audctl & 0x80) != 0) ? 15 * 31 * 511 : 15 * 31 * 131071; + if (PST poly_index >= 2 * m) + PST poly_index -= m; + if (PST tick_cycle1 != NEVER) + PST tick_cycle1 -= cycle_limit; + if (PST tick_cycle2 != NEVER) + PST tick_cycle2 -= cycle_limit; + if (PST tick_cycle3 != NEVER) + PST tick_cycle3 -= cycle_limit; + if (PST tick_cycle4 != NEVER) + PST tick_cycle4 -= cycle_limit; +} + +ASAP_FUNC void PokeySound_StartFrame(ASAP_State PTR ast) +{ + ZERO_ARRAY(AST base_pokey.delta_buffer); + if (AST extra_pokey_mask != 0) + ZERO_ARRAY(AST extra_pokey.delta_buffer); +} + +ASAP_FUNC void PokeySound_EndFrame(ASAP_State PTR ast, int current_cycle) +{ + end_frame(ast, ADDRESSOF AST base_pokey, current_cycle); + if (AST extra_pokey_mask != 0) + end_frame(ast, ADDRESSOF AST extra_pokey, current_cycle); + AST sample_offset += current_cycle * ASAP_SAMPLE_RATE; + AST sample_index = 0; + AST samples = AST sample_offset / ASAP_MAIN_CLOCK; + AST sample_offset %= ASAP_MAIN_CLOCK; +} + +ASAP_FUNC int PokeySound_Generate(ASAP_State PTR ast, byte ARRAY buffer, int buffer_offset, int blocks, ASAP_SampleFormat format) +{ + int i = AST sample_index; + int samples = AST samples; + int acc_left = AST iir_acc_left; + int acc_right = AST iir_acc_right; + if (blocks < samples - i) + samples = i + blocks; + else + blocks = samples - i; + for (; i < samples; i++) { + int sample; + acc_left += (AST base_pokey.delta_buffer[i] << 20) - (acc_left * 3 >> 10); + sample = acc_left >> 10; +#define STORE_SAMPLE \ + if (sample < -32767) \ + sample = -32767; \ + else if (sample > 32767) \ + sample = 32767; \ + switch (format) { \ + case ASAP_FORMAT_U8: \ + buffer[buffer_offset++] = (byte) ((sample >> 8) + 128); \ + break; \ + case ASAP_FORMAT_S16_LE: \ + buffer[buffer_offset++] = (byte) sample; \ + buffer[buffer_offset++] = (byte) (sample >> 8); \ + break; \ + case ASAP_FORMAT_S16_BE: \ + buffer[buffer_offset++] = (byte) (sample >> 8); \ + buffer[buffer_offset++] = (byte) sample; \ + break; \ + } + STORE_SAMPLE; + if (AST extra_pokey_mask != 0) { + acc_right += (AST extra_pokey.delta_buffer[i] << 20) - (acc_right * 3 >> 10); + sample = acc_right >> 10; + STORE_SAMPLE; + } + } + if (i == AST samples) { + acc_left += AST base_pokey.delta_buffer[i] << 20; + acc_right += AST extra_pokey.delta_buffer[i] << 20; + } + AST sample_index = i; + AST iir_acc_left = acc_left; + AST iir_acc_right = acc_right; + return blocks; +} + +ASAP_FUNC abool PokeySound_IsSilent(const PokeyState PTR pst) +{ + return ((PST audc1 | PST audc2 | PST audc3 | PST audc4) & 0xf) == 0; +} + +ASAP_FUNC void PokeySound_Mute(const ASAP_State PTR ast, PokeyState PTR pst, int mask) +{ + MUTE_CHANNEL(1, (mask & 1) != 0, MUTE_USER); + MUTE_CHANNEL(2, (mask & 2) != 0, MUTE_USER); + MUTE_CHANNEL(3, (mask & 4) != 0, MUTE_USER); + MUTE_CHANNEL(4, (mask & 8) != 0, MUTE_USER); +} Index: apps/plugins/asap/asap.c =================================================================== --- apps/plugins/asap/asap.c (revision 0) +++ apps/plugins/asap/asap.c (revision 0) @@ -0,0 +1,2000 @@ +/* + * asap.c - ASAP engine + * + * Copyright (C) 2005-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#if !defined(JAVA) && !defined(CSHARP) +#include +#endif + +#include "asap_internal.h" +#if !defined(JAVA) && !defined(CSHARP) +#include "players.h" +#endif + +#define CMR_BASS_TABLE_OFFSET 0x70f + +CONST_LOOKUP(byte, cmr_bass_table) = { + 0x5C, 0x56, 0x50, 0x4D, 0x47, 0x44, 0x41, 0x3E, + 0x38, 0x35, (byte) 0x88, 0x7F, 0x79, 0x73, 0x6C, 0x67, + 0x60, 0x5A, 0x55, 0x51, 0x4C, 0x48, 0x43, 0x3F, + 0x3D, 0x39, 0x34, 0x33, 0x30, 0x2D, 0x2A, 0x28, + 0x25, 0x24, 0x21, 0x1F, 0x1E +}; + +ASAP_FUNC int ASAP_GetByte(ASAP_State PTR ast, int addr) +{ + switch (addr & 0xff0f) { + case 0xd20a: + return PokeySound_GetRandom(ast, addr); + case 0xd20e: + if ((addr & AST extra_pokey_mask) != 0) + return 0xff; + return AST irqst; + case 0xd20f: + return 0xff; + case 0xd40b: + return AST scanline_number >> 1; + default: + return dGetByte(addr); + } +} + +ASAP_FUNC void ASAP_PutByte(ASAP_State PTR ast, int addr, int data) +{ + if ((addr >> 8) == 0xd2) { + if ((addr & (AST extra_pokey_mask + 0xf)) == 0xe) { + AST irqst |= data ^ 0xff; +#define SET_TIMER_IRQ(ch) \ + if ((data & AST irqst & ch) != 0) { \ + if (AST timer##ch##_cycle == NEVER) { \ + int t = AST base_pokey.tick_cycle##ch; \ + while (t < AST cycle) \ + t += AST base_pokey.period_cycles##ch; \ + AST timer##ch##_cycle = t; \ + if (AST nearest_event_cycle > t) \ + AST nearest_event_cycle = t; \ + } \ + } \ + else \ + AST timer##ch##_cycle = NEVER; + SET_TIMER_IRQ(1); + SET_TIMER_IRQ(2); + SET_TIMER_IRQ(4); + } + else + PokeySound_PutByte(ast, addr, data); + } + else if ((addr & 0xff0f) == 0xd40a) { + if (AST cycle <= AST next_scanline_cycle - 8) + AST cycle = AST next_scanline_cycle - 8; + else + AST cycle = AST next_scanline_cycle + 106; + } + else + dPutByte(addr, data); +} + +#define MAX_SONGS 32 + +CONST_LOOKUP(int, perframe2fastplay) = { 312, 312 / 2, 312 / 3, 312 / 4 }; + +FILE_FUNC abool load_native(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len, ASAP_OBX player) +{ +#if defined(JAVA) || defined(CSHARP) + try +#endif + { + int player_last_byte; + int block_len; + if (UBYTE(module[0]) != 0xff || UBYTE(module[1]) != 0xff) + return FALSE; +#ifdef JAVA + try { + player.read(); + player.read(); + MODULE_INFO player = player.read(); + MODULE_INFO player += player.read() << 8; + player_last_byte = player.read(); + player_last_byte += player.read() << 8; + } catch (IOException e) { + throw new RuntimeException(); + } +#elif defined(CSHARP) + player.ReadByte(); + player.ReadByte(); + MODULE_INFO player = player.ReadByte(); + MODULE_INFO player += player.ReadByte() << 8; + player_last_byte = player.ReadByte(); + player_last_byte += player.ReadByte() << 8; +#else + MODULE_INFO player = UBYTE(player[2]) + (UBYTE(player[3]) << 8); + player_last_byte = UBYTE(player[4]) + (UBYTE(player[5]) << 8); +#endif + MODULE_INFO music = UBYTE(module[2]) + (UBYTE(module[3]) << 8); + if (MODULE_INFO music <= player_last_byte) + return FALSE; + block_len = UBYTE(module[4]) + (UBYTE(module[5]) << 8) + 1 - MODULE_INFO music; + if (6 + block_len != module_len) { + int info_addr; + int info_len; + if (MODULE_INFO type != 'r' || 11 + block_len > module_len) + return FALSE; + /* allow optional info for Raster Music Tracker */ + info_addr = UBYTE(module[6 + block_len]) + (UBYTE(module[7 + block_len]) << 8); + if (info_addr != MODULE_INFO music + block_len) + return FALSE; + info_len = UBYTE(module[8 + block_len]) + (UBYTE(module[9 + block_len]) << 8) + 1 - info_addr; + if (10 + block_len + info_len != module_len) + return FALSE; + } + if (ast != NULL) { + COPY_ARRAY(AST memory, MODULE_INFO music, module, 6, block_len); +#ifdef JAVA + int addr = MODULE_INFO player; + do { + int i; + try { + i = player.read(AST memory, addr, player_last_byte + 1 - addr); + } catch (IOException e) { + throw new RuntimeException(); + } + if (i <= 0) + throw new RuntimeException(); + addr += i; + } while (addr <= player_last_byte); +#elif defined(CSHARP) + int addr = MODULE_INFO player; + do { + int i = player.Read(AST memory, addr, player_last_byte + 1 - addr); + if (i <= 0) + throw new Exception(); + addr += i; + } while (addr <= player_last_byte); +#else + COPY_ARRAY(AST memory, MODULE_INFO player, player, 6, player_last_byte + 1 - MODULE_INFO player); +#endif + } + return TRUE; + } +#ifdef JAVA + finally { + try { + player.close(); + } catch (IOException e) { + throw new RuntimeException(); + } + } +#elif defined(CSHARP) + finally { + player.Close(); + } +#endif +} + +FILE_FUNC void set_song_duration(ASAP_ModuleInfo PTR module_info, int player_calls) +{ + MODULE_INFO durations[MODULE_INFO songs] = (int) (player_calls * MODULE_INFO fastplay * 114000.0 / 1773447); + MODULE_INFO songs++; +} + +#define SEEN_THIS_CALL 1 +#define SEEN_BEFORE 2 +#define SEEN_REPEAT 3 + +FILE_FUNC void parse_cmc_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, int pos) +{ + int tempo = UBYTE(module[0x19]); + int player_calls = 0; + int rep_start_pos = 0; + int rep_end_pos = 0; + int rep_times = 0; + NEW_ARRAY(byte, seen, 0x55); + INIT_ARRAY(seen); + while (pos >= 0 && pos < 0x55) { + int p1; + int p2; + int p3; + if (pos == rep_end_pos && rep_times > 0) { + for (p1 = 0; p1 < 0x55; p1++) + if (seen[p1] == SEEN_THIS_CALL || seen[p1] == SEEN_REPEAT) + seen[p1] = 0; + rep_times--; + pos = rep_start_pos; + } + if (seen[pos] != 0) { + if (seen[pos] != SEEN_THIS_CALL) + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + seen[pos] = SEEN_THIS_CALL; + p1 = UBYTE(module[0x206 + pos]); + p2 = UBYTE(module[0x25b + pos]); + p3 = UBYTE(module[0x2b0 + pos]); + if (p1 == 0xfe || p2 == 0xfe || p3 == 0xfe) { + pos++; + continue; + } + p1 >>= 4; + if (p1 == 8) + break; + if (p1 == 9) { + pos = p2; + continue; + } + if (p1 == 0xa) { + pos -= p2; + continue; + } + if (p1 == 0xb) { + pos += p2; + continue; + } + if (p1 == 0xc) { + tempo = p2; + pos++; + continue; + } + if (p1 == 0xd) { + pos++; + rep_start_pos = pos; + rep_end_pos = pos + p2; + rep_times = p3 - 1; + continue; + } + if (p1 == 0xe) { + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + p2 = rep_times > 0 ? SEEN_REPEAT : SEEN_BEFORE; + for (p1 = 0; p1 < 0x55; p1++) + if (seen[p1] == SEEN_THIS_CALL) + seen[p1] = (byte) p2; + player_calls += tempo << 6; + pos++; + } + set_song_duration(module_info, player_calls); +} + +FILE_FUNC abool parse_cmc(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len, abool cmr) +{ + int last_pos; + int pos; + if (module_len < 0x306) + return FALSE; + MODULE_INFO type = cmr ? 'z' : 'c'; + if (!load_native(ast, module_info, module, module_len, GET_OBX(cmc))) + return FALSE; + if (ast != NULL && cmr) + COPY_ARRAY(AST memory, 0x500 + CMR_BASS_TABLE_OFFSET, cmr_bass_table, 0, sizeof(cmr_bass_table)); + /* auto-detect number of subsongs */ + last_pos = 0x54; + while (--last_pos >= 0) { + if (UBYTE(module[0x206 + last_pos]) < 0xb0 + || UBYTE(module[0x25b + last_pos]) < 0x40 + || UBYTE(module[0x2b0 + last_pos]) < 0x40) + break; + } + MODULE_INFO songs = 0; + parse_cmc_song(module_info, module, 0); + for (pos = 0; pos < last_pos && MODULE_INFO songs < MAX_SONGS; pos++) + if (UBYTE(module[0x206 + pos]) == 0x8f || UBYTE(module[0x206 + pos]) == 0xef) + parse_cmc_song(module_info, module, pos + 1); + return TRUE; +} + +FILE_FUNC void parse_mpt_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, + abool ARRAY global_seen, int song_len, int pos) +{ + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int tempo = UBYTE(module[0x1cf]); + int player_calls = 0; + NEW_ARRAY(byte, seen, 256); + NEW_ARRAY(int, pattern_offset, 4); + NEW_ARRAY(int, blank_rows, 4); + NEW_ARRAY(int, blank_rows_counter, 4); + INIT_ARRAY(seen); + INIT_ARRAY(blank_rows); + while (pos < song_len) { + int i; + int ch; + int pattern_rows; + if (seen[pos] != 0) { + if (seen[pos] != SEEN_THIS_CALL) + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + seen[pos] = SEEN_THIS_CALL; + global_seen[pos] = TRUE; + i = UBYTE(module[0x1d0 + pos * 2]); + if (i == 0xff) { + pos = UBYTE(module[0x1d1 + pos * 2]); + continue; + } + for (ch = 3; ch >= 0; ch--) { + i = UBYTE(module[0x1c6 + ch]) + (UBYTE(module[0x1ca + ch]) << 8) - addr_to_offset; + i = UBYTE(module[i + pos * 2]); + if (i >= 0x40) + break; + i <<= 1; + i = UBYTE(module[0x46 + i]) + (UBYTE(module[0x47 + i]) << 8); + pattern_offset[ch] = i == 0 ? 0 : i - addr_to_offset; + blank_rows_counter[ch] = 0; + } + if (ch >= 0) + break; + for (i = 0; i < song_len; i++) + if (seen[i] == SEEN_THIS_CALL) + seen[i] = SEEN_BEFORE; + for (pattern_rows = UBYTE(module[0x1ce]); --pattern_rows >= 0; ) { + for (ch = 3; ch >= 0; ch--) { + if (pattern_offset[ch] == 0 || --blank_rows_counter[ch] >= 0) + continue; + for (;;) { + i = UBYTE(module[pattern_offset[ch]++]); + if (i < 0x40 || i == 0xfe) + break; + if (i < 0x80) + continue; + if (i < 0xc0) { + blank_rows[ch] = i - 0x80; + continue; + } + if (i < 0xd0) + continue; + if (i < 0xe0) { + tempo = i - 0xcf; + continue; + } + pattern_rows = 0; + } + blank_rows_counter[ch] = blank_rows[ch]; + } + player_calls += tempo; + } + pos++; + } + if (player_calls > 0) + set_song_duration(module_info, player_calls); +} + +FILE_FUNC abool parse_mpt(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int track0_addr; + int pos; + int song_len; + /* seen[i] == TRUE if the track position i has been processed */ + NEW_ARRAY(abool, global_seen, 256); + if (module_len < 0x1d0) + return FALSE; + MODULE_INFO type = 'm'; + if (!load_native(ast, module_info, module, module_len, GET_OBX(mpt))) + return FALSE; + track0_addr = UBYTE(module[2]) + (UBYTE(module[3]) << 8) + 0x1ca; + if (UBYTE(module[0x1c6]) + (UBYTE(module[0x1ca]) << 8) != track0_addr) + return FALSE; + /* Calculate the length of the first track. Address of the second track minus + address of the first track equals the length of the first track in bytes. + Divide by two to get number of track positions. */ + song_len = (UBYTE(module[0x1c7]) + (UBYTE(module[0x1cb]) << 8) - track0_addr) >> 1; + if (song_len > 0xfe) + return FALSE; + INIT_ARRAY(global_seen); + MODULE_INFO songs = 0; + for (pos = 0; pos < song_len && MODULE_INFO songs < MAX_SONGS; pos++) { + if (!global_seen[pos]) { + MODULE_INFO song_pos[MODULE_INFO songs] = (byte) pos; + parse_mpt_song(module_info, module, global_seen, song_len, pos); + } + } + return MODULE_INFO songs != 0; +} + +CONST_LOOKUP(byte, rmt_volume_silent) = { 16, 8, 4, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1 }; + +FILE_FUNC int rmt_instrument_frames(const byte ARRAY module, int instrument, int volume, int volume_frame, abool extra_pokey) +{ + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int per_frame = module[0xc]; + int player_call; + int player_calls; + int index; + int index_end; + int index_loop; + int volume_slide_depth; + int volume_min; + abool looping; + int volume_slide; + abool silent_loop; + instrument = UBYTE(module[0xe]) + (UBYTE(module[0xf]) << 8) - addr_to_offset + (instrument << 1); + if (module[instrument + 1] == 0) + return 0; + instrument = UBYTE(module[instrument]) + (UBYTE(module[instrument + 1]) << 8) - addr_to_offset; + player_calls = player_call = volume_frame * per_frame; + index = UBYTE(module[instrument]) + 1 + player_call * 3; + index_end = UBYTE(module[instrument + 2]) + 3; + index_loop = UBYTE(module[instrument + 3]); + if (index_loop >= index_end) + return 0; /* error */ + volume_slide_depth = UBYTE(module[instrument + 6]); + volume_min = UBYTE(module[instrument + 7]); + looping = index >= index_end; + if (looping) + index = (index - index_end) % (index_end - index_loop) + index_loop; + else { + do { + int vol = module[instrument + index]; + if (extra_pokey) + vol >>= 4; + if ((vol & 0xf) >= rmt_volume_silent[volume]) + player_calls = player_call + 1; + player_call++; + index += 3; + } while (index < index_end); + } + if (volume_slide_depth == 0) + return player_calls / per_frame; + volume_slide = 128; + silent_loop = FALSE; + for (;;) { + int vol; + if (index >= index_end) { + if (silent_loop) + break; + silent_loop = TRUE; + index = index_loop; + } + vol = module[instrument + index]; + if (extra_pokey) + vol >>= 4; + if ((vol & 0xf) >= rmt_volume_silent[volume]) { + player_calls = player_call + 1; + silent_loop = FALSE; + } + player_call++; + index += 3; + volume_slide -= volume_slide_depth; + if (volume_slide < 0) { + volume_slide += 256; + if (--volume <= volume_min) + break; + } + } + return player_calls / per_frame; +} + +FILE_FUNC void parse_rmt_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, + abool ARRAY global_seen, int song_len, int pos_shift, int pos) +{ + int ch; + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int tempo = UBYTE(module[0xb]); + int frames = 0; + int song_offset = UBYTE(module[0x14]) + (UBYTE(module[0x15]) << 8) - addr_to_offset; + int pattern_lo_offset = UBYTE(module[0x10]) + (UBYTE(module[0x11]) << 8) - addr_to_offset; + int pattern_hi_offset = UBYTE(module[0x12]) + (UBYTE(module[0x13]) << 8) - addr_to_offset; + int instrument_frames; + NEW_ARRAY(byte, seen, 256); + NEW_ARRAY(int, pattern_begin, 8); + NEW_ARRAY(int, pattern_offset, 8); + NEW_ARRAY(int, blank_rows, 8); + NEW_ARRAY(int, instrument_no, 8); + NEW_ARRAY(int, instrument_frame, 8); + NEW_ARRAY(int, volume_value, 8); + NEW_ARRAY(int, volume_frame, 8); + INIT_ARRAY(seen); + INIT_ARRAY(instrument_no); + INIT_ARRAY(instrument_frame); + INIT_ARRAY(volume_value); + INIT_ARRAY(volume_frame); + while (pos < song_len) { + int i; + int pattern_rows; + if (seen[pos] != 0) { + if (seen[pos] != SEEN_THIS_CALL) + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + seen[pos] = SEEN_THIS_CALL; + global_seen[pos] = TRUE; + if (UBYTE(module[song_offset + (pos << pos_shift)]) == 0xfe) { + pos = UBYTE(module[song_offset + (pos << pos_shift) + 1]); + continue; + } + for (ch = 0; ch < 1 << pos_shift; ch++) { + i = UBYTE(module[song_offset + (pos << pos_shift) + ch]); + if (i == 0xff) + blank_rows[ch] = 256; + else { + pattern_offset[ch] = pattern_begin[ch] = UBYTE(module[pattern_lo_offset + i]) + + (UBYTE(module[pattern_hi_offset + i]) << 8) - addr_to_offset; + blank_rows[ch] = 0; + } + } + for (i = 0; i < song_len; i++) + if (seen[i] == SEEN_THIS_CALL) + seen[i] = SEEN_BEFORE; + for (pattern_rows = UBYTE(module[0xa]); --pattern_rows >= 0; ) { + for (ch = 0; ch < 1 << pos_shift; ch++) { + if (--blank_rows[ch] > 0) + continue; + for (;;) { + i = UBYTE(module[pattern_offset[ch]++]); + if ((i & 0x3f) < 62) { + i += UBYTE(module[pattern_offset[ch]++]) << 8; + if ((i & 0x3f) != 61) { + instrument_no[ch] = i >> 10; + instrument_frame[ch] = frames; + } + volume_value[ch] = (i >> 6) & 0xf; + volume_frame[ch] = frames; + break; + } + if (i == 62) { + blank_rows[ch] = UBYTE(module[pattern_offset[ch]++]); + break; + } + if ((i & 0x3f) == 62) { + blank_rows[ch] = i >> 6; + break; + } + if ((i & 0xbf) == 63) { + tempo = UBYTE(module[pattern_offset[ch]++]); + continue; + } + if (i == 0xbf) { + pattern_offset[ch] = pattern_begin[ch] + UBYTE(module[pattern_offset[ch]]); + continue; + } + /* assert(i == 0xff); */ + pattern_rows = -1; + break; + } + if (pattern_rows < 0) + break; + } + if (pattern_rows >= 0) + frames += tempo; + } + pos++; + } + instrument_frames = 0; + for (ch = 0; ch < 1 << pos_shift; ch++) { + int frame = instrument_frame[ch]; + frame += rmt_instrument_frames(module, instrument_no[ch], volume_value[ch], volume_frame[ch] - frame, ch >= 4); + if (instrument_frames < frame) + instrument_frames = frame; + } + if (frames > instrument_frames) { + if (frames - instrument_frames > 100) + MODULE_INFO loops[MODULE_INFO songs] = FALSE; + frames = instrument_frames; + } + if (frames > 0) + set_song_duration(module_info, frames); +} + +FILE_FUNC abool parse_rmt(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int per_frame; + int pos_shift; + int song_len; + int pos; + NEW_ARRAY(abool, global_seen, 256); + if (module_len < 0x30 || module[6] != 'R' || module[7] != 'M' + || module[8] != 'T' || module[0xd] != 1) + return FALSE; + switch ((char) module[9]) { + case '4': + pos_shift = 2; + break; + case '8': + MODULE_INFO channels = 2; + pos_shift = 3; + break; + default: + return FALSE; + } + per_frame = module[0xc]; + if (per_frame < 1 || per_frame > 4) + return FALSE; + MODULE_INFO type = 'r'; + if (!load_native(ast, module_info, module, module_len, + MODULE_INFO channels == 2 ? GET_OBX(rmt8) : GET_OBX(rmt4))) + return FALSE; + song_len = UBYTE(module[4]) + (UBYTE(module[5]) << 8) + 1 + - UBYTE(module[0x14]) - (UBYTE(module[0x15]) << 8); + if (pos_shift == 3 && (song_len & 4) != 0 + && UBYTE(module[6 + UBYTE(module[4]) + (UBYTE(module[5]) << 8) + - UBYTE(module[2]) - (UBYTE(module[3]) << 8) - 3]) == 0xfe) + song_len += 4; + song_len >>= pos_shift; + if (song_len >= 0x100) + return FALSE; + INIT_ARRAY(global_seen); + MODULE_INFO songs = 0; + for (pos = 0; pos < song_len && MODULE_INFO songs < MAX_SONGS; pos++) { + if (!global_seen[pos]) { + MODULE_INFO song_pos[MODULE_INFO songs] = (byte) pos; + parse_rmt_song(module_info, module, global_seen, song_len, pos_shift, pos); + } + } + /* must set fastplay after song durations calculations, so they assume 312 */ + MODULE_INFO fastplay = perframe2fastplay[per_frame - 1]; + MODULE_INFO player = 0x600; + return MODULE_INFO songs != 0; +} + +FILE_FUNC void parse_tmc_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, int pos) +{ + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int tempo = UBYTE(module[0x24]) + 1; + int frames = 0; + NEW_ARRAY(int, pattern_offset, 8); + NEW_ARRAY(int, blank_rows, 8); + while (UBYTE(module[0x1a6 + 15 + pos]) < 0x80) { + int ch; + int pattern_rows; + for (ch = 7; ch >= 0; ch--) { + int pat = UBYTE(module[0x1a6 + 15 + pos - 2 * ch]); + pattern_offset[ch] = UBYTE(module[0xa6 + pat]) + (UBYTE(module[0x126 + pat]) << 8) - addr_to_offset; + blank_rows[ch] = 0; + } + for (pattern_rows = 64; --pattern_rows >= 0; ) { + for (ch = 7; ch >= 0; ch--) { + if (--blank_rows[ch] >= 0) + continue; + for (;;) { + int i = UBYTE(module[pattern_offset[ch]++]); + if (i < 0x40) { + pattern_offset[ch]++; + break; + } + if (i == 0x40) { + i = UBYTE(module[pattern_offset[ch]++]); + if ((i & 0x7f) == 0) + pattern_rows = 0; + else + tempo = (i & 0x7f) + 1; + if (i >= 0x80) + pattern_offset[ch]++; + break; + } + if (i < 0x80) { + i = module[pattern_offset[ch]++] & 0x7f; + if (i == 0) + pattern_rows = 0; + else + tempo = i + 1; + pattern_offset[ch]++; + break; + } + if (i < 0xc0) + continue; + blank_rows[ch] = i - 0xbf; + break; + } + } + frames += tempo; + } + pos += 16; + } + if (UBYTE(module[0x1a6 + 14 + pos]) < 0x80) + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + set_song_duration(module_info, frames); +} + +FILE_FUNC abool parse_tmc(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int i; + int last_pos; + if (module_len < 0x1d0) + return FALSE; + MODULE_INFO type = 't'; + if (!load_native(ast, module_info, module, module_len, GET_OBX(tmc))) + return FALSE; + MODULE_INFO channels = 2; + i = 0; + /* find first instrument */ + while (module[0x66 + i] == 0) { + if (++i >= 64) + return FALSE; /* no instrument */ + } + last_pos = (UBYTE(module[0x66 + i]) << 8) + UBYTE(module[0x26 + i]) + - UBYTE(module[2]) - (UBYTE(module[3]) << 8) - 0x1b0; + if (0x1b5 + last_pos >= module_len) + return FALSE; + /* skip trailing jumps */ + do { + if (last_pos <= 0) + return FALSE; /* no pattern to play */ + last_pos -= 16; + } while (UBYTE(module[0x1b5 + last_pos]) >= 0x80); + MODULE_INFO songs = 0; + parse_tmc_song(module_info, module, 0); + for (i = 0; i < last_pos && MODULE_INFO songs < MAX_SONGS; i += 16) + if (UBYTE(module[0x1b5 + i]) >= 0x80) + parse_tmc_song(module_info, module, i + 16); + /* must set fastplay after song durations calculations, so they assume 312 */ + i = module[0x25]; + if (i < 1 || i > 4) + return FALSE; + if (ast != NULL) + AST tmc_per_frame = module[0x25]; + MODULE_INFO fastplay = perframe2fastplay[i - 1]; + return TRUE; +} + +FILE_FUNC void parse_tm2_song(ASAP_ModuleInfo PTR module_info, const byte ARRAY module, int pos) +{ + int addr_to_offset = UBYTE(module[2]) + (UBYTE(module[3]) << 8) - 6; + int tempo = UBYTE(module[0x24]) + 1; + int player_calls = 0; + NEW_ARRAY(int, pattern_offset, 8); + NEW_ARRAY(int, blank_rows, 8); + for (;;) { + int ch; + int pattern_rows = UBYTE(module[0x386 + 16 + pos]); + if (pattern_rows == 0) + break; + if (pattern_rows >= 0x80) { + MODULE_INFO loops[MODULE_INFO songs] = TRUE; + break; + } + for (ch = 7; ch >= 0; ch--) { + int pat = UBYTE(module[0x386 + 15 + pos - 2 * ch]); + pattern_offset[ch] = UBYTE(module[0x106 + pat]) + (UBYTE(module[0x206 + pat]) << 8) - addr_to_offset; + blank_rows[ch] = 0; + } + while (--pattern_rows >= 0) { + for (ch = 7; ch >= 0; ch--) { + if (--blank_rows[ch] >= 0) + continue; + for (;;) { + int i = UBYTE(module[pattern_offset[ch]++]); + if (i == 0) { + pattern_offset[ch]++; + break; + } + if (i < 0x40) { + if (UBYTE(module[pattern_offset[ch]++]) >= 0x80) + pattern_offset[ch]++; + break; + } + if (i < 0x80) { + pattern_offset[ch]++; + break; + } + if (i == 0x80) { + blank_rows[ch] = UBYTE(module[pattern_offset[ch]++]); + break; + } + if (i < 0xc0) + break; + if (i < 0xd0) { + tempo = i - 0xbf; + continue; + } + if (i < 0xe0) { + pattern_offset[ch]++; + break; + } + if (i < 0xf0) { + pattern_offset[ch] += 2; + break; + } + if (i < 0xff) { + blank_rows[ch] = i - 0xf0; + break; + } + blank_rows[ch] = 64; + break; + } + } + player_calls += tempo; + } + pos += 17; + } + set_song_duration(module_info, player_calls); +} + +FILE_FUNC abool parse_tm2(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int i; + int last_pos; + int c; + if (module_len < 0x3a4) + return FALSE; + MODULE_INFO type = 'T'; + if (!load_native(ast, module_info, module, module_len, GET_OBX(tm2))) + return FALSE; + i = module[0x25]; + if (i < 1 || i > 4) + return FALSE; + MODULE_INFO fastplay = perframe2fastplay[i - 1]; + MODULE_INFO player = 0x500; + if (module[0x1f] != 0) + MODULE_INFO channels = 2; + last_pos = 0xffff; + for (i = 0; i < 0x80; i++) { + int instr_addr = UBYTE(module[0x86 + i]) + (UBYTE(module[0x306 + i]) << 8); + if (instr_addr != 0 && instr_addr < last_pos) + last_pos = instr_addr; + } + for (i = 0; i < 0x100; i++) { + int pattern_addr = UBYTE(module[0x106 + i]) + (UBYTE(module[0x206 + i]) << 8); + if (pattern_addr != 0 && pattern_addr < last_pos) + last_pos = pattern_addr; + } + last_pos -= UBYTE(module[2]) + (UBYTE(module[3]) << 8) + 0x380; + if (0x386 + last_pos >= module_len) + return FALSE; + /* skip trailing stop/jump commands */ + do { + if (last_pos <= 0) + return FALSE; + last_pos -= 17; + c = UBYTE(module[0x386 + 16 + last_pos]); + } while (c == 0 || c >= 0x80); + MODULE_INFO songs = 0; + parse_tm2_song(module_info, module, 0); + for (i = 0; i < last_pos && MODULE_INFO songs < MAX_SONGS; i += 17) { + c = UBYTE(module[0x386 + 16 + i]); + if (c == 0 || c >= 0x80) + parse_tm2_song(module_info, module, i + 17); + } + return TRUE; +} + +#if !defined(JAVA) && !defined(CSHARP) + +static abool parse_hex(int *retval, const char *p) +{ + int r = 0; + do { + char c = *p; + if (r > 0xfff) + return FALSE; + r <<= 4; + if (c >= '0' && c <= '9') + r += c - '0'; + else if (c >= 'A' && c <= 'F') + r += c - 'A' + 10; + else if (c >= 'a' && c <= 'f') + r += c - 'a' + 10; + else + return FALSE; + } while (*++p != '\0'); + *retval = r; + return TRUE; +} + +static abool parse_dec(int *retval, const char *p, int minval, int maxval) +{ + int r = 0; + do { + char c = *p; + if (c >= '0' && c <= '9') + r = 10 * r + c - '0'; + else + return FALSE; + if (r > maxval) + return FALSE; + } while (*++p != '\0'); + if (r < minval) + return FALSE; + *retval = r; + return TRUE; +} + +static abool parse_text(char *retval, const char *p) +{ + int i; + if (*p != '"') + return FALSE; + p++; + if (p[0] == '<' && p[1] == '?' && p[2] == '>' && p[3] == '"') + return TRUE; + i = 0; + while (*p != '"') { + if (i >= 127) + return FALSE; + if (*p == '\0') + return FALSE; + retval[i++] = *p++; + } + retval[i] = '\0'; + return TRUE; +} + +int ASAP_ParseDuration(const char *s) +{ + int r; + if (*s < '0' || *s > '9') + return -1; + r = *s++ - '0'; + if (*s >= '0' && *s <= '9') + r = 10 * r + *s++ - '0'; + if (*s == ':') { + s++; + if (*s < '0' || *s > '5') + return -1; + r = 60 * r + (*s++ - '0') * 10; + if (*s < '0' || *s > '9') + return -1; + r += *s++ - '0'; + } + r *= 1000; + if (*s != '.') + return r; + s++; + if (*s < '0' || *s > '9') + return r; + r += 100 * (*s++ - '0'); + if (*s < '0' || *s > '9') + return r; + r += 10 * (*s++ - '0'); + if (*s < '0' || *s > '9') + return r; + r += *s - '0'; + return r; +} + +static char *two_digits(char *s, int x) +{ + s[0] = '0' + x / 10; + s[1] = '0' + x % 10; + return s + 2; +} + +void ASAP_DurationToString(char *s, int duration) +{ + if (duration >= 0) { + int seconds = duration / 1000; + int minutes = seconds / 60; + s = two_digits(s, minutes); + *s++ = ':'; + s = two_digits(s, seconds % 60); + duration %= 1000; + if (duration != 0) { + *s++ = '.'; + s = two_digits(s, duration / 10); + duration %= 10; + if (duration != 0) + *s++ = '0' + duration; + } + } + *s = '\0'; +} + +#endif /* !defined(JAVA) && !defined(CSHARP) */ + +FILE_FUNC abool parse_sap_header(ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int module_index = 0; + abool sap_signature = FALSE; + int duration_index = 0; + for (;;) { + NEW_ARRAY(char, line, 256); + int i; +#if !defined(JAVA) && !defined(CSHARP) + char *p; +#endif + if (module_index + 8 >= module_len) + return FALSE; + if (UBYTE(module[module_index]) == 0xff) + break; + i = 0; + while (module[module_index] != 0x0d) { + line[i++] = (char) module[module_index++]; + if (module_index >= module_len || i >= sizeof(line) - 1) + return FALSE; + } + if (++module_index >= module_len || module[module_index++] != 0x0a) + return FALSE; + +#ifdef JAVA + String tag = new String(line, 0, i); + String arg = null; + i = tag.indexOf(' '); + if (i >= 0) { + arg = tag.substring(i + 1); + tag = tag.substring(0, i); + } +#define TAG_IS(t) tag.equals(t) +#define CHAR_ARG arg.charAt(0) +#define SET_HEX(v) v = Integer.parseInt(arg, 16) +#define SET_DEC(v, min, max) do { v = Integer.parseInt(arg); if (v < min || v > max) return FALSE; } while (FALSE) +#define SET_TEXT(v) v = arg.substring(1, arg.length() - 1) +#define DURATION_ARG parseDuration(arg) +#define ARG_CONTAINS(t) (arg.indexOf(t) >= 0) +#elif defined(CSHARP) + string tag = new string(line, 0, i); + string arg = null; + i = tag.IndexOf(' '); + if (i >= 0) { + arg = tag.Substring(i + 1); + tag = tag.Substring(0, i); + } +#define TAG_IS(t) tag == t +#define CHAR_ARG arg[0] +#define SET_HEX(v) v = int.Parse(arg, System.Globalization.NumberStyles.HexNumber) +#define SET_DEC(v, min, max) do { v = int.Parse(arg); if (v < min || v > max) return FALSE; } while (FALSE) +#define SET_TEXT(v) v = arg.Substring(1, arg.Length - 1) +#define DURATION_ARG ParseDuration(arg) +#define ARG_CONTAINS(t) (arg.IndexOf(t) >= 0) +#else + line[i] = '\0'; + for (p = line; *p != '\0'; p++) { + if (*p == ' ') { + *p++ = '\0'; + break; + } + } +#define TAG_IS(t) (strcmp(line, t) == 0) +#define CHAR_ARG *p +#define SET_HEX(v) do { if (!parse_hex(&v, p)) return FALSE; } while (FALSE) +#define SET_DEC(v, min, max) do { if (!parse_dec(&v, p, min, max)) return FALSE; } while (FALSE) +#define SET_TEXT(v) do { if (!parse_text(v, p)) return FALSE; } while (FALSE) +#define DURATION_ARG ASAP_ParseDuration(p) +#define ARG_CONTAINS(t) (strstr(p, t) != NULL) +#endif + + if (TAG_IS("SAP")) + sap_signature = TRUE; + if (!sap_signature) + return FALSE; + if (TAG_IS("AUTHOR")) + SET_TEXT(MODULE_INFO author); + else if (TAG_IS("NAME")) + SET_TEXT(MODULE_INFO name); + else if (TAG_IS("DATE")) + SET_TEXT(MODULE_INFO date); + else if (TAG_IS("SONGS")) + SET_DEC(MODULE_INFO songs, 1, MAX_SONGS); + else if (TAG_IS("DEFSONG")) + SET_DEC(MODULE_INFO default_song, 0, MAX_SONGS - 1); + else if (TAG_IS("STEREO")) + MODULE_INFO channels = 2; + else if (TAG_IS("TIME")) { + int duration = DURATION_ARG; + if (duration < 0 || duration_index >= MAX_SONGS) + return FALSE; + MODULE_INFO durations[duration_index] = duration; + if (ARG_CONTAINS("LOOP")) + MODULE_INFO loops[duration_index] = TRUE; + duration_index++; + } + else if (TAG_IS("TYPE")) + MODULE_INFO type = CHAR_ARG; + else if (TAG_IS("FASTPLAY")) + SET_DEC(MODULE_INFO fastplay, 1, 312); + else if (TAG_IS("MUSIC")) + SET_HEX(MODULE_INFO music); + else if (TAG_IS("INIT")) + SET_HEX(MODULE_INFO init); + else if (TAG_IS("PLAYER")) + SET_HEX(MODULE_INFO player); + } + if (MODULE_INFO default_song >= MODULE_INFO songs) + return FALSE; + switch (MODULE_INFO type) { + case 'B': + case 'D': + if (MODULE_INFO player < 0 || MODULE_INFO init < 0) + return FALSE; + break; + case 'C': + if (MODULE_INFO player < 0 || MODULE_INFO music < 0) + return FALSE; + break; + case 'S': + if (MODULE_INFO init < 0) + return FALSE; + MODULE_INFO fastplay = 78; + break; + default: + return FALSE; + } + if (UBYTE(module[module_index + 1]) != 0xff) + return FALSE; + MODULE_INFO header_len = module_index; + return TRUE; +} + +FILE_FUNC abool parse_sap(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + const byte ARRAY module, int module_len) +{ + int module_index; + if (!parse_sap_header(module_info, module, module_len)) + return FALSE; + if (ast == NULL) + return TRUE; + ZERO_ARRAY(AST memory); + module_index = MODULE_INFO header_len + 2; + while (module_index + 5 <= module_len) { + int start_addr = UBYTE(module[module_index]) + (UBYTE(module[module_index + 1]) << 8); + int block_len = UBYTE(module[module_index + 2]) + (UBYTE(module[module_index + 3]) << 8) + 1 - start_addr; + if (block_len <= 0 || module_index + block_len > module_len) + return FALSE; + module_index += 4; + COPY_ARRAY(AST memory, start_addr, module, module_index, block_len); + module_index += block_len; + if (module_index == module_len) + return TRUE; + if (module_index + 7 <= module_len + && UBYTE(module[module_index]) == 0xff && UBYTE(module[module_index + 1]) == 0xff) + module_index += 2; + } + return FALSE; +} + +#define ASAP_EXT(c1, c2, c3) (((c1) + ((c2) << 8) + ((c3) << 16)) | 0x202020) + +FILE_FUNC int get_packed_ext(STRING filename) +{ +#ifdef JAVA + int i = filename.length(); + int ext = 0; + while (--i > 0) { + if (filename.charAt(i) == '.') + return ext | 0x202020; + ext = (ext << 8) + filename.charAt(i); + } + return 0; +#elif defined(CSHARP) + int i = filename.Length; + int ext = 0; + while (--i > 0) { + if (filename[i] == '.') + return ext | 0x202020; + ext = (ext << 8) + filename[i]; + } + return 0; +#else + const char *p; + int ext; + for (p = filename; *p != '\0'; p++); + ext = 0; + for (;;) { + if (--p <= filename || *p <= ' ') + return 0; /* no filename extension or invalid character */ + if (*p == '.') + return ext | 0x202020; + ext = (ext << 8) + (*p & 0xff); + } +#endif +} + +FILE_FUNC abool is_our_ext(int ext) +{ + switch (ext) { + case ASAP_EXT('C', 'M', 'C'): + case ASAP_EXT('C', 'M', 'R'): + case ASAP_EXT('D', 'M', 'C'): + case ASAP_EXT('M', 'P', 'D'): + case ASAP_EXT('M', 'P', 'T'): + case ASAP_EXT('R', 'M', 'T'): + case ASAP_EXT('S', 'A', 'P'): + case ASAP_EXT('T', 'M', '2'): + case ASAP_EXT('T', 'M', '8'): + case ASAP_EXT('T', 'M', 'C'): + return TRUE; + default: + return FALSE; + } +} + +ASAP_FUNC abool ASAP_IsOurFile(STRING filename) +{ + int ext = get_packed_ext(filename); + return is_our_ext(ext); +} + +ASAP_FUNC abool ASAP_IsOurExt(STRING ext) +{ +#ifdef JAVA + return ext.length() == 3 + && is_our_ext(ASAP_EXT(ext.charAt(0), ext.charAt(1), ext.charAt(2))); +#else + return ext[0] > ' ' && ext[1] > ' ' && ext[2] > ' ' && ext[3] == '\0' + && is_our_ext(ASAP_EXT(ext[0], ext[1], ext[2])); +#endif +} + +FILE_FUNC abool parse_file(ASAP_State PTR ast, ASAP_ModuleInfo PTR module_info, + STRING filename, const byte ARRAY module, int module_len) +{ + int i; +#ifdef JAVA + int basename = 0; + int ext = -1; + for (i = 0; i < filename.length(); i++) { + int c = filename.charAt(i); + if (c == '/' || c == '\\') + basename = i + 1; + else if (c == '.') + ext = i; + } + if (ext < 0) + ext = i; + module_info.author = ""; + module_info.name = filename.substring(basename, ext); + module_info.date = ""; +#elif defined(CSHARP) + int basename = 0; + int ext = -1; + for (i = 0; i < filename.Length; i++) { + int c = filename[i]; + if (c == '/' || c == '\\') + basename = i + 1; + else if (c == '.') + ext = i; + } + if (ext < 0) + ext = i; + module_info.author = string.Empty; + module_info.name = filename.Substring(basename, ext - basename); + module_info.date = string.Empty; +#else + const char *p; + const char *basename = filename; + const char *ext = NULL; + for (p = filename; *p != '\0'; p++) { + if (*p == '/' || *p == '\\') + basename = p + 1; + else if (*p == '.') + ext = p; + } + if (ext == NULL) + ext = p; + module_info->author[0] = '\0'; + i = ext - basename; + memcpy(module_info->name, basename, i); + module_info->name[i] = '\0'; + module_info->date[0] = '\0'; +#endif + MODULE_INFO channels = 1; + MODULE_INFO songs = 1; + MODULE_INFO default_song = 0; + for (i = 0; i < MAX_SONGS; i++) { + MODULE_INFO durations[i] = -1; + MODULE_INFO loops[i] = FALSE; + } + MODULE_INFO type = '?'; + MODULE_INFO fastplay = 312; + MODULE_INFO music = -1; + MODULE_INFO init = -1; + MODULE_INFO player = -1; + switch (get_packed_ext(filename)) { + case ASAP_EXT('C', 'M', 'C'): + return parse_cmc(ast, module_info, module, module_len, FALSE); + case ASAP_EXT('C', 'M', 'R'): + return parse_cmc(ast, module_info, module, module_len, TRUE); + case ASAP_EXT('D', 'M', 'C'): + MODULE_INFO fastplay = 156; + return parse_cmc(ast, module_info, module, module_len, FALSE); + case ASAP_EXT('M', 'P', 'D'): + MODULE_INFO fastplay = 156; + return parse_mpt(ast, module_info, module, module_len); + case ASAP_EXT('M', 'P', 'T'): + return parse_mpt(ast, module_info, module, module_len); + case ASAP_EXT('R', 'M', 'T'): + return parse_rmt(ast, module_info, module, module_len); + case ASAP_EXT('S', 'A', 'P'): + return parse_sap(ast, module_info, module, module_len); + case ASAP_EXT('T', 'M', '2'): + return parse_tm2(ast, module_info, module, module_len); + case ASAP_EXT('T', 'M', '8'): + case ASAP_EXT('T', 'M', 'C'): + return parse_tmc(ast, module_info, module, module_len); + default: + return FALSE; + } +} + +ASAP_FUNC abool ASAP_GetModuleInfo(ASAP_ModuleInfo PTR module_info, STRING filename, + const byte ARRAY module, int module_len) +{ + return parse_file(NULL, module_info, filename, module, module_len); +} + +ASAP_FUNC abool ASAP_Load(ASAP_State PTR ast, STRING filename, + const byte ARRAY module, int module_len) +{ + AST silence_cycles = 0; + return parse_file(ast, ADDRESSOF AST module_info, filename, module, module_len); +} + +ASAP_FUNC void ASAP_DetectSilence(ASAP_State PTR ast, int seconds) +{ + AST silence_cycles = seconds * ASAP_MAIN_CLOCK; +} + +FILE_FUNC void call_6502(ASAP_State PTR ast, int addr, int max_scanlines) +{ + AST cpu_pc = addr; + /* put a CIM at 0xd20a and a return address on stack */ + dPutByte(0xd20a, 0xd2); + dPutByte(0x01fe, 0x09); + dPutByte(0x01ff, 0xd2); + AST cpu_s = 0xfd; + Cpu_RunScanlines(ast, max_scanlines); +} + +/* 50 Atari frames for the initialization routine - some SAPs are self-extracting. */ +#define SCANLINES_FOR_INIT (50 * 312) + +FILE_FUNC void call_6502_init(ASAP_State PTR ast, int addr, int a, int x, int y) +{ + AST cpu_a = a & 0xff; + AST cpu_x = x & 0xff; + AST cpu_y = y & 0xff; + call_6502(ast, addr, SCANLINES_FOR_INIT); +} + +ASAP_FUNC void ASAP_PlaySong(ASAP_State PTR ast, int song, int duration) +{ + AST current_song = song; + AST current_duration = duration; + AST blocks_played = 0; + AST silence_cycles_counter = AST silence_cycles; + AST extra_pokey_mask = AST module_info.channels > 1 ? 0x10 : 0; + PokeySound_Initialize(ast); + AST cycle = 0; + AST cpu_nz = 0; + AST cpu_c = 0; + AST cpu_vdi = 0; + AST scanline_number = 0; + AST next_scanline_cycle = 0; + AST timer1_cycle = NEVER; + AST timer2_cycle = NEVER; + AST timer4_cycle = NEVER; + AST irqst = 0xff; + switch (AST module_info.type) { + case 'B': + call_6502_init(ast, AST module_info.init, song, 0, 0); + break; + case 'C': + case 'c': + case 'z': + call_6502_init(ast, AST module_info.player + 3, 0x70, AST module_info.music, AST module_info.music >> 8); + call_6502_init(ast, AST module_info.player + 3, 0x00, song, 0); + break; + case 'D': + case 'S': + AST cpu_a = song; + AST cpu_x = 0x00; + AST cpu_y = 0x00; + AST cpu_s = 0xff; + AST cpu_pc = AST module_info.init; + break; + case 'm': + call_6502_init(ast, AST module_info.player, 0x00, AST module_info.music >> 8, AST module_info.music); + call_6502_init(ast, AST module_info.player, 0x02, AST module_info.song_pos[song], 0); + break; + case 'r': + call_6502_init(ast, AST module_info.player, AST module_info.song_pos[song], AST module_info.music, AST module_info.music >> 8); + break; + case 't': + case 'T': + call_6502_init(ast, AST module_info.player, 0x70, AST module_info.music >> 8, AST module_info.music); + call_6502_init(ast, AST module_info.player, 0x00, song, 0); + AST tmc_per_frame_counter = 1; + break; + } + ASAP_MutePokeyChannels(ast, 0); +} + +ASAP_FUNC void ASAP_MutePokeyChannels(ASAP_State PTR ast, int mask) +{ + PokeySound_Mute(ast, ADDRESSOF AST base_pokey, mask); + PokeySound_Mute(ast, ADDRESSOF AST extra_pokey, mask >> 4); +} + +ASAP_FUNC abool call_6502_player(ASAP_State PTR ast) +{ + int s; + PokeySound_StartFrame(ast); + switch (AST module_info.type) { + case 'B': + call_6502(ast, AST module_info.player, AST module_info.fastplay); + break; + case 'C': + case 'c': + case 'z': + call_6502(ast, AST module_info.player + 6, AST module_info.fastplay); + break; + case 'D': + s = AST cpu_s; +#define PUSH_ON_6502_STACK(x) dPutByte(0x100 + s, x); s = (s - 1) & 0xff +#define RETURN_FROM_PLAYER_ADDR 0xd200 + /* save 6502 state on 6502 stack */ + PUSH_ON_6502_STACK(AST cpu_pc >> 8); + PUSH_ON_6502_STACK(AST cpu_pc & 0xff); + PUSH_ON_6502_STACK(((AST cpu_nz | (AST cpu_nz >> 1)) & 0x80) + AST cpu_vdi + \ + ((AST cpu_nz & 0xff) == 0 ? Z_FLAG : 0) + AST cpu_c + 0x20); + PUSH_ON_6502_STACK(AST cpu_a); + PUSH_ON_6502_STACK(AST cpu_x); + PUSH_ON_6502_STACK(AST cpu_y); + /* RTS will jump to 6502 code that restores the state */ + PUSH_ON_6502_STACK((RETURN_FROM_PLAYER_ADDR - 1) >> 8); + PUSH_ON_6502_STACK((RETURN_FROM_PLAYER_ADDR - 1) & 0xff); + AST cpu_s = s; + dPutByte(RETURN_FROM_PLAYER_ADDR, 0x68); /* PLA */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 1, 0xa8); /* TAY */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 2, 0x68); /* PLA */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 3, 0xaa); /* TAX */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 4, 0x68); /* PLA */ + dPutByte(RETURN_FROM_PLAYER_ADDR + 5, 0x40); /* RTI */ + AST cpu_pc = AST module_info.player; + Cpu_RunScanlines(ast, AST module_info.fastplay); + break; + case 'S': + Cpu_RunScanlines(ast, AST module_info.fastplay); + { + int i = dGetByte(0x45) - 1; + dPutByte(0x45, i); + if (i == 0) + dPutByte(0xb07b, dGetByte(0xb07b) + 1); + } + break; + case 'm': + case 'r': + case 'T': + call_6502(ast, AST module_info.player + 3, AST module_info.fastplay); + break; + case 't': + if (--AST tmc_per_frame_counter <= 0) { + AST tmc_per_frame_counter = AST tmc_per_frame; + call_6502(ast, AST module_info.player + 3, AST module_info.fastplay); + } + else + call_6502(ast, AST module_info.player + 6, AST module_info.fastplay); + break; + } + PokeySound_EndFrame(ast, AST module_info.fastplay * 114); + if (AST silence_cycles > 0) { + if (PokeySound_IsSilent(ADDRESSOF AST base_pokey) + && PokeySound_IsSilent(ADDRESSOF AST extra_pokey)) { + AST silence_cycles_counter -= AST module_info.fastplay * 114; + if (AST silence_cycles_counter <= 0) + return FALSE; + } + else + AST silence_cycles_counter = AST silence_cycles; + } + return TRUE; +} + +FILE_FUNC int milliseconds_to_blocks(int milliseconds) +{ + return milliseconds * (ASAP_SAMPLE_RATE / 100) / 10; +} + +ASAP_FUNC void ASAP_Seek(ASAP_State PTR ast, int position) +{ + int block = milliseconds_to_blocks(position); + if (block < AST blocks_played) + ASAP_PlaySong(ast, AST current_song, AST current_duration); + while (AST blocks_played + AST samples - AST sample_index < block) { + AST blocks_played += AST samples - AST sample_index; + call_6502_player(ast); + } + AST sample_index += block - AST blocks_played; + AST blocks_played = block; +} + +ASAP_FUNC int ASAP_Generate(ASAP_State PTR ast, VOIDPTR buffer, int buffer_len, + ASAP_SampleFormat format) +{ + int block_shift; + int buffer_blocks; + int block; + if (AST silence_cycles > 0 && AST silence_cycles_counter <= 0) + return 0; + block_shift = (AST module_info.channels - 1) + (format != ASAP_FORMAT_U8 ? 1 : 0); + buffer_blocks = buffer_len >> block_shift; + if (AST current_duration > 0) { + int total_blocks = milliseconds_to_blocks(AST current_duration); + if (buffer_blocks > total_blocks - AST blocks_played) + buffer_blocks = total_blocks - AST blocks_played; + } + block = 0; + do { + int blocks = PokeySound_Generate(ast, buffer, block << block_shift, buffer_blocks - block, format); + AST blocks_played += blocks; + block += blocks; + } while (block < buffer_blocks && call_6502_player(ast)); + return block << block_shift; +} + +#if !defined(JAVA) && !defined(CSHARP) + +abool ASAP_ChangeExt(char *filename, const char *ext) +{ + char *dest = NULL; + while (*filename != '\0') { + if (*filename == '/' || *filename == '\\') + dest = NULL; + else if (*filename == '.') + dest = filename + 1; + filename++; + } + if (dest == NULL) + return FALSE; + strcpy(dest, ext); + return TRUE; +} + +abool ASAP_CanSetModuleInfo(const char *filename) +{ + int ext = get_packed_ext(filename); + return ext == ASAP_EXT('S', 'A', 'P'); +} + +static byte *put_string(byte *dest, const char *str) +{ + while (*str != '\0') + *dest++ = *str++; + return dest; +} + +static byte *put_dec(byte *dest, int value) +{ + if (value >= 10) { + dest = put_dec(dest, value / 10); + value %= 10; + } + *dest++ = '0' + value; + return dest; +} + +static byte *put_text_tag(byte *dest, const char *tag, const char *value) +{ + dest = put_string(dest, tag); + *dest++ = ' '; + *dest++ = '"'; + if (*value == '\0') + value = ""; + while (*value != '\0') { + if (*value < ' ' || *value > 'z' || *value == '"' || *value == '`') + return NULL; + *dest++ = *value++; + } + *dest++ = '"'; + *dest++ = '\r'; + *dest++ = '\n'; + return dest; +} + +static byte *put_hex_tag(byte *dest, const char *tag, int value) +{ + int i; + if (value < 0) + return dest; + dest = put_string(dest, tag); + *dest++ = ' '; + for (i = 12; i >= 0; i -= 4) { + int digit = (value >> i) & 0xf; + *dest++ = (byte) (digit + (digit < 10 ? '0' : 'A' - 10)); + } + *dest++ = '\r'; + *dest++ = '\n'; + return dest; +} + +static byte *put_dec_tag(byte *dest, const char *tag, int value) +{ + dest = put_string(dest, tag); + *dest++ = ' '; + dest = put_dec(dest, value); + *dest++ = '\r'; + *dest++ = '\n'; + return dest; +} + +static byte *start_sap_header(byte *dest, const ASAP_ModuleInfo *module_info) +{ + dest = put_string(dest, "SAP\r\n"); + dest = put_text_tag(dest, "AUTHOR", module_info->author); + if (dest == NULL) + return NULL; + dest = put_text_tag(dest, "NAME", module_info->name); + if (dest == NULL) + return NULL; + dest = put_text_tag(dest, "DATE", module_info->date); + if (dest == NULL) + return NULL; + if (module_info->songs > 1) { + dest = put_dec_tag(dest, "SONGS", module_info->songs); + if (module_info->default_song > 0) + dest = put_dec_tag(dest, "DEFSONG", module_info->default_song); + } + if (module_info->channels > 1) + dest = put_string(dest, "STEREO\r\n"); + return dest; +} + +static byte *put_durations(byte *dest, const ASAP_ModuleInfo *module_info) +{ + int song; + for (song = 0; song < module_info->songs; song++) { + if (module_info->durations[song] < 0) + break; + dest = put_string(dest, "TIME "); + ASAP_DurationToString((char *) dest, module_info->durations[song]); + while (*dest != '\0') + dest++; + if (module_info->loops[song]) + dest = put_string(dest, " LOOP"); + *dest++ = '\r'; + *dest++ = '\n'; + } + return dest; +} + +static byte *put_sap_header(byte *dest, const ASAP_ModuleInfo *module_info, char type, int music, int init, int player) +{ + dest = start_sap_header(dest, module_info); + if (dest == NULL) + return NULL; + dest = put_string(dest, "TYPE "); + *dest++ = type; + *dest++ = '\r'; + *dest++ = '\n'; + if (module_info->fastplay != 312) + dest = put_dec_tag(dest, "FASTPLAY", module_info->fastplay); + dest = put_hex_tag(dest, "MUSIC", music); + dest = put_hex_tag(dest, "INIT", init); + dest = put_hex_tag(dest, "PLAYER", player); + dest = put_durations(dest, module_info); + return dest; +} + +int ASAP_SetModuleInfo(const ASAP_ModuleInfo *module_info, const byte ARRAY module, + int module_len, byte ARRAY out_module) +{ + byte *dest; + int i; + if (memcmp(module, "SAP\r\n", 5) != 0) + return -1; + dest = start_sap_header(out_module, module_info); + if (dest == NULL) + return -1; + i = 5; + while (i < module_len && module[i] != 0xff) { + if (memcmp(module + i, "AUTHOR ", 7) == 0 + || memcmp(module + i, "NAME ", 5) == 0 + || memcmp(module + i, "DATE ", 5) == 0 + || memcmp(module + i, "SONGS ", 6) == 0 + || memcmp(module + i, "DEFSONG ", 8) == 0 + || memcmp(module + i, "STEREO", 6) == 0 + || memcmp(module + i, "TIME ", 5) == 0) { + while (i < module_len && module[i++] != 0x0a); + } + else { + int b; + do { + b = module[i++]; + *dest++ = b; + } while (i < module_len && b != 0x0a); + } + } + dest = put_durations(dest, module_info); + module_len -= i; + memcpy(dest, module + i, module_len); + dest += module_len; + return dest - out_module; +} + +#define RMT_INIT 0x0c80 +#define TM2_INIT 0x1080 + +const char *ASAP_CanConvert(const char *filename, const ASAP_ModuleInfo *module_info, + const byte ARRAY module, int module_len) +{ + switch (module_info->type) { + case 'B': + if (module_info->init == 0x4f3 || module_info->init == 0xf4f3 || module_info->init == 0x4ef) + return module_info->fastplay == 156 ? "mpd" : "mpt"; + if (module_info->init == RMT_INIT) + return "rmt"; + if ((module_info->init == 0x4f5 || module_info->init == 0xf4f5 || module_info->init == 0x4f2) + || ((module_info->init == 0x4e7 || module_info->init == 0xf4e7 || module_info->init == 0x4e4) && module_info->fastplay == 156) + || ((module_info->init == 0x4e5 || module_info->init == 0xf4e5 || module_info->init == 0x4e2) && (module_info->fastplay == 104 || module_info->fastplay == 78))) + return "tmc"; + if (module_info->init == TM2_INIT) + return "tm2"; + break; + case 'C': + if (module_info->player == 0x500 || module_info->player == 0xf500) { + if (module_info->fastplay == 156) + return "dmc"; + return module[module_len - 170] == 0x1e ? "cmr" : "cmc"; + } + break; + case 'c': + case 'z': + case 'm': + case 'r': + case 't': + case 'T': + return "sap"; + default: + break; + } + return NULL; +} + +int ASAP_Convert(const char *filename, const ASAP_ModuleInfo *module_info, + const byte ARRAY module, int module_len, byte ARRAY out_module) +{ + int out_len; + byte *dest; + int addr; + int player; + static const int tmc_player[4] = { 3, -9, -10, -10 }; + static const int tmc_init[4] = { -14, -16, -17, -17 }; + switch (module_info->type) { + case 'B': + case 'C': + out_len = module[module_info->header_len + 4] + (module[module_info->header_len + 5] << 8) + - module[module_info->header_len + 2] - (module[module_info->header_len + 3] << 8) + 7; + if (out_len < 7 || module_info->header_len + out_len >= module_len) + return -1; + memcpy(out_module, module + module_info->header_len, out_len); + return out_len; + case 'c': + case 'z': + dest = put_sap_header(out_module, module_info, 'C', module_info->music, -1, module_info->player); + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + memcpy(dest, cmc_obx + 2, sizeof(cmc_obx) - 2); + if (module_info->type == 'z') + memcpy(dest + 4 + CMR_BASS_TABLE_OFFSET, cmr_bass_table, sizeof(cmr_bass_table)); + dest += sizeof(cmc_obx) - 2; + return dest - out_module; + case 'm': + if (module_info->songs != 1) { + addr = module_info->player - 17 - module_info->songs; + dest = put_sap_header(out_module, module_info, 'B', -1, module_info->player - 17, module_info->player + 3); + } + else { + addr = module_info->player - 13; + dest = put_sap_header(out_module, module_info, 'B', -1, addr, module_info->player + 3); + } + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + *dest++ = (byte) addr; + *dest++ = (byte) (addr >> 8); + *dest++ = mpt_obx[4]; + *dest++ = mpt_obx[5]; + if (module_info->songs != 1) { + memcpy(dest, module_info->song_pos, module_info->songs); + dest += module_info->songs; + *dest++ = 0x48; /* pha */ + } + *dest++ = 0xa0; /* ldy #music; + *dest++ = 0xa2; /* ldx #>music */ + *dest++ = (byte) (module_info->music >> 8); + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + *dest++ = 0x20; /* jsr player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + if (module_info->songs != 1) { + *dest++ = 0x68; /* pla */ + *dest++ = 0xa8; /* tay */ + *dest++ = 0xbe; /* ldx song2pos,y */ + *dest++ = (byte) addr; + *dest++ = (byte) (addr >> 8); + } + else { + *dest++ = 0xa2; /* ldx #0 */ + *dest++ = 0; + } + *dest++ = 0xa9; /* lda #2 */ + *dest++ = 2; + memcpy(dest, mpt_obx + 6, sizeof(mpt_obx) - 6); + dest += sizeof(mpt_obx) - 6; + return dest - out_module; + case 'r': + dest = put_sap_header(out_module, module_info, 'B', -1, RMT_INIT, module_info->player + 3); + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + *dest++ = (byte) RMT_INIT; + *dest++ = (byte) (RMT_INIT >> 8); + if (module_info->songs != 1) { + addr = RMT_INIT + 10 + module_info->songs; + *dest++ = (byte) addr; + *dest++ = (byte) (addr >> 8); + *dest++ = 0xa8; /* tay */ + *dest++ = 0xb9; /* lda song2pos,y */ + *dest++ = (byte) (RMT_INIT + 11); + *dest++ = (byte) ((RMT_INIT + 11) >> 8); + } + else { + *dest++ = (byte) (RMT_INIT + 8); + *dest++ = (byte) ((RMT_INIT + 8) >> 8); + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + } + *dest++ = 0xa2; /* ldx #music; + *dest++ = 0xa0; /* ldy #>music */ + *dest++ = (byte) (module_info->music >> 8); + *dest++ = 0x4c; /* jmp player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + if (module_info->songs != 1) { + memcpy(dest, module_info->song_pos, module_info->songs); + dest += module_info->songs; + } + if (module_info->channels == 1) { + memcpy(dest, rmt4_obx + 2, sizeof(rmt4_obx) - 2); + dest += sizeof(rmt4_obx) - 2; + } + else { + memcpy(dest, rmt8_obx + 2, sizeof(rmt8_obx) - 2); + dest += sizeof(rmt8_obx) - 2; + } + return dest - out_module; + case 't': + player = module_info->player + tmc_player[module[0x25] - 1]; + addr = player + tmc_init[module[0x25] - 1]; + if (module_info->songs != 1) + addr -= 3; + dest = put_sap_header(out_module, module_info, 'B', -1, addr, player); + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + *dest++ = (byte) addr; + *dest++ = (byte) (addr >> 8); + *dest++ = tmc_obx[4]; + *dest++ = tmc_obx[5]; + if (module_info->songs != 1) + *dest++ = 0x48; /* pha */ + *dest++ = 0xa0; /* ldy #music; + *dest++ = 0xa2; /* ldx #>music */ + *dest++ = (byte) (module_info->music >> 8); + *dest++ = 0xa9; /* lda #$70 */ + *dest++ = 0x70; + *dest++ = 0x20; /* jsr player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + if (module_info->songs != 1) { + *dest++ = 0x68; /* pla */ + *dest++ = 0xaa; /* tax */ + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + } + else { + *dest++ = 0xa9; /* lda #$60 */ + *dest++ = 0x60; + } + switch (module[0x25]) { + case 2: + *dest++ = 0x06; /* asl 0 */ + *dest++ = 0; + *dest++ = 0x4c; /* jmp player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + *dest++ = 0xa5; /* lda 0 */ + *dest++ = 0; + *dest++ = 0xe6; /* inc 0 */ + *dest++ = 0; + *dest++ = 0x4a; /* lsr @ */ + *dest++ = 0x90; /* bcc player+3 */ + *dest++ = 5; + *dest++ = 0xb0; /* bcs player+6 */ + *dest++ = 6; + break; + case 3: + case 4: + *dest++ = 0xa0; /* ldy #1 */ + *dest++ = 1; + *dest++ = 0x84; /* sty 0 */ + *dest++ = 0; + *dest++ = 0xd0; /* bne player */ + *dest++ = 10; + *dest++ = 0xc6; /* dec 0 */ + *dest++ = 0; + *dest++ = 0xd0; /* bne player+6 */ + *dest++ = 12; + *dest++ = 0xa0; /* ldy #3 */ + *dest++ = module[0x25]; + *dest++ = 0x84; /* sty 0 */ + *dest++ = 0; + *dest++ = 0xd0; /* bne player+3 */ + *dest++ = 3; + break; + default: + break; + } + memcpy(dest, tmc_obx + 6, sizeof(tmc_obx) - 6); + dest += sizeof(tmc_obx) - 6; + return dest - out_module; + case 'T': + dest = put_sap_header(out_module, module_info, 'B', -1, TM2_INIT, module_info->player + 3); + if (dest == NULL) + return -1; + memcpy(dest, module, module_len); + dest += module_len; + *dest++ = (byte) TM2_INIT; + *dest++ = (byte) (TM2_INIT >> 8); + if (module_info->songs != 1) { + *dest++ = (byte) (TM2_INIT + 16); + *dest++ = (byte) ((TM2_INIT + 16) >> 8); + *dest++ = 0x48; /* pha */ + } + else { + *dest++ = (byte) (TM2_INIT + 14); + *dest++ = (byte) ((TM2_INIT + 14) >> 8); + } + *dest++ = 0xa0; /* ldy #music; + *dest++ = 0xa2; /* ldx #>music */ + *dest++ = (byte) (module_info->music >> 8); + *dest++ = 0xa9; /* lda #$70 */ + *dest++ = 0x70; + *dest++ = 0x20; /* jsr player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + if (module_info->songs != 1) { + *dest++ = 0x68; /* pla */ + *dest++ = 0xaa; /* tax */ + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + } + else { + *dest++ = 0xa9; /* lda #0 */ + *dest++ = 0; + *dest++ = 0xaa; /* tax */ + } + *dest++ = 0x4c; /* jmp player */ + *dest++ = (byte) module_info->player; + *dest++ = (byte) (module_info->player >> 8); + memcpy(dest, tm2_obx + 2, sizeof(tm2_obx) - 2); + dest += sizeof(tm2_obx) - 2; + return dest - out_module; + default: + return -1; + } +} + +#endif /* !defined(JAVA) && !defined(CSHARP) */ Index: apps/plugins/asap/asap.h =================================================================== --- apps/plugins/asap/asap.h (revision 0) +++ apps/plugins/asap/asap.h (revision 0) @@ -0,0 +1,299 @@ +/* + * asap.h - public interface of the ASAP engine + * + * Copyright (C) 2005-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef _ASAP_H_ +#define _ASAP_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ASAP version. */ +#define ASAP_VERSION_MAJOR 1 +#define ASAP_VERSION_MINOR 2 +#define ASAP_VERSION_MICRO 0 +#define ASAP_VERSION "1.2.0" + +/* Short credits of the ASAP engine. */ +#define ASAP_YEARS "2005-2008" +#define ASAP_CREDITS \ + "Another Slight Atari Player (C) 2005-2008 Piotr Fusik\n" \ + "CMC, MPT, TMC players (C) 1994-2005 Marcin Lewandowski\n" \ + "RMT player (C) 2002-2005 Radek Sterba\n" + +/* Short GPL notice. + Display after the credits. */ +#define ASAP_COPYRIGHT \ + "This program is free software; you can redistribute it and/or modify\n" \ + "it under the terms of the GNU General Public License as published\n" \ + "by the Free Software Foundation; either version 2 of the License,\n" \ + "or (at your option) any later version." + +/* Useful type definitions. */ +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef TRUE +#define TRUE 1 +#endif +typedef int abool; +typedef unsigned char byte; + +/* Information about a file. */ +typedef struct { + char author[128]; /* author's name */ + char name[128]; /* title */ + char date[128]; /* creation date */ + int channels; /* 1 for mono or 2 for stereo */ + int songs; /* number of subsongs */ + int default_song; /* 0-based index of the "main" subsong */ + int durations[32]; /* lengths of songs, in milliseconds, -1 = unspecified */ + abool loops[32]; /* whether songs repeat or not */ + /* the following technical information should not be used outside ASAP. */ + char type; + int fastplay; + int music; + int init; + int player; + int header_len; + byte song_pos[128]; +} ASAP_ModuleInfo; + +/* POKEY state. + Not for use outside the ASAP engine. */ +typedef struct { + int audctl; + abool init; + int poly_index; + int div_cycles; + int mute1; + int mute2; + int mute3; + int mute4; + int audf1; + int audf2; + int audf3; + int audf4; + int audc1; + int audc2; + int audc3; + int audc4; + int tick_cycle1; + int tick_cycle2; + int tick_cycle3; + int tick_cycle4; + int period_cycles1; + int period_cycles2; + int period_cycles3; + int period_cycles4; + int reload_cycles1; + int reload_cycles3; + int out1; + int out2; + int out3; + int out4; + int delta1; + int delta2; + int delta3; + int delta4; + int skctl; + char delta_buffer[888]; +} PokeyState; + +/* Player state. + Only module_info is meant to be read outside the ASAP engine. */ +typedef struct { + int cycle; + int cpu_pc; + int cpu_a; + int cpu_x; + int cpu_y; + int cpu_s; + int cpu_nz; + int cpu_c; + int cpu_vdi; + int scanline_number; + int nearest_event_cycle; + int next_scanline_cycle; + int timer1_cycle; + int timer2_cycle; + int timer4_cycle; + int irqst; + int extra_pokey_mask; + PokeyState base_pokey; + PokeyState extra_pokey; + int sample_offset; + int sample_index; + int samples; + int iir_acc_left; + int iir_acc_right; + ASAP_ModuleInfo module_info; + int tmc_per_frame; + int tmc_per_frame_counter; + int current_song; + int current_duration; + int blocks_played; + int silence_cycles; + int silence_cycles_counter; + byte poly9_lookup[511]; + byte poly17_lookup[16385]; + byte memory[65536]; +} ASAP_State; + +/* Maximum length of a "mm:ss.xxx" string including the terminator. */ +#define ASAP_DURATION_CHARS 10 + +/* Maximum length of a supported input file. + You can assume that files longer than this are not supported by ASAP. */ +#define ASAP_MODULE_MAX 65000 + +/* Output sample rate. */ +#define ASAP_SAMPLE_RATE 44100 + +/* Output formats. */ +typedef enum { + ASAP_FORMAT_U8 = 8, /* unsigned char */ + ASAP_FORMAT_S16_LE = 16, /* signed short, little-endian */ + ASAP_FORMAT_S16_BE = -16 /* signed short, big-endian */ +} ASAP_SampleFormat; + +/* Parses the string in the "mm:ss.xxx" format + and returns the number of milliseconds or -1 if an error occurs. */ +int ASAP_ParseDuration(const char *s); + +/* Converts number of milliseconds to a string in the "mm:ss.xxx" format. */ +void ASAP_DurationToString(char *s, int duration); + +/* Checks whether the extension of the passed filename is known to ASAP. */ +abool ASAP_IsOurFile(const char *filename); + +/* Checks whether the filename extension is known to ASAP. */ +abool ASAP_IsOurExt(const char *ext); + +/* Changes the filename extension, returns true on success. */ +abool ASAP_ChangeExt(char *filename, const char *ext); + +/* Gets information about a module. + "module_info" is the structure where the information is returned. + "filename" determines file format. + "module" is the music data (contents of the file). + "module_len" is the number of data bytes. + ASAP_GetModuleInfo() returns true on success. */ +abool ASAP_GetModuleInfo(ASAP_ModuleInfo *module_info, const char *filename, + const byte module[], int module_len); + +/* Loads music data. + "as" is the destination structure. + "filename" determines file format. + "module" is the music data (contents of the file). + "module_len" is the number of data bytes. + ASAP does not make copies of the passed pointers. You can overwrite + or free "filename" and "module" once this function returns. + ASAP_Load() returns true on success. + If false is returned, the structure is invalid and you cannot + call the following functions. */ +abool ASAP_Load(ASAP_State *as, const char *filename, + const byte module[], int module_len); + +/* Enables silence detection. + Makes ASAP finish playing after the specified period of silence. + "as" is ASAP state initialized by ASAP_Load(). + "seconds" is the minimum length of silence that ends playback. */ +void ASAP_DetectSilence(ASAP_State *as, int seconds); + +/* Prepares ASAP to play the specified song of the loaded module. + "as" is ASAP state initialized by ASAP_Load(). + "song" is a zero-based index which must be less than the "songs" field + of the ASAP_ModuleInfo structure. + "duration" is playback time in milliseconds - use durations[song] + unless you want to override it. -1 means indefinitely. */ +void ASAP_PlaySong(ASAP_State *as, int song, int duration); + +/* Mutes the selected POKEY channels. + This is only useful for people who want to grab samples of individual + instruments. + "as" is ASAP state after calling ASAP_PlaySong(). + "mask" is a bit mask which selects POKEY channels to be muted. + Bits 0-3 control the base POKEY channels, + bits 4-7 control the extra POKEY channels. */ +void ASAP_MutePokeyChannels(ASAP_State *as, int mask); + +/* Rewinds the current song. + "as" is ASAP state initialized by ASAP_PlaySong(). + "position" is the requested absolute position in milliseconds. */ +void ASAP_Seek(ASAP_State *as, int position); + +/* Fills the specified buffer with generated samples. + "as" is ASAP state initialized by ASAP_PlaySong(). + "buffer" is the destination buffer. + "buffer_len" is the length of this buffer in bytes. + "format" is the format of samples. + ASAP_Generate() returns number of bytes actually written + (less than buffer_len if reached the end of the song). + Normally you use a buffer of a few kilobytes or less, + and call ASAP_Generate() in a loop or via a callback. */ +int ASAP_Generate(ASAP_State *as, void *buffer, int buffer_len, + ASAP_SampleFormat format); + +/* Checks whether information in the specified file can be edited. */ +abool ASAP_CanSetModuleInfo(const char *filename); + +/* Updates the specified module with author, name, date, stereo + and song durations as specified in "module_info". + "module_info" contains the new module information. + "module" is the source file contents. + "module_len" is the source file length. + "out_module" is the destination buffer of size ASAP_MODULE_MAX. + ASAP_SetModuleInfo() returns the resulting file length (number of bytes + written to "out_module") or -1 if illegal characters were found. */ +int ASAP_SetModuleInfo(const ASAP_ModuleInfo *module_info, const byte module[], + int module_len, byte out_module[]); + +/* Checks whether the specified module can be converted to another format. + "filename" determines the source format. + "module_info" contains the information about the source module, + with possibly modified public fields. + "module" is the source file contents. + "module_len" is the source file length. + ASAP_CanConvert() returns the extension of the target format + or NULL if there's no possible conversion. */ +const char *ASAP_CanConvert(const char *filename, const ASAP_ModuleInfo *module_info, + const byte module[], int module_len); + +/* Converts the specified module to the format returned by ASAP_CanConvert(). + "filename" determines the source format. + "module_info" contains the information about the source module, + with possibly modified public fields. + "module" is the source file contents. + "module_len" is the source file length. + "out_module" is the destination buffer of size ASAP_MODULE_MAX. + ASAP_Convert() returns the resulting file length (number of bytes + written to "out_module") or -1 on error. */ +int ASAP_Convert(const char *filename, const ASAP_ModuleInfo *module_info, + const byte module[], int module_len, byte out_module[]); + +#ifdef __cplusplus +} +#endif + +#endif Index: apps/plugins/asap/asap2wav.c =================================================================== --- apps/plugins/asap/asap2wav.c (revision 0) +++ apps/plugins/asap/asap2wav.c (revision 0) @@ -0,0 +1,179 @@ +/* + * asap2wav.c - converter of ASAP-supported formats to WAV files + * + * Copyright (C) 2005-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include +#include +#include + +#include "asap.h" +#include "plugin.h" + +/* This macros must always be included. Should be placed at the top by + convention, although the actual position doesn't matter */ +PLUGIN_HEADER + +/* here is a global api struct pointer. while not strictly necessary, + it's nice not to have to pass the api pointer in all function calls + in the plugin */ +const struct plugin_api* rb; + +static abool no_input_files = TRUE; +static const char *output_file = NULL; +static abool output_header = TRUE; +static int song = -1; +static abool use_16bit = TRUE; +static int duration = -1; +static int mute_mask = 0; + +#define FILENAME_MAX 255 + +/* write 16-bit word as little endian */ +static void fput16(int x, int fp) +{ + char a = x & 0xff; + char b = (x >> 8) & 0xff; + rb->write(fp,&a, 1); + rb->write(fp,&b, 1); +} + +/* write 32-bit word as little endian */ +static void fput32(int x, int fp) +{ + char a = x & 0xff; + char b= (x >> 8) & 0xff; + char c = (x >> 16) & 0xff; + char d =(x >> 24) & 0xff; + + rb->write(fp,&a, 1); + rb->write(fp,&b, 1); + rb->write(fp,&c, 1); + rb->write(fp,&d, 1); +} + +static byte module[ASAP_MODULE_MAX]; +static ASAP_State asap; +static byte buffer[8192]; + +static void process_file(const char *input_file) +{ + int fp; + + int module_len; + + int n_bytes; + + fp = rb->open(input_file, O_RDONLY); + if (fp == -1) + { + rb->splash(HZ*2,"cannot open input_file"); + return; + } + + module_len = rb->read(fp,module,sizeof(module)); + rb->close(fp); + + if (!ASAP_Load(&asap, input_file, module, module_len)) + { + rb->splash(HZ*2,"format not supported"); + return; + } + + song = asap.module_info.default_song; + + duration = asap.module_info.durations[song]; + if (duration < 0) + duration = 180 * 1000; + + ASAP_PlaySong(&asap, song, duration); + ASAP_MutePokeyChannels(&asap, mute_mask); + + if (output_file == NULL) { + static char output_default[FILENAME_MAX]; + rb->strcpy(output_default, input_file); + ASAP_ChangeExt(output_default, output_header ? "wav" : "raw"); + output_file = output_default; + } + + fp = rb->open(output_file, O_WRONLY); + if (fp == -1) + { + rb->splash(HZ*2,"could not open outputfile."); + return; + } + + if (output_header) + { + int block_size = asap.module_info.channels << use_16bit; + int bytes_per_second = ASAP_SAMPLE_RATE * block_size; + n_bytes = duration * (ASAP_SAMPLE_RATE / 100) / 10 * block_size; + rb->write(fp,"RIFF", 4); + fput32(n_bytes + 36, fp); + rb->write(fp,"WAVEfmt \x10\0\0\0\1\0", 14); + fput16(asap.module_info.channels, fp); + fput32(ASAP_SAMPLE_RATE, fp); + fput32(bytes_per_second, fp); + fput16(block_size, fp); + fput16(8 << use_16bit, fp); + rb->write(fp,"data", 4); + fput32(n_bytes, fp); + } + + do { + n_bytes = ASAP_Generate(&asap, buffer, sizeof(buffer), + use_16bit ? ASAP_FORMAT_S16_LE : ASAP_FORMAT_U8); + if (rb->write(fp,buffer, n_bytes) != n_bytes) + { + rb->close(fp); + rb->splash(HZ*2,"error writing to output_file"); + return; + } + } while (n_bytes == sizeof(buffer)); + + rb->close(fp); + output_file = NULL; + song = -1; + duration = -1; + no_input_files = FALSE; +} + + +/* this is the plugin entry point */ +enum plugin_status plugin_start(const struct plugin_api* api, const void* parameter) +{ + /* if you are using a global api pointer, don't forget to copy it! + otherwise you will get lovely "I04: IllInstr" errors... :-) */ + rb = api; + + /* now go ahead and have fun! */ + rb->splash(HZ*2, "Encoding!"); + + output_file = "/test.wav"; + use_16bit = TRUE; + process_file(parameter); + + rb->splash(HZ*2, "Finished!"); + + return PLUGIN_OK; +} + Index: apps/plugins/asap/asap_internal.h =================================================================== --- apps/plugins/asap/asap_internal.h (revision 0) +++ apps/plugins/asap/asap_internal.h (revision 0) @@ -0,0 +1,102 @@ +/* + * asap_internal.h - private interface of the ASAP engine + * + * Copyright (C) 2005-2008 Piotr Fusik + * + * This file is part of ASAP (Another Slight Atari Player), + * see http://asap.sourceforge.net + * + * ASAP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. + * + * ASAP is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ASAP; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef _ASAP_INTERNAL_H_ +#define _ASAP_INTERNAL_H_ + +#include "plugin.h" +#define memset rb->memset +#define memcpy rb->memcpy +#define memcmp rb->memcmp +#define strcmp rb->strcmp +#define strcpy rb->strcpy +#define strstr rb->strcasestr +extern const struct plugin_api* rb; + +#if !defined(JAVA) && !defined(CSHARP) + +#include "asap.h" + +#define CONST_LOOKUP(type, name) \ + static const type name[] +#define FILE_FUNC static +#define ASAP_FUNC +#define PTR * +#define ADDRESSOF & +#define ARRAY * +#define VOIDPTR void * +#define UBYTE(data) (data) +#define SBYTE(data) (signed char) (data) +#define STRING const char * +#define ZERO_ARRAY(array) memset(array, 0, sizeof(array)) +#define COPY_ARRAY(dest, dest_offset, src, src_offset, len) \ + memcpy(dest + dest_offset, src + src_offset, len) +#define NEW_ARRAY(type, name, size) \ + type name[size] +#define INIT_ARRAY(array) memset(array, 0, sizeof(array)) + +#define AST ast-> +#define PST pst-> +#define MODULE_INFO module_info-> +#define ASAP_OBX const byte * +#define GET_OBX(name) name##_obx + +int ASAP_GetByte(ASAP_State *ast, int addr); +void ASAP_PutByte(ASAP_State *ast, int addr, int data); + +void Cpu_RunScanlines(ASAP_State *ast, int scanlines); + +void PokeySound_Initialize(ASAP_State *ast); +void PokeySound_StartFrame(ASAP_State *ast); +void PokeySound_PutByte(ASAP_State *ast, int addr, int data); +int PokeySound_GetRandom(ASAP_State *ast, int addr); +void PokeySound_EndFrame(ASAP_State *ast, int cycle_limit); +int PokeySound_Generate(ASAP_State *ast, byte buffer[], int buffer_offset, int blocks, ASAP_SampleFormat format); +abool PokeySound_IsSilent(const PokeyState *pst); +void PokeySound_Mute(const ASAP_State *ast, PokeyState *pst, int mask); + +#ifdef ASAPSCAN +abool call_6502_player(ASAP_State *ast); +extern abool cpu_trace; +void print_cpu_state(const ASAP_State *ast, int pc, int a, int x, int y, int s, int nz, int vdi, int c); +#endif + +#endif /* !defined(JAVA) && !defined(CSHARP) */ + +#define ASAP_MAIN_CLOCK 1773447 + +#define V_FLAG 0x40 +#define D_FLAG 0x08 +#define I_FLAG 0x04 +#define Z_FLAG 0x02 + +#define NEVER 0x800000 + +#define dGetByte(addr) UBYTE(AST memory[addr]) +#define dPutByte(addr, data) AST memory[addr] = (byte) (data) +#define dGetWord(addr) (dGetByte(addr) + (dGetByte((addr) + 1) << 8)) +#define GetByte(addr) (((addr) & 0xf900) == 0xd000 ? ASAP_GetByte(ast, addr) : dGetByte(addr)) +#define PutByte(addr, data) do { if (((addr) & 0xf900) == 0xd000) ASAP_PutByte(ast, addr, data); else dPutByte(addr, data); } while (FALSE) +#define RMW_GetByte(dest, addr) do { if (((addr) >> 8) == 0xd2) { dest = ASAP_GetByte(ast, addr); AST cycle--; ASAP_PutByte(ast, addr, dest); AST cycle++; } else dest = dGetByte(addr); } while (FALSE) + +#endif /* _ASAP_INTERNAL_H_ */ Index: apps/plugins/asap/Makefile =================================================================== --- apps/plugins/asap/Makefile (revision 0) +++ apps/plugins/asap/Makefile (revision 0) @@ -0,0 +1,105 @@ +# __________ __ ___. +# Open \______ \ ____ ____ | | _\_ |__ _______ ___ +# Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +# Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +# Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +# \/ \/ \/ \/ \/ +# $Id $ +# + +INCLUDES = -I$(APPSDIR) -I.. -I. $(TARGET_INC) -I$(FIRMDIR)/include -I$(FIRMDIR)/export \ + -I$(FIRMDIR)/common -I$(FIRMDIR)/drivers -I$(OUTDIR) -I$(BUILDDIR) + +ifeq ($(CPU),coldfire) + MIDIOPTS = -O2 +else + MIDIOPTS = -O +endif + +PLAYERS_OBX = players/cmc.obx players/mpt.obx players/rmt4.obx players/rmt8.obx players/tmc.obx players/tm2.obx +XASM = xasm -q + +CFLAGS = $(INCLUDES) $(GCCOPTS) $(TARGET) $(EXTRA_DEFINES) $(MIDIOPTS) \ + -DTARGET_ID=$(TARGET_ID) -DMEM=${MEMORYSIZE} -DPLUGIN + +ifdef APPEXTRA + INCLUDES += $(patsubst %,-I$(APPSDIR)/%,$(subst :, ,$(APPEXTRA))) +endif + +LINKFILE := $(OBJDIR)/link.lds +DEPFILE = $(OBJDIR)/dep-asap + +# This sets up 'SRC' based on the files mentioned in SOURCES +include $(TOOLSDIR)/makesrc.inc + +SOURCES = $(SRC) +OBJS := $(SRC:%.c=$(OBJDIR)/%.o) +DIRS = . + +ifndef SIMVER + LDS := ../plugin.lds + OUTPUT = $(OUTDIR)/asap.rock +else ## simulators + OUTPUT = $(OUTDIR)/asap.rock +endif + +all: $(OUTPUT) + +ifndef SIMVER +$(OBJDIR)/asap.elf: $(OBJS) $(LINKFILE) $(BITMAPLIBS) + $(call PRINTS,LD $(@F))$(CC) $(CFLAGS) -o $@ $(OBJS) -L$(BUILDDIR) -lplugin -lgcc \ + $(LINKBITMAPS) -T$(LINKFILE) -Wl,--gc-sections -Wl,-Map,$(OBJDIR)/asap.map + +$(OUTPUT): $(OBJDIR)/asap.elf + $(call PRINTS,OBJCOPY $(@F))$(OC) -O binary $< $@ +else + +################################################### +# This is the SDL simulator version + +$(OUTPUT): $(OBJS) + $(call PRINTS,LD $(@F))$(CC) $(CFLAGS) $(SHARED_FLAG) $(OBJS) -L$(BUILDDIR) -lplugin $(LINKBITMAPS) -o $@ +ifeq ($(findstring CYGWIN,$(UNAME)),CYGWIN) +# 'x' must be kept or you'll have "Win32 error 5" +# $ fgrep 5 /usr/include/w32api/winerror.h | head -1 +# #define ERROR_ACCESS_DENIED 5L +else + @chmod -x $@ +endif + +endif # end of simulator section + +include $(TOOLSDIR)/make.inc + +# MEMORYSIZE should be passed on to this makefile with the chosen memory size +# given in number of MB +$(LINKFILE): $(LDS) + $(call PRINTS,build $(@F))cat $< | $(CC) -DMEMORYSIZE=$(MEMORYSIZE) $(INCLUDES) $(TARGET) \ + $(DEFINES) -E -P - >$@ + +players.h: raw2c.pl ${PLAYERS_OBX} + perl raw2c.pl ${PLAYERS_OBX} >$@ + +players/cmc.obx: players/cmc.asx + ${XASM} -o $@ players/cmc.asx + +players/mpt.obx: players/mpt.asx + ${XASM} -o $@ players/mpt.asx + +players/rmt4.obx: players/rmt.asx + ${XASM} -d STEREOMODE=0 -o $@ players/rmt.asx + +players/rmt8.obx: players/rmt.asx + ${XASM} -d STEREOMODE=1 -o $@ players/rmt.asx + +players/tmc.obx: players/tmc.asx + ${XASM} -o $@ players/tmc.asx + +players/tm2.obx: players/tm2.asx + ${XASM} -o $@ players/tm2.asx + +clean: + $(call PRINTS,cleaning asap)rm -rf $(OBJDIR)/asap + $(SILENT)rm -f $(OBJDIR)/asap.* $(DEPFILE) + +-include $(DEPFILE) Index: apps/plugins/asap/players/rmt8.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\rmt8.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/mpt.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\mpt.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/cmc.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\cmc.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/tm2.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\tm2.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/mpt.asx =================================================================== --- apps/plugins/asap/players/mpt.asx (revision 0) +++ apps/plugins/asap/players/mpt.asx (revision 0) @@ -0,0 +1,904 @@ +*----------------* +* Player MPT 2.4 * +* ver.spackowana * +*----------------* + + org $0500 + +*--- strona 0 + +addr equ $ec ,$ed +word equ $ee ,$ef +audzer equ $f0 ,$f1 ,$f2 ,$f3 +licslp equ $f4 ,$f5 ,$f6 ,$f7 +lensmp equ $f8 +lsbmsb equ $f9 +adrs1 equ $fa ,$fb +adrs2 equ $fc ,$fd +adrsmp equ $fe ,$ff + +*--- program + + jmp init + +play lda czygrc + bne *+3 + rts + lda #0 + sta oraaud + inc licz + lda pozptr + cmp maxptr + bcc r1 + dec zegar + beq p1 + jmp r5 +p1 ldx #0 + stx pozptr +p2 lda #0 + sta ptrwsk,x + sta licspc,x + lda adrtrl,x + sta addr + lda adrtrh,x + sta addr+1 + ldy pozsng +p3 lda (addr),y + iny + cmp #$ff + beq p5 + cmp #$fe + bne p6 +p4 jmp inic2 +p5 lda (addr),y + bmi p4 + asl @ + tay + sty pozsng + jmp p3 +p6 sta numptr,x + lda (addr),y + sta poddzw,x +p7 inx + cpx #4 + bne p2 + iny + sty pozsng + jmp r5 +r1 dec zegar + bpl r5 + lda tempo + sta zegar + ldx #3 +r2 dec licspc,x + bpl r4 + lda numptr,x + asl @ + tay +aptrlz lda $ffff,y + sta addr + iny +aptrhz lda $ffff,y + sta addr+1 + ora addr + beq r4 + lda ptrwsk,x + sta licptr + jsr newdzw + ldy licptr + iny + tya + sta ptrwsk,x + lda ilespc,x + sta licspc,x + cpx #2 + bne r4 + lda adcvol,x + eor #$f + asl @ + asl @ + asl @ + asl @ + adc volstb + adc #0 + sta volsmp+2 +r4 dex + bpl r2 + inc pozptr +r5 ldx #1 + lda typsmp + cmp #2 + beq r6 + ldx #3 +r6 lda typsmp + cmp #2 + bne r7 + cpx kansmp + beq r8 +r7 jmp dzwiek +r8 lda audzer,x + and filtry,x + beq r9 + ldy #$28 + lda (addr),y + clc + adc numdzw,x + jsr czest + sec + adc p1pom,x + sta freq+2,x +r9 dex + bpl r6 + lda #3 + sta $d20f + lda audzer+1 + and #$10 + beq w1 + ldy numdzw+1 + lda bsfrql,y + sta freq + lda bsfrqh,y + sta freq+1 +w1 lda freq + sta $d200 + lda freq+1 + sta $d202 + lda freq+2 + sta $d204 + lda freq+3 + sta $d206 + lda volume + ldx #$ff + ldy typsmp + cpy #1 + bne w2 + ldx kansmp + beq w3 +w2 sta $d201 +w3 lda volume+1 + cpx #1 + beq w4 + sta $d203 +w4 cpy #2 + beq w6 + lda volume+2 + cpx #2 + beq w5 + sta $d205 +w5 lda volume+3 + cpx #3 + beq w6 + sta $d207 +w6 lda audzer + ora audzer+1 + ora audzer+2 + ora audzer+3 + ora oraaud + sta $d208 + rts +filtry dta b(4),b(2),b(0),b(0) + +dzwiek lda adrinl,x + sta addr + lda adrinh,x + sta addr+1 + ora addr + bne d0 + sta volume,x + sta audzer,x + jmp r9 +d0 ldy licslp,x + cpy #$20 + beq d3 + lda (addr),y + sec + sbc adcvol,x + bit sprvol + beq d1 + and #$f0 +d1 sta volume,x + iny + lda (addr),y + sta przech + iny + sty licslp,x + and #7 + beq d4 + tay + lda akcadl-1,y + sta akjmpz+1 + lda akcadh-1,y + sta akjmpz+2 + lda przech + lsr @ + lsr @ + lsr @ + lsr @ + lsr @ + ora #$28 + tay + lda (addr),y + clc +akjmpz jsr $ffff +d2 lda #0 + sta audzer,x + jmp r9 +d3 lda p3max,x + beq d4 + dec p3lic,x + bne d4 + sta p3lic,x + lda volume,x + and #15 + beq d4 + dec volume,x +d4 ldy #$23 + lda (addr),y + sta audzer,x + lda trnlic,x + clc + adc #$25 + tay + and #3 + sta trnlic,x + dey + lda (addr),y + adc adcdzw,x + sta numdzw,x + jsr czest+2 + sta freq,x + lda p2lic,x + beq d5 + dec p2lic,x + jmp r8 +d5 lda branch,x + sta p1jmpz+1 +p1jmpz bpl * + jmp typ0dz + brk + jmp typ1dz + brk + jmp typ2dz + brk + jmp typ3dz +czygrc dta b(0) + jmp typ4dz +zapisx dta b(0) + jmp typ5dz +zapisy dta b(0) + jmp typ6dz +sprvol dta b($10) + jmp typ7dz + +newdzw lda #0 + sta adcvol,x + ldy licptr + dey +new iny + lda (addr),y + cmp #$fe + bne q0 + sty licptr + rts +q0 cmp #$e0 + bcc q1 + lda maxptr + sta pozptr + bne new +q1 cmp #$d0 + bcc q2 + and #15 + sta tempo + sta zegar + bpl new +q2 cmp #$c0 + bcc q3 + and #15 + eor #15 + sta adcvol,x + bpl new +q3 cmp #$80 + bcc q4 + and #$3f + sta ilespc,x + bpl new +q4 cmp #$40 + bcc q5 + iny + sty licptr + and #$1f + sta numsmp,x + asl @ + tay +ainslz lda $ffff,y + sta adrinl,x + iny +ainshz lda $ffff,y + sta adrinh,x + jmp newdzw + +q5 sty licptr + sta przech + clc + adc poddzw,x + sta adcdzw,x + lda typsmp + beq n9 + cmp #2 + beq n8 + lda numsmp,x + cmp #$1f + bne n9 + lda przech + sec + sbc #1 +n6 and #15 + tay + lda (adrsmp),y + sta adrs2+1 + tya + ora #$10 + tay + lda (adrsmp),y + sta lensmp + ldy #1 + ora adrs2+1 + bne n7 + ldy #0 +n7 sty czysmp + lda #0 + sta adrs2 + sta adrinl,x + sta adrinh,x + txa + asl @ + sta wsksmp + stx kansmp + rts +n8 cpx #2 + bcs nb +n9 lda adrinl,x + sta word + lda adrinh,x + sta word+1 + ora word + beq na-1 + ldy #$20 + lda (word),y + and #15 + sta p1lsb,x + lda (word),y + and #$70 + lsr @ + lsr @ + sta branch,x + iny + lda (word),y + asl @ + asl @ + pha + and #$3f + sta p2lic,x + pla + and #$c0 + sta frqwsk,x + iny + lda (word),y + sta p3max,x + sta p3lic,x + lda #0 + sta licslp,x + sta trnlic,x + sta p1lic,x + sta p1pom,x + lda adcdzw,x + sta numdzw,x + jsr czest + sta freq,x + cpx kansmp + beq na + rts +na ldy #$ff + sty kansmp + iny + sty czysmp + rts +nb cpx #2 + bne nd + ldy adcdzw+2 + lda frsmpl,y + sta smpl1z+1 + lda frsmph,y + sta smpl2z+1 + lda #0 + sta lsbmsb + sta adrs1 + lda numsmp+2 + and #15 + tay + lda (adrsmp),y + sta adrs1+1 + tya + ora #$10 + tay + lda (adrsmp),y + sta smpl3z+1 + ora adrs1+1 + bne nc + sta smpl1z+1 + sta smpl2z+1 +nc rts +nd lda numsmp+3 + and #15 + tay + lda (adrsmp),y + sta adrs2+1 + tya + ora #$10 + tay + lda (adrsmp),y + ora adrs2+1 + beq ne + lda (adrsmp),y + sec + sbc adrs2+1 + sta lensmp + lda #0 + sta adrs2 + lda #$8d + bne nf +ne lda #$ad +nf sta drum2z + sta drum1z + lda #$18 + sta $d207 + rts + +typ0dz lda licz + and #7 + lsr @ + lsr @ + bcc t2 + bne typ1dz + lda p1lsb,x +t1 clc + sta p1pom,x + adc freq,x + sta freq,x + jmp r8 +t2 lda #0 + sta p1pom,x + jmp r8 +typ1dz lda freq,x + sec + sbc p1lsb,x + sta freq,x + sec + lda #0 + sbc p1lsb,x + sta p1pom,x + jmp r8 +typ2dz lda p1lic,x + clc + sta p1pom,x + adc freq,x +t3 sta freq,x + clc + lda p1lic,x + adc p1lsb,x + sta p1lic,x + jmp r8 +typ3dz lda numdzw,x + sec + sbc p1lic,x +t4 sta numdzw,x + jsr czest + jmp t3 +typ4dz lda #0 + sec + sbc p1lic,x + sta p1pom,x + lda freq,x + sec + sbc p1lic,x + jmp t3 +typ5dz lda numdzw,x + clc + adc p1lic,x + jmp t4 +typ6dz jsr t5 + jmp t1 +typ7dz jsr t5 + clc + adc numdzw,x + jsr a3 + jmp r8 +t5 ldy p1lic,x + lda p1lsb,x + bmi t6 + iny + iny +t6 dey + tya + sta p1lic,x + cmp p1lsb,x + bne t7 + lda p1lsb,x + eor #$ff + sta p1lsb,x +t7 lda p1lic,x + rts +czest and #$3f + ora frqwsk,x + tay +t1frqz lda $ffff,y + rts + +akcadl dta l(a1),l(a0),l(a2) + dta l(a4),l(a5),l(a6),l(a8) +akcadh dta h(a1),h(a0),h(a2) + dta h(a4),h(a5),h(a6),h(a8) +audora dta b($40),b(0),b($20),b(0) + +a0 adc freq,x +a1 sta freq,x + rts +a2 adc adcdzw,x +a3 sta numdzw,x + jsr czest + sta freq,x + rts +a4 sta freq,x + lda audora,x + bpl a7 +a5 sta freq,x + lda #$80 + bne a7 +a6 sta freq,x + lda #1 +a7 ora oraaud + sta oraaud + rts +a8 and $d20a + sta freq,x +a9 rts + +bsfrql equ *-1 + dta b($f2),b($33),b($96) + dta b($e2),b($38),b($8c),b(0) + dta b($6a),b($e8),b($6a),b($ef) + dta b($80),b(8),b($ae),b($46) + dta b($e6),b($95),b($41),b($f6) + dta b($b0),b($6e),b($30),b($f6) + dta b($bb),b($84),b($52),b($22) + dta b($f4),b($c8),b($a0),b($7a) + dta b($55),b($34),b($14),b($f5) + dta b($d8),b($bd),b($a4),b($8d) + dta b($77),b($60),b($4e),b($38) + dta b($27),b($15),b(6),b($f7) + dta b($e8),b($db),b($cf),b($c3) + dta b($b8),b($ac),b($a2),b($9a) + dta b($90),b($88),b($7f),b($78) + dta b($70),b($6a),b($64),b($5e) + +bsfrqh equ *-1 + dta b(13,13,12,11,11,10,10,9,8,8,7,7,7,6,6) + dta b(5,5,5,4,4,4,4,3,3,3,3,3,2,2,2,2) + dta b(2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,0) + dta b(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0) + +volstb dta d'8888888888888888' + dta d'667777888889999:' + dta d'556667788899:::;' + dta d'455667788899::;;' + dta d'44556677899::;;<' + dta d'34456677899::;<<' + dta d'33455677899:;;<=' + dta d'23445677899:;<<=' + dta d'2334566789::;<==' + dta d'2234566789::;<=>' + dta d'1234566789::;<=>' + dta d'1234556789:;;<=>' + dta d'1234456789:;<<=>' + dta d'1233456789:;<==>' + dta d'1223456789:;<=>>' + dta d'0123456789:;<=>?' + +frsmpl dta b($20),b($22),b($24),b($26),b($29) + dta b($2b),b($2e),b($30),b($33),b($37) + dta b($3a),b($3d),b($41),b($45),b($49) + dta b($4d),b($52),b($57),b($5c),b($61) + dta b($67),b($6e),b($74),b($7b),b($82) + dta b($8a),b($92),b($9b),b($a4),b($ae) + dta b($b8),b($c3),b($cf),b($dc),b($e9) + dta b($f6),b(5),b($15),b($25),b($37) + dta b($49),b($5d),b($71),b($87),b($9f) + dta b($b8),b($d2),b($ed),b($b),b($2a) + dta b($4b),b($6e),b($93),b($ba),b($e3) + dta b($f),b($3e),b($70),b($a4),b($db) + +frsmph dta d' ' + dta d' ' + dta d' !!!!!!!!!' + dta d'!!!"""""""#####' + +*--- inicjacja + +iniadl dta l(inic0),l(inic2) + dta l(inic4),l(inic5) + dta l(inic6),l(inic7) + dta l(inic8),l(inic9) +iniadh dta h(inic0),h(inic2) + dta h(inic4),h(inic5) + dta h(inic6),h(inic7) + dta h(inic8),h(inic9) + +init stx zapisx + sty zapisy + and #7 + tay + lda iniadl,y + sta inic1+1 + lda iniadh,y + sta inic1+2 +inic1 jmp $ffff + +inic0 lda zapisy + ldx zapisx + sta ainslz+1 + sta ainshz+1 + stx ainslz+2 + stx ainshz+2 + clc + adc #$40 + sta aptrlz+1 + sta aptrhz+1 + bcc i2 + inx +i2 stx aptrlz+2 + stx aptrhz+2 + clc + adc #$80 + sta t1frqz+1 + bcc i4 + inx +i4 stx t1frqz+2 + inx + sta j4+1 + stx j4+2 + ldx #9 +j4 lda $ffff,x + sta adrtrl,x + dex + bpl j4 + dec tempo + +inic2 lda #0 + sta czygrc + ldx ressmp+1 + sta adrs1+1 + lda #$ad + sta drum2z + sta drum1z + ldy #0 + sty smpl1z+1 + sty smpl2z+1 +k2 ldx $d40b + lda (adrs2),y + lsr @ + lsr @ + lsr @ + lsr @ + ora #$10 +drum1z sta $d207 + jsr k6 +k3 cpx $d40b + beq k3 + sta $d205 + ldx $d40b + lda (adrs2),y + inc adrs2 + bne k4 + inc adrs2+1 + dec lensmp + bne k4 + lda #$ad + sta drum2z + sta drum1z + lda #8 +k4 ora #$10 +drum2z sta $d207 + jsr k6 +k5 cpx $d40b + beq k5 + sta $d205 + lda typsmp + bne k2 + rts + +k6 clc + lda lsbmsb +smpl1z adc #0 + sta lsbmsb + lda adrs1 +smpl2z adc #0 + sta adrs1 + bcc k7 + inc adrs1+1 + lda adrs1+1 +smpl3z cmp #0 + bne k7 + sty smpl1z+1 + sty smpl2z+1 + rts +k7 lda (adrs1),y + bit lsbmsb + bmi k8 + lsr @ + lsr @ + lsr @ + lsr @ +k8 and #15 + tay +volsmp lda volstb,y + ldy #0 + rts + +inic9 ldy #0 + sty typsmp + sty czysmp + dey + sty kansmp + rts + +*--- zmienne + +adrtrl org *+4 +adrtrh org *+4 +maxptr org *+1 +tempo org *+1 + +branch org *+4 +volume org *+4 +adcvol org *+4 +freq org *+4 +frqwsk org *+4 +adcdzw org *+4 +poddzw org *+4 +adrinl org *+4 +adrinh org *+4 +numdzw org *+4 +numsmp org *+4 +numptr org *+4 +ptrwsk org *+4 +ilespc org *+4 +licspc org *+4 +p1lsb org *+4 +p1lic org *+4 +p1pom org *+4 +p2lic org *+4 +p3max org *+4 +p3lic org *+4 +trnlic org *+4 +zegar org *+1 +pozsng org *+1 +pozptr org *+1 +wsksmp org *+1 +kansmp org *+1 +czysmp org *+1 +typsmp org *+1 +oraaud org *+1 +licz org *+1 +przech org *+1 +licptr org *+1 + + end Index: apps/plugins/asap/players/tmc.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\tmc.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/cmc.asx =================================================================== --- apps/plugins/asap/players/cmc.asx (revision 0) +++ apps/plugins/asap/players/cmc.asx (revision 0) @@ -0,0 +1,944 @@ +*---------------------------* +* cmc player v 2.1 * +* by Marcin Lewandowski * +* based on cmc player v 2.0 * +* by Janusz Pelc * +*---------------------------* + + org $0500 + +*--- strona 0 + +addr equ $fc +word equ $fe + +*--- skoki + + jmp basic + jmp init + jmp play + +*--- dane + +volume dta d' ' +czest dta d' ' +numins dta d' ' + + dta c' cmc player v 2.1 '* + +frq dta d' ' +znieks dta d' ' +audc dta b(0) + +czest1 dta d' ' +czest2 dta d' ' +czest3 dta d' ' +zniek dta d' ' +count1 dta b($ff),b($ff),b($ff) +count2 dta d' ' +lopad dta d' ' +numptr dta d' ' +poswpt dta d' ' +ilewol dta d' ' +czygrx dta b($80),b($80),b($80) +czygrc dta b($80) + +dana0 dta d' ' +dana1 dta d' ' +dana2 dta d' ' +dana3 dta d' ' +dana4 dta d' ' +dana5 dta d' ' +ladr dta d' ' +hadr dta d' ' + +posptr dta b(0) +possng dta b(0) +pocrep dta b(0) +konrep dta b(0) +ilrep dta b(0) +tmpo dta b(0) +ltemp dta b(0) +b1 dta b(0) +b2 dta b(0) +b3 dta b(0) +czygr dta b(0) + +adrmus dta a(0) +adradr dta a(0) +adrsng dta a(0) + +*--- init + +init sta b1 + stx b2 + sty b3 + and #$70 + lsr @ + lsr @ + lsr @ + tax + lda tab1,x + sta zm1+1 + lda tab1+1,x + sta zm1+2 + lda #3 + sta $d20f + cld + lda word + pha + lda word+1 + pha + ldy b3 + ldx b2 + lda b1 +zm1 jsr graj + pla + sta word+1 + pla + sta word + rts + +graj lda adrsng + sta word + lda adrsng+1 + sta word+1 + ldy #0 + txa + beq grajx +l1 lda (word),y + cmp #$8f + beq l2 + cmp #$ef + bne l3 +l2 dex + bne l3 + iny + cpy #$54 + bcs l4 + tya + tax + bpl grajx +l3 iny + cpy #$54 + bcc l1 +l4 rts + +grajx stx possng + jsr skoncz + lda #0 + ldx #9 +l5 sta poswpt,x + dex + bpl l5 + sta posptr + lda #1 + sta czygr + lda #$ff + sta konrep + lda adrmus + sta word + lda adrmus+1 + sta word+1 + ldy #$13 + lda (word),y + tax + lda adrsng + sta word + lda adrsng+1 + sta word+1 + ldy possng +l6 lda (word),y + cmp #$cf + bne l7 + tya + clc + adc #$55 + tay + lda (word),y + bmi l8 + tax + jmp l8 +l7 cmp #$8f + beq l8 + cmp #$ef + beq l8 + dey + bpl l6 +l8 stx tmpo + stx ltemp + rts + +tempo and #$f + beq l8 + stx d0+1 + stx d1+1 + stx d2+1 + sty d0+2 + sty d1+2 + sty d2+2 + rts + +inic stx adrmus + stx word + sty adrmus+1 + sty word+1 + clc + txa + adc #$14 + sta adradr + tya + adc #0 + sta adradr+1 + stx adrsng + iny + iny + sty adrsng+1 + ldy #$13 + lda (word),y + sta tmpo + sta ltemp + +skoncz ldx #8 +l9 lda #0 + sta czygr + sta $d200,x + cpx #3 + bcs l10 + sta volume,x + lda #$ff + sta count1,x +l10 dex + bpl l9 + +przer lda #$80 +l11 ldx #3 +l12 sta czygrx,x + dex + bpl l12 +l13 rts + +kont lda #1 + sta czygr + lda #0 + beq l11 + +instr and #3 + cmp #3 + beq l13 + cpx #$40 + bcs l13 + cpy #26 + bcs l13 + tax + lda #$80 + sta czygrx,x + +inst lda #0 + sta count1,x + sta count2,x + sta lopad,x + lda b2 + sta czest,x + + lda b3 + asl @ + asl @ + asl @ + sta word + clc + lda adrmus + adc #$30 + pha + lda adrmus+1 + adc #1 + tay + pla + clc + adc word + sta ladr,x + tya + adc #0 + sta hadr,x + + clc + lda adrmus + adc #$94 + sta word + lda adrmus+1 + adc #0 + sta word+1 + lda b3 + asl @ + adc b3 + asl @ + tay + lda (word),y + sta dana0,x + iny + lda (word),y + sta dana1,x + and #7 + sta b1 + iny + lda (word),y + sta dana2,x + iny + lda (word),y + sta dana3,x + iny + lda (word),y + sta dana4,x + iny + lda (word),y + sta dana5,x + + ldy #0 + lda b1 + cmp #3 + bne l14 + ldy #2 +l14 cmp #7 + bne l15 + ldy #4 +l15 lda tab3,y + sta word + lda tab3+1,y + sta word+1 + lda dana2,x + lsr @ + lsr @ + lsr @ + lsr @ + clc + adc b2 + sta b2 + sta zm2+1 + tay + lda b1 + cmp #7 + bne l16 + tya + asl @ + tay + lda (word),y + sta czest1,x + iny + sty b2 + jmp l17 +l16 lda (word),y + sta czest1,x + lda dana2,x + and #$f + clc + adc b2 + sta b2 +l17 ldy b2 + lda b1 + cmp #5 + php + lda (word),y + plp + beq l18 + cmp czest1,x + bne l18 + sec + sbc #1 +l18 sta czest2,x + lda dana0,x + pha + and #3 + tay + lda tab4,y + sta zniek,x + pla + lsr @ + lsr @ + lsr @ + lsr @ + ldy #$3e + cmp #$f + beq l19 + ldy #$37 + cmp #$e + beq l19 + ldy #$30 + cmp #$d + beq l19 + clc +zm2 adc #0 + tay +l19 lda tab5,y + sta czest3,x + rts + +*--- play + +play cld + lda addr + pha + lda addr+1 + pha + lda word + pha + lda word+1 + pha + lda czygr + bne g1 + jmp end +g1 lda czygrc + beq g2 + jmp dal3 +g2 lda tmpo + cmp ltemp + beq g3 + jmp dal2 +g3 lda posptr + beq g4 + jmp dal1 +g4 ldx #2 +g5 ldy czygrx,x + bmi g6 + sta czygrx,x +g6 sta poswpt,x + dex + bpl g5 + + lda adrsng + sta addr + lda adrsng+1 + sta addr+1 + ldy possng + sty word +g7 cpy konrep + bne g8 + lda ilrep + beq g8 + lda possng + ldy pocrep + sty possng + dec ilrep + bne g7 + sta possng + tay + bpl g7 +g8 ldx #0 +g9 lda (addr),y + cmp #$fe + bne g10 + ldy possng + iny + cpy word + beq g11 + sty possng + jmp g7 +g10 sta numptr,x + clc + tya + adc #$55 + tay + inx + cpx #3 + bcc g9 + ldy possng + lda (addr),y + bpl dal1 + cmp #$ff + beq dal1 + lsr @ + lsr @ + lsr @ + and #$e + tax + lda tab2,x + sta zm3+1 + lda tab2+1,x + sta zm3+2 + lda numptr+1 + sta word+1 +zm3 jsr stop + sty possng + cpy #$55 + bcs g11 + cpy word + bne g7 +g11 ldy word + sty possng + jmp end + +stop jsr przer +g12 ldy #$ff + rts +jump bmi g12 + tay + rts +up bmi g12 + sec + tya + sbc word+1 + tay + rts +down bmi g12 + clc + tya + adc word+1 + tay + rts +temp bmi g12 + sta tmpo + sta ltemp + iny + rts +rep bmi g12 + lda numptr+2 + bmi g12 + sta ilrep + iny + sty pocrep + clc + tya + adc word+1 + sta konrep + rts +break dey + bmi g13 + lda (addr),y + cmp #$8f + beq g13 + cmp #$ef + bne break +g13 iny + rts + +dal1 ldx #2 +v1 lda ilewol,x + beq v2 + dec ilewol,x + bpl v7 +v2 lda czygrx,x + bne v7 + ldy numptr,x + cpy #$40 + bcs v7 + lda adradr + sta addr + lda adradr+1 + sta addr+1 + lda (addr),y + sta word + clc + tya + adc #$40 + tay + lda (addr),y + sta word+1 + and word + cmp #$ff + beq v7 +v3 ldy poswpt,x + lda (word),y + and #$c0 + bne v4 + lda (word),y + and #$3f + sta numins,x + inc poswpt,x + bpl v3 +v4 cmp #$40 + bne v5 + lda (word),y + and #$3f + sta b2 + lda numins,x + sta b3 + jsr inst + jmp v6 +v5 cmp #$80 + bne v7 + lda (word),y + and #$3f + sta ilewol,x +v6 inc poswpt,x +v7 dex + bpl v1 + + ldx posptr + inx + txa + and #$3f + sta posptr + +dal2 dec ltemp + bne dal3 + lda tmpo + sta ltemp + lda posptr + bne dal3 + inc possng + +dal3 ldy czest2 + lda dana1 + and #7 + cmp #5 + beq a1 + cmp #6 + bne a2 +a1 dey +a2 sty frq+3 + ldy #0 + cmp #5 + beq a3 + cmp #6 + bne a4 +a3 ldy #2 +a4 cmp #7 + bne a5 + ldy #$28 +a5 sty audc + + ldx #2 +loop lda dana1,x + and #$e0 + sta znieks,x + lda ladr,x + sta addr + lda hadr,x + sta addr+1 + lda count1,x + cmp #$ff + beq y4 + cmp #$f + bne y2 + lda lopad,x + beq y4 + dec lopad,x + lda lopad,x + bne y4 + ldy volume,x + beq y1 + dey +y1 tya + sta volume,x + lda dana3,x + sta lopad,x + jmp y4 +y2 lda count1,x + lsr @ + tay + lda (addr),y + bcc y3 + lsr @ + lsr @ + lsr @ + lsr @ +y3 and #$f + sta volume,x +y4 ldy czest1,x + lda dana1,x + and #7 + cmp #1 + bne y6 + dey + tya + iny + cmp czest2,x + php + lda #1 + plp + bne y5 + asl @ + asl @ +y5 and count2,x + beq y6 + ldy czest2,x + cpy #$ff + bne y6 + lda #0 + sta volume,x +y6 tya + sta frq,x + lda #1 + sta b1 + lda count1,x + cmp #$f + beq y9 + and #7 + tay + lda tab9,y + sta word + lda count1,x + and #8 + php + txa + plp + clc + beq y7 + adc #3 +y7 tay + lda dana4,y + and word + beq y9 + lda czest3,x + sta frq,x + stx b1 + dex + bpl y8 + sta frq+3 + lda #0 + sta audc +y8 inx + lda zniek,x + sta znieks,x +y9 lda count1,x + and #$f + cmp #$f + beq y10 + inc count1,x + lda count1,x + cmp #$f + bne y10 + lda dana3,x + sta lopad,x +y10 lda czygrx,x + bpl y11 + lda volume,x + bne y11 + lda #$40 + sta czygrx,x +y11 inc count2,x + ldy #0 + lda dana1,x + lsr @ + lsr @ + lsr @ + lsr @ + bcc y12 + dey +y12 lsr @ + bcc y13 + iny +y13 clc + tya + adc czest1,x + sta czest1,x + lda czest2,x + cmp #$ff + bne y14 + ldy #0 +y14 clc + tya + adc czest2,x + sta czest2,x + dex + bmi x1 + jmp loop + +x1 lda znieks + sta znieks+3 + lda dana1 + and #7 + tax + ldy #3 + lda b1 + beq x2 + ldy tab10,x +x2 tya + pha + lda tab8,y + php + and #$7f + tax + tya + and #3 + asl @ + tay + lda frq,x +d0 sta $d200,y + iny + lda volume,x + cpx #3 + bne x3 + lda volume +x3 ora znieks,x + plp + bpl d1 + lda #0 +d1 sta $d200,y + pla + tay + dey + and #3 + bne x2 + ldy #8 + lda audc +d2 sta $d200,y + + clc +end pla + sta word+1 + pla + sta word + pla + sta addr+1 + pla + sta addr + rts + +*--- basic + +basic pla + tax + beq p6 + cmp #2 + beq p2 +p1 pla + pla + dex + bne p1 + rts +p2 lda $14 + cmp $14 + beq *-2 + lda $224 + cmp p8 + beq p1 +p3 lda $224 + sta p9+1 + lda $225 + sta p9+2 + lda p8 + sta $225 + pla + pla + beq p4 + sec + sbc #1 +p4 sta p5+1 + pla + tay + pla + tax + lda #$70 + jsr init + lda #0 +p5 ldx #0 + jmp init +p6 lda $14 + cmp $14 + beq *-2 + lda $224 + cmp p8 + bne p2-1 +p7 lda p9+1 + sta $224 + lda p9+2 + sta $225 + lda #$40 + jmp init +p8 jsr play + bcc p9 + jsr p7 +p9 jmp $ffff + +*--- tablice + +tab1 dta a(graj) + dta a(grajx) + dta a(instr) + dta a(tempo) + dta a(skoncz) + dta a(przer) + dta a(kont) + dta a(inic) + +tab2 dta a(stop) + dta a(jump) + dta a(up) + dta a(down) + dta a(temp) + dta a(rep) + dta a(break) + +tab3 dta a(tab5) + dta a(tab6) + dta a(tab7) + +tab4 dta b($80),b($a0) + dta b($20),b($40) + +tab5 dta b($ff),b($f1),b($e4),b($d7) + dta b($cb),b($c0),b($b5),b($aa) + dta b($a1),b($98),b($8f),b($87) + dta b($7f),b($78),b($72),b($6b) + dta b($65),b($5f),b($5a),b($55) + dta b($50),b($4b),b($47),b($43) + dta b($3f),b($3c),b($38),b($35) + dta b($32),b($2f),b($2c),b($2a) + dta b($27),b($25),b($23),b($21) + dta b($1f),b($1d),b($1c),b($1a) + dta b($18),b($17),b($16),b($14) + dta b($13),b($12),b($11),b($10) + dta b($0f),b($0e),b($0d),b($0c) + dta b($0b),b($0a),b($09),b($08) + dta b($07),b($06),b($05),b($04) + dta b($03),b($02),b($01),b($00) + dta b($00) + +tab6 dta b($00),b($00),b($00),b($00) + dta b($f2),b($e9),b($da),b($ce) + dta b($bf),b($b6),b($aa),b($a1) + dta b($98),b($8f),b($89),b($80) + dta b($7a),b($71),b($6b),b($65) + dta b($5f),b($00),b($56),b($50) + dta b($67),b($60),b($5a),b($55) + dta b($51),b($4c),b($48),b($43) + dta b($3f),b($3d),b($39),b($34) + dta b($33),b($39),b($2d),b($2a) + dta b($28),b($25),b($24),b($21) + dta b($1f),b($1e),b($00),b($00) + dta b($0f),b($0e),b($0d),b($0c) + dta b($0b),b($0a),b($09),b($08) + dta b($07),b($06),b($05),b($04) + dta b($03),b($02),b($01),b($00) + dta b($00) + +tab7 dta a($b38),a($a8c),a($a00),a($96a) + dta a($8e8),a($86a),a($7ef),a($780) + dta a($708),a($6ae),a($646),a($5e6) + dta a($595),a($541),a($4f6),a($4b0) + dta a($46e),a($430),a($3f6),a($3bb) + dta a($384),a($352),a($322),a($2f4) + dta a($2c8),a($2a0),a($27a),a($255) + dta a($234),a($214),a($1f5),a($1d8) + dta a($1bd),a($1a4),a($18d),a($177) + dta a($160),a($14e),a($138),a($127) + dta a($115),a($106),a($0f7),a($0e8) + dta a($0db),a($0cf),a($0c3),a($0b8) + dta a($0ac),a($0a2),a($09a),a($090) + dta a($088),a($07f),a($078),a($070) + dta a($06a),a($064),a($05e),a($057) + dta a($052),a($032),a($00a) + +tab8 dta b($00),b($01),b($02),b($83) + dta b($00),b($01),b($02),b($03) + dta b($01),b($00),b($02),b($83) + dta b($01),b($00),b($02),b($03) + dta b($01),b($02),b($80),b($03) + +tab9 dta b($80),b($40),b($20),b($10) + dta b($08),b($04),b($02),b($01) + +tab10 dta b(3),b(3),b(3),b(3) + dta b(7),b($b),b($f),b($13) + +*--- koniec + + end Index: apps/plugins/asap/players/rmt.asx =================================================================== --- apps/plugins/asap/players/rmt.asx (revision 0) +++ apps/plugins/asap/players/rmt.asx (revision 0) @@ -0,0 +1,1326 @@ +;* +;* Raster Music Tracker, RMT Atari routine version 1.20051226 +;* (c) Radek Sterba, Raster/C.P.U., 2002 - 2005 +;* http://raster.atari.org +;* +;* Warnings: +;* +;* 1. RMT player routine needs 19 itself reserved bytes in zero page (no accessed +;* from any other routines) as well as cca 1KB of memory before the "PLAYER" +;* address for frequency tables and functionary variables. It's: +;* a) from PLAYER-$400 to PLAYER for stereo RMTplayer +;* b) from PLAYER-$380 to PLAYER for mono RMTplayer +;* +;* 2. RMT player routine MUST (!!!) be compiled from the begin of the memory page. +;* i.e. "PLAYER" address can be $..00 only! +;* +;* 3. Because of RMTplayer provides a lot of effects, it spent a lot of CPU time. +;* +;* STEREOMODE equ 0 ;0 => compile RMTplayer for 4 tracks mono +;* ;1 => compile RMTplayer for 8 tracks stereo +;* ;2 => compile RMTplayer for 4 tracks stereo L1 R2 R3 L4 +;* ;3 => compile RMTplayer for 4 tracks stereo L1 L2 R3 R4 +;* +PLAYER equ $0600 +;* + IFT STEREOMODE==1 +TRACKS equ 8 + ELS +TRACKS equ 4 + EIF +;* +;* RMT FEATures definitions +;* For optimizations of RMT player routine to concrete RMT modul only! +;* --------BEGIN-------- +FEAT_INSTRSPEED equ 0 ;* cca 21 or 5 bytes +FEAT_CONSTANTSPEED equ 0 ;* cca 28 bytes +;* VARIOUS COMMANDS +FEAT_COMMAND1 equ 1 ;* cca 8 bytes +FEAT_COMMAND2 equ 1 ;* cca 20 bytes (+save 1 address in zero page) and quicker whole RMT routine +FEAT_COMMAND3 equ 1 ;* cca 12 bytes +FEAT_COMMAND4 equ 1 ;* cca 15 bytes +FEAT_COMMAND5 equ 1 ;* cca 67 bytes +FEAT_COMMAND6 equ 1 ;* cca 15 bytes +;* COMMAND7 SETNOTE (i.e. command 7 with parameter != $80) +FEAT_COMMAND7SETNOTE equ 1 ;* cca 12 bytes +;* COMMAND7 VOLUMEONLY (i.e. command 7 with parameter == $80) +FEAT_COMMAND7VOLUMEONLY equ 1 ;* cca 74 bytes +;* PORTAMENTO +FEAT_PORTAMENTO equ 1 ;* cca 138 bytes and quicker whole RMT routine +;* FILTER +FEAT_FILTER equ 1 ;* cca 179 bytes and quicker whole RMT routine +FEAT_FILTERG0L equ 1 ;* (cca 38 bytes for each) +FEAT_FILTERG1L equ 1 +FEAT_FILTERG0R equ 1 +FEAT_FILTERG1R equ 1 +;* BASS16B (i.e. distortion value 6) +FEAT_BASS16 equ 1 ;* cca 194 bytes +128bytes freq table and quicker whole RMT routine +FEAT_BASS16G1L equ 1 ;* (cca 47 bytes for each) +FEAT_BASS16G3L equ 1 +FEAT_BASS16G1R equ 1 +FEAT_BASS16G3R equ 1 +;* VOLUME ONLY for particular generators +FEAT_VOLUMEONLYG0L equ 1 ;* (cca 7 bytes for each) +FEAT_VOLUMEONLYG2L equ 1 +FEAT_VOLUMEONLYG3L equ 1 +FEAT_VOLUMEONLYG0R equ 1 +FEAT_VOLUMEONLYG2R equ 1 +FEAT_VOLUMEONLYG3R equ 1 +;* TABLE TYPE (i.e. TABLETYPE=1) +FEAT_TABLETYPE equ 1 ;* cca 53 bytes and quicker whole RMT routine +;* TABLE MODE (i.e. TABLEMODE=1) +FEAT_TABLEMODE equ 1 ;* cca 16 bytes and quicker whole RMT routine +;* TABLE GO (i.e. TGO is nonzero value) +FEAT_TABLEGO equ 1 ;* cca 6 bytes and quicker whole RMT routine +;* AUDCTLMANUALSET (i.e. any MANUAL AUDCTL setting is nonzero value) +FEAT_AUDCTLMANUALSET equ 1 ;* cca 27 bytes and quicker whole RMT routine +;* VOLUME MINIMUM (i.e. VMIN is nonzero value) +FEAT_VOLUMEMIN equ 1 ;* cca 12 bytes and quicker whole RMT routine +;* --------END-------- + +;* +;* RMT ZeroPage addresses + org 203 +p_tis +p_instrstable org *+2 +p_trackslbstable org *+2 +p_trackshbstable org *+2 +p_song org *+2 +ns org *+2 +nr org *+2 +nt org *+2 +reg1 org *+1 +reg2 org *+1 +reg3 org *+1 +tmp org *+1 + IFT FEAT_COMMAND2 +frqaddcmd2 org *+1 + EIF + IFT TRACKS>4 + org PLAYER-$400 + ELS + org PLAYER-$380 + EIF +track_variables +trackn_db org *+TRACKS +trackn_hb org *+TRACKS +trackn_idx org *+TRACKS +trackn_pause org *+TRACKS +trackn_note org *+TRACKS +trackn_volume org *+TRACKS +trackn_distor org *+TRACKS +trackn_shiftfrq org *+TRACKS + IFT FEAT_PORTAMENTO +trackn_portafrqc org *+TRACKS +trackn_portafrqa org *+TRACKS +trackn_portaspeed org *+TRACKS +trackn_portaspeeda org *+TRACKS +trackn_portadepth org *+TRACKS + EIF +trackn_instrx2 org *+TRACKS +trackn_instrdb org *+TRACKS +trackn_instrhb org *+TRACKS +trackn_instridx org *+TRACKS +trackn_instrlen org *+TRACKS +trackn_instrlop org *+TRACKS +trackn_instrreachend org *+TRACKS +trackn_volumeslidedepth org *+TRACKS +trackn_volumeslidevalue org *+TRACKS + IFT FEAT_VOLUMEMIN +trackn_volumemin org *+TRACKS + EIF +trackn_effdelay org *+TRACKS +trackn_effvibratoa org *+TRACKS +trackn_effvibratobeg org *+TRACKS +trackn_effvibratoend org *+TRACKS +trackn_effshift org *+TRACKS +trackn_tabletypespeed org *+TRACKS + IFT FEAT_TABLEMODE +trackn_tablemode org *+TRACKS + EIF +trackn_tablenote org *+TRACKS +trackn_tablea org *+TRACKS +trackn_tableend org *+TRACKS + IFT FEAT_TABLEGO +trackn_tablelop org *+TRACKS + EIF +trackn_tablespeeda org *+TRACKS +trackn_command org *+TRACKS + IFT FEAT_BASS16 +trackn_outnote org *+TRACKS + EIF + IFT FEAT_FILTER +trackn_filter org *+TRACKS + EIF +trackn_audf org *+TRACKS +trackn_audc org *+TRACKS + IFT FEAT_AUDCTLMANUALSET +trackn_audctl org *+TRACKS + EIF + IFT FEAT_CONSTANTSPEED==0 +v_speed org *+1 + EIF +v_aspeed org *+1 + IFT FEAT_INSTRSPEED==0||FEAT_INSTRSPEED>1 +v_ainstrspeed org *+1 + EIF +v_abeat org *+1 +track_endvariables + org PLAYER-$100-$140-$30 +INSTRPAR equ 12 +tabbeganddistor + dta frqtabpure-frqtab,$00 + dta frqtabpure-frqtab,$20 + dta frqtabpure-frqtab,$40 + dta frqtabbass1-frqtab,$c0 + dta frqtabpure-frqtab,$80 + dta frqtabpure-frqtab,$a0 + dta frqtabbass1-frqtab,$c0 + dta frqtabbass2-frqtab,$c0 +vibtabbeg dta 0,vib1-vib0,vib2-vib0,vib3-vib0,vibx-vib0 +vib0 dta 0 +vib1 dta 1,-1,-1,1 +vib2 dta 1,0,-1,-1,0,1 +vib3 dta 1,1,0,-1,-1,-1,-1,0,1,1 +vibx +:PLAYER-$100-$140-* dta 0 +; org PLAYER-$100-$140 + IFT FEAT_BASS16 +frqtabbasslo + dta $F2,$33,$96,$E2,$38,$8C,$00,$6A,$E8,$6A,$EF,$80,$08,$AE,$46,$E6 + dta $95,$41,$F6,$B0,$6E,$30,$F6,$BB,$84,$52,$22,$F4,$C8,$A0,$7A,$55 + dta $34,$14,$F5,$D8,$BD,$A4,$8D,$77,$60,$4E,$38,$27,$15,$06,$F7,$E8 + dta $DB,$CF,$C3,$B8,$AC,$A2,$9A,$90,$88,$7F,$78,$70,$6A,$64,$5E,$00 + EIF + org PLAYER-$100-$100 +frqtab + ERT [255 + ldy #0 + tya +ri0 sta track_variables,y + sta track_endvariables-$100,y + iny + bne ri0 + ELS + ldy #track_endvariables-track_variables + lda #0 +ri0 sta track_variables-1,y + dey + bne ri0 + EIF + ldy #4 + lda (ns),y + sta v_maxtracklen + iny + IFT FEAT_CONSTANTSPEED==0 + lda (ns),y + sta v_speed + EIF + IFT FEAT_INSTRSPEED==0 + iny + lda (ns),y + sta v_instrspeed + sta v_ainstrspeed + ELI FEAT_INSTRSPEED>1 + lda #FEAT_INSTRSPEED + sta v_ainstrspeed + EIF + ldy #8 +ri1 lda (ns),y + sta p_tis-8,y + iny + cpy #8+8 + bne ri1 + pla + pha + IFT TRACKS>4 + asl @ + asl @ + asl @ + clc + adc p_song + sta p_song + pla + php + and #$e0 + asl @ + rol @ + rol @ + rol @ + ELS + asl @ + asl @ + clc + adc p_song + sta p_song + pla + php + and #$c0 + asl @ + rol @ + rol @ + EIF + plp + adc p_song+1 + sta p_song+1 + jsr GetSongLineTrackLineInitOfNewSetInstrumentsOnlyRmtp3 +rmt_silence + IFT STEREOMODE>0 + lda #0 + sta $d208 + sta $d218 + ldy #3 + sty $d20f + sty $d21f + ldy #8 +si1 sta $d200,y + sta $d210,y + dey + bpl si1 + ELS + lda #0 + sta $d208 + ldy #3 + sty $d20f + ldy #8 +si1 sta $d200,y + dey + bpl si1 + EIF + IFT FEAT_INSTRSPEED==0 + lda v_instrspeed + ELS + lda #FEAT_INSTRSPEED + EIF + rts +GetSongLineTrackLineInitOfNewSetInstrumentsOnlyRmtp3 +GetSongLine + ldx #0 + stx v_abeat +nn0 +nn1 txa + tay + lda (p_song),y + cmp #$fe + bcs nn2 + tay + lda (p_trackslbstable),y + sta trackn_db,x + lda (p_trackshbstable),y +nn1a sta trackn_hb,x + lda #0 + sta trackn_idx,x + lda #1 +nn1a2 sta trackn_pause,x + lda #$80 + sta trackn_instrx2,x + inx +xtracks01 cpx #TRACKS + bne nn1 + lda p_song + clc +xtracks02 adc #TRACKS + sta p_song + bcc GetTrackLine + inc p_song+1 +nn1b + jmp GetTrackLine +nn2 + beq nn3 +nn2a + lda #0 + beq nn1a2 +nn3 + ldy #2 + lda (p_song),y + tax + iny + lda (p_song),y + sta p_song+1 + stx p_song + ldx #0 + beq nn0 +GetTrackLine +oo0 +oo0a + IFT FEAT_CONSTANTSPEED==0 + lda v_speed + sta v_bspeed + EIF + ldx #-1 +oo1 + inx + dec trackn_pause,x + bne oo1x +oo1b + lda trackn_db,x + sta ns + lda trackn_hb,x + sta ns+1 +oo1i + ldy trackn_idx,x + inc trackn_idx,x + lda (ns),y + sta reg1 + and #$3f + cmp #61 + beq oo1a + bcs oo2 + sta trackn_note,x + IFT FEAT_BASS16 + sta trackn_outnote,x + EIF + iny + lda (ns),y + lsr @ + and #$3f*2 + sta trackn_instrx2,x +oo1a + lda #1 + sta trackn_pause,x + ldy trackn_idx,x + inc trackn_idx,x + lda (ns),y + lsr @ + ror reg1 + lsr @ + ror reg1 + lda reg1 + and #$f0 + sta trackn_volume,x +oo1x +xtracks03sub1 cpx #TRACKS-1 + bne oo1 + IFT FEAT_CONSTANTSPEED==0 + lda #$ff +v_bspeed equ *-1 + sta v_speed + ELS + lda #FEAT_CONSTANTSPEED + EIF + sta v_aspeed + jmp InitOfNewSetInstrumentsOnly +oo2 + cmp #63 + beq oo63 + lda reg1 + and #$c0 + beq oo62_b + asl @ + rol @ + rol @ + sta trackn_pause,x + jmp oo1x +oo62_b + iny + lda (ns),y + sta trackn_pause,x + inc trackn_idx,x + jmp oo1x +oo63 + lda reg1 + IFT FEAT_CONSTANTSPEED==0 + bmi oo63_1X + iny + lda (ns),y + sta v_bspeed + inc trackn_idx,x + jmp oo1i +oo63_1X + EIF + cmp #255 + beq oo63_11 + iny + lda (ns),y + sta trackn_idx,x + jmp oo1i +oo63_11 + jmp GetSongLine +p2xrmtp3 jmp rmt_p3 +p2x0 dex + bmi p2xrmtp3 +InitOfNewSetInstrumentsOnly +p2x1 ldy trackn_instrx2,x + bmi p2x0 +SetUpInstrumentY2 + lda (p_instrstable),y + sta trackn_instrdb,x + sta nt + iny + lda (p_instrstable),y + sta trackn_instrhb,x + sta nt+1 + IFT FEAT_FILTER + lda #1 + sta trackn_filter,x + EIF + IFT FEAT_TABLEGO + IFT FEAT_FILTER + tay + ELS + ldy #1 + EIF + lda (nt),y + sta trackn_tablelop,x + iny + ELS + ldy #2 + EIF + lda (nt),y + sta trackn_instrlen,x + iny + lda (nt),y + sta trackn_instrlop,x + iny + lda (nt),y + sta trackn_tabletypespeed,x + IFT FEAT_TABLETYPE||FEAT_TABLEMODE + and #$3f + EIF + sta trackn_tablespeeda,x + IFT FEAT_TABLEMODE + lda (nt),y + and #$40 + sta trackn_tablemode,x + EIF + IFT FEAT_AUDCTLMANUALSET + iny + lda (nt),y + sta trackn_audctl,x + iny + ELS + ldy #6 + EIF + lda (nt),y + sta trackn_volumeslidedepth,x + IFT FEAT_VOLUMEMIN + iny + lda (nt),y + sta trackn_volumemin,x + iny + ELS + ldy #8 + EIF + lda (nt),y + sta trackn_effdelay,x + iny + lda (nt),y + tay + lda vibtabbeg,y + sta trackn_effvibratoa,x + sta trackn_effvibratobeg,x + lda vibtabbeg+1,y + sta trackn_effvibratoend,x + ldy #10 + lda (nt),y + sta trackn_effshift,x + lda #128 + sta trackn_volumeslidevalue,x + sta trackn_instrx2,x + asl @ + sta trackn_instrreachend,x + sta trackn_shiftfrq,x + tay + lda (nt),y + sta trackn_tableend,x + adc #0 + sta trackn_instridx,x + lda #INSTRPAR + sta trackn_tablea,x + tay + lda (nt),y + sta trackn_tablenote,x +xata_rtshere + jmp p2x0 +rmt_play +rmt_p0 + jsr SetPokey +rmt_p1 + IFT FEAT_INSTRSPEED==0||FEAT_INSTRSPEED>1 + dec v_ainstrspeed + bne rmt_p3 + EIF + IFT FEAT_INSTRSPEED==0 + lda #$ff +v_instrspeed equ *-1 + sta v_ainstrspeed + ELI FEAT_INSTRSPEED>1 + lda #FEAT_INSTRSPEED + sta v_ainstrspeed + EIF +rmt_p2 + dec v_aspeed + bne rmt_p3 + inc v_abeat + lda v_abeat + cmp #$ff +v_maxtracklen equ *-1 + beq p2o3 + jmp GetTrackLine +p2o3 + jmp GetSongLineTrackLineInitOfNewSetInstrumentsOnlyRmtp3 +go_ppnext jmp ppnext +rmt_p3 + lda #>frqtab + sta nr+1 +xtracks05sub1 ldx #TRACKS-1 +pp1 + lda trackn_instrhb,x + beq go_ppnext + sta ns+1 + lda trackn_instrdb,x + sta ns + ldy trackn_instridx,x + lda (ns),y + sta reg1 + iny + lda (ns),y + sta reg2 + iny + lda (ns),y + sta reg3 + iny + tya + cmp trackn_instrlen,x + bcc pp2 + beq pp2 + lda #$80 + sta trackn_instrreachend,x +pp1b + lda trackn_instrlop,x +pp2 sta trackn_instridx,x + lda reg1 + IFT TRACKS>4 + cpx #4 + bcc pp2s + lsr @ + lsr @ + lsr @ + lsr @ +pp2s + EIF + and #$0f + ora trackn_volume,x + tay + lda volumetab,y + sta tmp + lda reg2 + and #$0e + tay + lda tabbeganddistor,y + sta nr + lda tmp + ora tabbeganddistor+1,y + sta trackn_audc,x +InstrumentsEffects + lda trackn_effdelay,x + beq ei2 + cmp #1 + bne ei1 + lda trackn_shiftfrq,x + clc + adc trackn_effshift,x + clc + ldy trackn_effvibratoa,x + adc vib0,y + sta trackn_shiftfrq,x + iny + tya + cmp trackn_effvibratoend,x + bne ei1a + lda trackn_effvibratobeg,x +ei1a + sta trackn_effvibratoa,x + jmp ei2 +ei1 + dec trackn_effdelay,x +ei2 + ldy trackn_tableend,x + cpy #INSTRPAR+1 + bcc ei3 + lda trackn_tablespeeda,x + bpl ei2f +ei2c + tya + cmp trackn_tablea,x + bne ei2c2 + IFT FEAT_TABLEGO + lda trackn_tablelop,x + ELS + lda #INSTRPAR + EIF + sta trackn_tablea,x + bne ei2a +ei2c2 + inc trackn_tablea,x +ei2a + lda trackn_instrdb,x + sta nt + lda trackn_instrhb,x + sta nt+1 + ldy trackn_tablea,x + lda (nt),y + IFT FEAT_TABLEMODE + ldy trackn_tablemode,x + beq ei2e + clc + adc trackn_tablenote,x +ei2e + EIF + sta trackn_tablenote,x + lda trackn_tabletypespeed,x + IFT FEAT_TABLETYPE||FEAT_TABLEMODE + and #$3f + EIF +ei2f + sec + sbc #1 + sta trackn_tablespeeda,x +ei3 + lda trackn_instrreachend,x + bpl ei4 + lda trackn_volume,x + beq ei4 + IFT FEAT_VOLUMEMIN + cmp trackn_volumemin,x + beq ei4 + bcc ei4 + EIF + tay + lda trackn_volumeslidevalue,x + clc + adc trackn_volumeslidedepth,x + sta trackn_volumeslidevalue,x + bcc ei4 + tya + sbc #16 + sta trackn_volume,x +ei4 + IFT FEAT_COMMAND2 + lda #0 + sta frqaddcmd2 + EIF + lda reg2 + sta trackn_command,x + and #$70 + lsr @ + lsr @ + sta jmx+1 +jmx bcc * + jmp cmd0 + nop + jmp cmd1 + nop + jmp cmd2 + nop + jmp cmd3 + nop + jmp cmd4 + nop + jmp cmd5 + nop + jmp cmd6 + nop + jmp cmd7 +cmd1 + IFT FEAT_COMMAND1 + lda reg3 + jmp cmd0c + EIF +cmd2 + IFT FEAT_COMMAND2 + lda reg3 + sta frqaddcmd2 + lda trackn_note,x + jmp cmd0a + EIF +cmd3 + IFT FEAT_COMMAND3 + lda trackn_note,x + clc + adc reg3 + sta trackn_note,x + jmp cmd0a + EIF +cmd4 + IFT FEAT_COMMAND4 + lda trackn_shiftfrq,x + clc + adc reg3 + sta trackn_shiftfrq,x + lda trackn_note,x + jmp cmd0a + EIF +cmd5 + IFT FEAT_COMMAND5&&FEAT_PORTAMENTO + IFT FEAT_TABLETYPE + lda trackn_tabletypespeed,x + bpl cmd5a1 + ldy trackn_note,x + lda (nr),y + clc + adc trackn_tablenote,x + jmp cmd5ax + EIF +cmd5a1 + lda trackn_note,x + clc + adc trackn_tablenote,x + cmp #61 + bcc cmd5a2 + lda #63 +cmd5a2 + tay + lda (nr),y +cmd5ax + sta trackn_portafrqc,x + ldy reg3 + bne cmd5a + sta trackn_portafrqa,x +cmd5a + tya + lsr @ + lsr @ + lsr @ + lsr @ + sta trackn_portaspeed,x + sta trackn_portaspeeda,x + lda reg3 + and #$0f + sta trackn_portadepth,x + lda trackn_note,x + jmp cmd0a + ELI FEAT_COMMAND5 + jmp pp9 + EIF +cmd6 + IFT FEAT_COMMAND6&&FEAT_FILTER + lda reg3 + clc + adc trackn_filter,x + sta trackn_filter,x + lda trackn_note,x + jmp cmd0a + ELI FEAT_COMMAND6 + jmp pp9 + EIF +cmd7 + IFT FEAT_COMMAND7SETNOTE||FEAT_COMMAND7VOLUMEONLY + IFT FEAT_COMMAND7SETNOTE + lda reg3 + IFT FEAT_COMMAND7VOLUMEONLY + cmp #$80 + beq cmd7a + EIF + sta trackn_note,x + jmp cmd0a + EIF + IFT FEAT_COMMAND7VOLUMEONLY +cmd7a + lda trackn_audc,x + ora #$f0 + sta trackn_audc,x + lda trackn_note,x + jmp cmd0a + EIF + EIF +cmd0 + lda trackn_note,x + clc + adc reg3 +cmd0a + IFT FEAT_TABLETYPE + ldy trackn_tabletypespeed,x + bmi cmd0b + EIF + clc + adc trackn_tablenote,x + cmp #61 + bcc cmd0a1 + lda #0 + sta trackn_audc,x + lda #63 +cmd0a1 + IFT FEAT_BASS16 + sta trackn_outnote,x + EIF + tay + lda (nr),y + clc + adc trackn_shiftfrq,x + IFT FEAT_COMMAND2 + clc + adc frqaddcmd2 + EIF + IFT FEAT_TABLETYPE + jmp cmd0c +cmd0b + cmp #61 + bcc cmd0b1 + lda #0 + sta trackn_audc,x + lda #63 +cmd0b1 + tay + lda trackn_shiftfrq,x + clc + adc trackn_tablenote,x + clc + adc (nr),y + IFT FEAT_COMMAND2 + clc + adc frqaddcmd2 + EIF + EIF +cmd0c + sta trackn_audf,x +pp9 + IFT FEAT_PORTAMENTO + lda trackn_portaspeeda,x + beq pp10 + dec trackn_portaspeeda,x + bne pp10 + lda trackn_portaspeed,x + sta trackn_portaspeeda,x + lda trackn_portafrqa,x + cmp trackn_portafrqc,x + beq pp10 + bcs pps1 + adc trackn_portadepth,x + bcs pps8 + cmp trackn_portafrqc,x + bcs pps8 + jmp pps9 +pps1 + sbc trackn_portadepth,x + bcc pps8 + cmp trackn_portafrqc,x + bcs pps9 +pps8 + lda trackn_portafrqc,x +pps9 + sta trackn_portafrqa,x +pp10 + lda reg2 + and #$01 + beq pp11 + lda trackn_portafrqa,x + clc + adc trackn_shiftfrq,x + sta trackn_audf,x +pp11 + EIF +ppnext + dex + bmi rmt_p4 + jmp pp1 +rmt_p4 + IFT FEAT_AUDCTLMANUALSET + lda trackn_audctl+0 + ora trackn_audctl+1 + ora trackn_audctl+2 + ora trackn_audctl+3 + tax + ELS + ldx #0 + EIF +qq1 + stx v_audctl + IFT FEAT_FILTER + IFT FEAT_FILTERG0L + lda trackn_command+0 + bpl qq2 + lda trackn_audc+0 + and #$0f + beq qq2 + lda trackn_audf+0 + clc + adc trackn_filter+0 + sta trackn_audf+2 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG2L + lda trackn_audc+2 + and #$10 + bne qq1a + EIF + lda #0 + sta trackn_audc+2 +qq1a + txa + ora #4 + tax + EIF +qq2 + IFT FEAT_FILTERG1L + lda trackn_command+1 + bpl qq3 + lda trackn_audc+1 + and #$0f + beq qq3 + lda trackn_audf+1 + clc + adc trackn_filter+1 + sta trackn_audf+3 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG3L + lda trackn_audc+3 + and #$10 + bne qq2a + EIF + lda #0 + sta trackn_audc+3 +qq2a + txa + ora #2 + tax + EIF +qq3 + IFT FEAT_FILTERG0L||FEAT_FILTERG1L + cpx v_audctl + bne qq5 + EIF + EIF + IFT FEAT_BASS16 + IFT FEAT_BASS16G1L + lda trackn_command+1 + and #$0e + cmp #6 + bne qq4 + lda trackn_audc+1 + and #$0f + beq qq4 + ldy trackn_outnote+1 + lda frqtabbasslo,y + sta trackn_audf+0 + lda frqtabbasshi,y + sta trackn_audf+1 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG0L + lda trackn_audc+0 + and #$10 + bne qq3a + EIF + lda #0 + sta trackn_audc+0 +qq3a + txa + ora #$50 + tax + EIF +qq4 + IFT FEAT_BASS16G3L + lda trackn_command+3 + and #$0e + cmp #6 + bne qq5 + lda trackn_audc+3 + and #$0f + beq qq5 + ldy trackn_outnote+3 + lda frqtabbasslo,y + sta trackn_audf+2 + lda frqtabbasshi,y + sta trackn_audf+3 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG2L + lda trackn_audc+2 + and #$10 + bne qq4a + EIF + lda #0 + sta trackn_audc+2 +qq4a + txa + ora #$28 + tax + EIF + EIF +qq5 + stx v_audctl + IFT TRACKS>4 + IFT FEAT_AUDCTLMANUALSET + lda trackn_audctl+4 + ora trackn_audctl+5 + ora trackn_audctl+6 + ora trackn_audctl+7 + tax + ELS + ldx #0 + EIF + stx v_audctl2 + IFT FEAT_FILTER + IFT FEAT_FILTERG0R + lda trackn_command+0+4 + bpl qs2 + lda trackn_audc+0+4 + and #$0f + beq qs2 + lda trackn_audf+0+4 + clc + adc trackn_filter+0+4 + sta trackn_audf+2+4 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG2R + lda trackn_audc+2+4 + and #$10 + bne qs1a + EIF + lda #0 + sta trackn_audc+2+4 +qs1a + txa + ora #4 + tax + EIF +qs2 + IFT FEAT_FILTERG1R + lda trackn_command+1+4 + bpl qs3 + lda trackn_audc+1+4 + and #$0f + beq qs3 + lda trackn_audf+1+4 + clc + adc trackn_filter+1+4 + sta trackn_audf+3+4 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG3R + lda trackn_audc+3+4 + and #$10 + bne qs2a + EIF + lda #0 + sta trackn_audc+3+4 +qs2a + txa + ora #2 + tax + EIF +qs3 + IFT FEAT_FILTERG0R||FEAT_FILTERG1R + cpx v_audctl2 + bne qs5 + EIF + EIF + IFT FEAT_BASS16 + IFT FEAT_BASS16G1R + lda trackn_command+1+4 + and #$0e + cmp #6 + bne qs4 + lda trackn_audc+1+4 + and #$0f + beq qs4 + ldy trackn_outnote+1+4 + lda frqtabbasslo,y + sta trackn_audf+0+4 + lda frqtabbasshi,y + sta trackn_audf+1+4 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG0R + lda trackn_audc+0+4 + and #$10 + bne qs3a + EIF + lda #0 + sta trackn_audc+0+4 +qs3a + txa + ora #$50 + tax + EIF +qs4 + IFT FEAT_BASS16G3R + lda trackn_command+3+4 + and #$0e + cmp #6 + bne qs5 + lda trackn_audc+3+4 + and #$0f + beq qs5 + ldy trackn_outnote+3+4 + lda frqtabbasslo,y + sta trackn_audf+2+4 + lda frqtabbasshi,y + sta trackn_audf+3+4 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG2R + lda trackn_audc+2+4 + and #$10 + bne qs4a + EIF + lda #0 + sta trackn_audc+2+4 +qs4a + txa + ora #$28 + tax + EIF + EIF +qs5 + stx v_audctl2 + EIF +rmt_p5 + IFT FEAT_INSTRSPEED==0||FEAT_INSTRSPEED>1 + lda v_ainstrspeed + ELS + lda #1 + EIF + rts +SetPokey + IFT STEREOMODE==1 ;* L1 L2 L3 L4 R1 R2 R3 R4 + ldy #$ff +v_audctl2 equ *-1 + lda trackn_audf+0+4 + ldx trackn_audf+0 +xstastx01 sta $d210 + stx $d200 + lda trackn_audc+0+4 + ldx trackn_audc+0 +xstastx02 sta $d211 + stx $d201 + lda trackn_audf+1+4 + ldx trackn_audf+1 +xstastx03 sta $d212 + stx $d202 + lda trackn_audc+1+4 + ldx trackn_audc+1 +xstastx04 sta $d213 + stx $d203 + lda trackn_audf+2+4 + ldx trackn_audf+2 +xstastx05 sta $d214 + stx $d204 + lda trackn_audc+2+4 + ldx trackn_audc+2 +xstastx06 sta $d215 + stx $d205 + lda trackn_audf+3+4 + ldx trackn_audf+3 +xstastx07 sta $d216 + stx $d206 + lda trackn_audc+3+4 + ldx trackn_audc+3 +xstastx08 sta $d217 + stx $d207 + lda #$ff +v_audctl equ *-1 +xstysta01 sty $d218 + sta $d208 + ELI STEREOMODE==0 ;* L1 L2 L3 L4 + ldy #$ff +v_audctl equ *-1 + lda trackn_audf+0 + ldx trackn_audc+0 + sta $d200 + stx $d201 + lda trackn_audf+1 + ldx trackn_audc+1 + sta $d200+2 + stx $d201+2 + lda trackn_audf+2 + ldx trackn_audc+2 + sta $d200+4 + stx $d201+4 + lda trackn_audf+3 + ldx trackn_audc+3 + sta $d200+6 + stx $d201+6 + sty $d208 + ELI STEREOMODE==2 ;* L1 R2 R3 L4 + ldy #$ff +v_audctl equ *-1 + lda trackn_audf+0 + ldx trackn_audc+0 + sta $d200 + stx $d201 + sta $d210 + lda trackn_audf+1 + ldx trackn_audc+1 + sta $d210+2 + stx $d211+2 + lda trackn_audf+2 + ldx trackn_audc+2 + sta $d210+4 + stx $d211+4 + sta $d200+4 + lda trackn_audf+3 + ldx trackn_audc+3 + sta $d200+6 + stx $d201+6 + sta $d210+6 + sty $d218 + sty $d208 + ELI STEREOMODE==3 ;* L1 L2 R3 R4 + ldy #$ff +v_audctl equ *-1 + lda trackn_audf+0 + ldx trackn_audc+0 + sta $d200 + stx $d201 + lda trackn_audf+1 + ldx trackn_audc+1 + sta $d200+2 + stx $d201+2 + lda trackn_audf+2 + ldx trackn_audc+2 + sta $d210+4 + stx $d211+4 + sta $d200+4 + lda trackn_audf+3 + ldx trackn_audc+3 + sta $d210+6 + stx $d211+6 + sta $d200+6 + sty $d218 + sty $d208 + EIF + rts +RMTEND Index: apps/plugins/asap/players/tm2.asx =================================================================== --- apps/plugins/asap/players/tm2.asx (revision 0) +++ apps/plugins/asap/players/tm2.asx (revision 0) @@ -0,0 +1,1551 @@ +;------------------- +; TMC 2.00 Player +;------------------ + +player equ $200 +normal equ 1 ; change to 0 for short version + + org player + +addr equ $fa +byte equ $fc +bajt equ $fd +filter equ $fe +maxvol equ $ff + +; some tables on start (to avoid page breaking) + +voltab dta d' ' + dta d' !!!!!!!!' + dta d' !!!!!!!!""""' + dta d' !!!!!"""""###' + dta d' !!!!""""####$$' + dta d' !!!"""###$$$%%' + dta d' !!"""##$$$%%&&' + dta d' !!""##$$%%&&''''' + dta d' !!""##$$%%&&''''(' + dta d' !!""#$$%%&''''(()' + dta d' !!"##$%%&''''())*' + dta d' !!"#$$%&''''()**+' + dta d' !""#$%&&''()**+,' + dta d' !"##$%&''()**+,-' + dta d' !"#$%&''''()*+,-.' + dta d' !"#$%&''()*+,-./' + +frqtab dta 0,$f1,$e4,$d7 + dta $cb,$c0,$b5,$aa + dta $a1,$98,$8f,$87 + dta $7f,$78,$72,$6b + dta $65,$5f,$5a,$55 + dta $50,$4b,$47,$43 + dta $3f,$3c,$38,$35 + dta $32,$2f,$2c,$2a + dta $27,$25,$23,$21 + dta $1f,$1d,$1c,$1a + dta $18,$17,$16,$14 + dta $13,$12,$11,$10 + dta 15,14,13,12 + dta 11,10,9,8 + dta 7,6,5,4 + dta 3,2,1,0 + + dta 0,$f2,$e9,$da + dta $ce,$bf,$b6,$aa + dta $a1,$98,$8f,$89 + dta $80,$7a,$71,$6b + dta $65,$5f,$5c,$56 + dta $50,$4d,$47,$44 + dta $3e,$3c,$38,$35 + dta $32,$2f,$2d,$2a + dta $28,$25,$23,$21 + dta $1f,$1d,$1c,$1a + dta $18,$17,$16,$14 + dta $13,$12,$11,$10 + dta 15,14,13,12 + dta 11,10,9,8 + dta 7,6,5,4 + dta 3,2,1,0 + + dta 0,$ff,$f1,$e4 + dta $d8,$ca,$c0,$b5 + dta $ab,$a2,$99,$8e + dta $87,$7f,$79,$73 + dta $70,$66,$61,$5a + dta $55,$52,$4b,$48 + dta $43,$3f,$3c,$39 + dta $37,$33,$30,$2d + dta $2a,$28,$25,$24 + dta $21,$1f,$1e,$1c + dta $1b,$19,$17,$16 + dta $15,$13,$12,$11 + dta $10,15,14,13 + dta 12,11,10,9 + dta 8,7,6,5 + dta 4,3,2,1 + + dta 0,$f3,$e6,$d9 + dta $cc,$c1,$b5,$ad + dta $a2,$99,$90,$88 + dta $80,$79,$72,$6c + dta $66,$60,$5b,$55 + dta $51,$4c,$48,$44 + dta $40,$3c,$39,$35 + dta $32,$2f,$2d,$2a + dta $28,$25,$23,$21 + dta $1f,$1d,$1c,$1a + dta $18,$17,$16,$14 + dta $13,$12,$11,$10 + dta 15,14,13,12 + dta 11,10,9,8 + dta 7,6,5,4 + dta 3,2,1,0 + +basslo dta l($be2,$b38,$a8c,$a00) + dta l($96a,$8e8,$86a,$7ef) + dta l($780,$708,$6ae,$646) + dta l($5e6,$595,$541,$4f6) + dta l($4b0,$46e,$430,$3f6) + dta l($3bb,$384,$352,$322) + dta l($2f4,$2c8,$2a0,$27a) + dta l($255,$234,$214,$1f5) + dta l($1d8,$1bd,$1a4,$18d) + dta l($177,$160,$14e,$138) + dta l($127,$115,$106,$0f7) + dta l($0e8,$0db,$0cf,$0c3) + dta l($0b8,$0ac,$0a2,$09a) + dta l($090,$088,$07f,$078) + dta l($070,$06a,$064,$05e) + dta l($057,$052,$032,$00a) + + dta 0,$f2,$33,$96 + dta $e2,$38,$8c,$00 + dta $6a,$e8,$6a,$ef + dta $80,$08,$ae,$46 + dta $e6,$95,$41,$f6 + dta $b0,$6e,$30,$f6 + dta $bb,$84,$52,$22 + dta $f4,$c8,$a0,$7a + dta $55,$34,$14,$f5 + dta $d8,$bd,$a4,$8d + dta $77,$60,$4e,$38 + dta $27,$15,$06,$f7 + dta $e8,$db,$cf,$c3 + dta $b8,$ac,$a2,$9a + dta $90,$88,$7f,$78 + dta $70,$6a,$64,$5e + +basshi dta h($be2,$b38,$a8c,$a00) + dta h($96a,$8e8,$86a,$7ef) + dta h($780,$708,$6ae,$646) + dta h($5e6,$595,$541,$4f6) + dta h($4b0,$46e,$430,$3f6) + dta h($3bb,$384,$352,$322) + dta h($2f4,$2c8,$2a0,$27a) + dta h($255,$234,$214,$1f5) + dta h($1d8,$1bd,$1a4,$18d) + dta h($177,$160,$14e,$138) + dta h($127,$115,$106,$0f7) + dta h($0e8,$0db,$0cf,$0c3) + dta h($0b8,$0ac,$0a2,$09a) + dta h($090,$088,$07f,$078) + dta h($070,$06a,$064,$05e) + dta h($057,$052,$032,$00a) + + dta 0,13,13,12 + dta 11,11,10,10 + dta 9,8,8,7 + dta 7,7,6,6 + dta 5,5,5,4 + dta 4,4,4,3 + dta 3,3,3,3 + dta 2,2,2,2 + dta 2,2,2,1 + dta 1,1,1,1 + dta 1,1,1,1 + dta 1,1,1,0 + dta 0,0,0,0 + dta 0,0,0,0 + dta 0,0,0,0 + dta 0,0,0,0 + +tables_len equ *-player + +; org +$300 + jmp init + jmp play + jmp sound + +; some external controls +quadro dta 1 ; 0=mono, 1-63=stereo, 64-127= RMT stereo, 128-255=quadro +pokeys dta 16 ; which data should go to which pokey (0,1,2 and 3 respectively) + dta 20 ; for stereo config: 16=first 4 tracks, 20=last 4 tracks + dta 0 ; for quadro values should be: + dta 0 ; 0=main volume from tracks 0-3, 4=main volume from tracks 4-5 + ; 8=additional volume from tracks 0-3, 12=additional volume from tracks 4-5 + ; typical: 0,4,12,8 which should sound well on pokeys 0&2 on left channel + ; and pokeys 1&3 on right channel + ; (on stereo atari these settings should also sound well) +silent dta d' ' ; which channel should be silent + +; these values are usable from the outside of player +czygrc dta 0 ; if song should be played +pozsng dta 0 ; position in song + +specialflag dta 0 ; flag triggered in song data +adrsng dta a(0) ; address of song line + +tempo dta 0 ; tempo of song +ltempo dta 0 ; counter of tempo +pozptr dta 0 ; counter of positions in patterns (64 means end of pattern) + + ift normal ; !!! + +aud1 dta 0 ; total AUDCTL of left channel +aud2 dta 0 ; and right + +voltabs equ * ; (24 bytes) + + eif ; !!! + +vol1ch dta d' ' ; volume of main channels + + ift normal ; !!! + +vol2ch dta d' ' ; volume of additional channels +volume dta d' ' ; volume of channels in stereo (taken from vol1ch and vol2ch) + +freqtabs equ * ; (24 bytes) + + eif ; !!! + +frq dta d' ' ; frequency + + ift normal ; !!! + +note dta d' ' ; actual note played on channel (taken from aktwys) +freqen dta d' ' ; frequency of channels in stereo (taken from frq) + + eif ; !!! + +; data for accesing pattern data +adrptl dta d' ' ; address of pattern data +adrpth dta d' ' ; +pozwpt dta d' ' ; index for accesing data in pattern +poddzw dta d' ' ; change of note +delay dta d' ' ; how many spaces in pattern should be skipped + +; data for accesing instrument data +czygrx dta d' ' ; if something is played on channel +adrsnl dta d' ' ; address of instrument data +adrsnh dta d' ' ; +numdzw dta d' ' ; number of instrument +wysdzw dta d' ' ; note to play +aktwys dta d' ' ; actual played note +znksz dta d' ' ; distortion +audctl dta d' ' ; AUDCTL +slupy dta d' ' ; counter for data inside instrument + +; data for specific sound effects +sndlen dta d' ' ; length of instrument +sndlop dta d' ' ; where to loop sound data +actvol dta d' ' ; volume of sounds +actvl1 dta d' ' ; actual control of main volume + + ift normal ; !!! + +actvl2 dta d' ' ; and additional volume + + eif ; !!! + +opad1 dta d' ' ; how soon the sound should fade (main volume) +opad2 dta d' ' ; and additional volume +lopad1 dta d' ' ; counters for fading +lopad2 dta d' ' ; +opadst dta d' ' ; start of fading +typ dta d' ' ; type of effect +param dta d' ' ; parameter for effect +typdat dta d' ' ; data for effect +czekaj dta d' ' ; how soon the effect should start +dtyp dta d' ' ; how often the effect should chanfe +ltyp dta d' ' ; counter for effect change +ilperm dta d' ' ; how many arpeggio sounds +aperm dta d' ' ; actual arpeggio sound +dperm dta d' ' ; how soon the arpeggio should change +lperm dta d' ' ; counter for arpeggio +kolejn dta d' ' ; order of arpeggio +sndfilter dta d' ' ; filter from sound data +mainaudctl dta d' ' ; main audctl +addaudctl dta d' ' ; additional audctl +shiftfrq dta d' ' +shiftnote dta d' ' +shiftfilter dta d' ' + +; some useful tables + + ift normal ; !!! + +przeci dta 4,5,6,7 ; which channel is the opposite (used only in stereo) + dta 0,1,2,3 + + eif ; !!! + +audtb1 dta 4,2,0,0 ; which byte in audctl has to be set to make sound "2 channel synth" + dta 4,2,0,0 +audtb2 dta 0,16,0,8 ; which byte in audctl has to be set to make sound "2 channel bass" + dta 0,16,0,8 +usedaudctl dta 4+129,$50+2+129,129,$28+129 ; bits of AUDCTL used in channel + dta 4+129,$50+2+129,129,$28+129 + +;------------------------- +; start of player program + +player_program equ * + +; new address of song line +p3 dey + lda (addr),y + sta pozsng + mvx #0 byte + asl @ + rol byte + asl @ + rol byte + asl @ + rol byte + asl @ + rol byte + adc pozsng ; clc + scc:inc byte + clc +zm0 adc #0 + sta addr + lda byte +zm1 adc #0 + sta addr+1 + jmp p1 + +; play song (call only one time per frame) +play jsr pokey + lda czygrc + beq rsound + dec ltempo + bmi p4 +rsound jmp sound+3 + +p4 dec pozptr + bne r1 + +; get new patterns from song + ldx #0 + inc pozsng + mwa adrsng addr + +p1 ldy #16 + lda (addr),y + bmi p3 + jeq stop + sta pozptr + dey + +p2 lda (addr),y + dey + sty byte + tay +zm2 lda $ffff,y + sta adrptl,x +zm3 lda $ffff,y + sta adrpth,x + lda #0 + sta delay,x + sta pozwpt,x + ldy byte + lda (addr),y + sta poddzw,x + inx + dey + bpl p2 + lda #17 + add addr + sta adrsng + lda #0 + adc addr+1 + sta adrsng+1 + +; get new data from patterns +r1 mva tempo ltempo + + ldx #7 +r2 dec delay,x + bmi r13 + +r14 dex + bpl r2 + jmp sound+3 + +r13 mva adrptl,x addr + mva adrpth,x addr+1 + + ldy pozwpt,x +r3 lda (addr),y ; get data + bne r4 + + iny ; $00: only new volume + lda (addr),y + sta actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda (addr),y + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + iny + tya + sta pozwpt,x + jmp r14 + +r4 cmp #$40 + bcs r5 + adc poddzw,x ; $01-$3f: new note with sound and maybe volume + sta wysdzw,x + iny + lda (addr),y + bpl r11 + and #$7f + sta byte + iny + lda (addr),y + sta actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda (addr),y + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + iny + tya + sta pozwpt,x + ldy byte + jsr dzwiek + jmp r14 + +r11 tay ; without volume + inc pozwpt,x + inc pozwpt,x + lda actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda actvol,x + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + jsr dzwiek + jmp r14 + +r5 cmp #$80 + bcs r6 + and #$3f ; $41-$7f: new note with volume + add poddzw,x + sta wysdzw,x + iny + lda (addr),y + sta actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda (addr),y + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + iny + tya + sta pozwpt,x + jmp r14 + +r6 bne r7 + iny ; $80: more than 15 spaces + lda (addr),y + sta delay,x + iny + tya + sta pozwpt,x + jmp r14 + +r7 cmp #$c0 + bcs r8 + and #$3f ; $81-$bf: new note + add poddzw,x + sta wysdzw,x + inc pozwpt,x + jmp r14 + +r8 cmp #$d0 + bcs r9 + iny ; $c0-$cf: new tempo + inc pozwpt,x + and #15 + sta tempo + sta ltempo + jmp r3 + +r9 cmp #$e0 ; special code + bcs r15 + mva (addr),y byte + iny + mva (addr),y bajt + iny + tya + sta pozwpt,x + lda byte + jsr specialcode + jmp r14 + +r15 cmp #$f0 ; special code with volume + bcs r12 + mva (addr),y byte + iny + mva (addr),y bajt + lda byte + jsr specialcode + ldy pozwpt,x + iny + iny + lda (addr),y + sta actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda (addr),y + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + iny + tya + sta pozwpt,x + jmp r14 + +r12 cmp #$ff + bcs r10 + sbc #$ef ; $f0-$fe: spaces-$f0 (c is clear here) + sta delay,x + inc pozwpt,x + jmp r14 + +r10 lda #$40 ; $ff: spaces till the end of pattern + sta delay,x + jmp r14 + +; main play sound loop +sound jsr pokey + ldx #7 +p5 lda czygrx,x + beq p6 + jmp graj + +grajreturn equ * + lda silent,x + beq p7 + + lda #0 ; silent channel + sta vol1ch,x + + ift normal ; !!! + + sta vol2ch,x + + eif ; !!! + + dex + bpl p5 + jmp p8 + +p7 ldy bajt + lda frqtab,y + add byte + sta frq,x + tya + sta aktwys,x + + lda audctl,x + and audtb2,x + beq p11 + lda bajt ; 2 channel bass + and #$7f + tay + lda basslo,y + add byte + sta frq-1,x + lda basshi,y + adc #0 + sta frq,x + lda #0 + sta vol1ch-1,x + ldy przeci,x + sta vol2ch-1,y + dex + dex + bpl p5 + jmp p8 + +p11 lda audctl,x + and audtb1,x + beq p6 + lda sndfilter,x ;two channel filter + add bajt + sta aktwys+2,x + tay + lda frqtab,y + add byte + sec + adc filter + sta frq+2,x + +p6 dex + bpl p5 + +; sound postprocessing +p8 inx + stx byte + + ift normal ; !!! + + ldx #3 + lda quadro + beq p9 + and #$40 + bne p12 + + ldx #7 ; standard stereo settings +p9 txa + tay + lda vol1ch,y + bne p10 + ldy przeci,x + lda vol2ch,y + bne p10 + txa + tay + lda #0 +p10 ora znksz,y + sta volume,x + lda frq,y + sta freqen,x + lda aktwys,y + sta note,x + + lda audctl,y + ora byte + sta byte + + cpx #4 + sne:sta aud2 + dex + bpl p9 + sta aud1 + rts + +p12 equ * ; RMT stereo +p13 lda vol1ch,x + ora znksz,x + sta volume,x + lda vol2ch+4,x + ora znksz+4,x + sta volume+4,x + mva frq,x freqen,x + mva frq+4,x freqen+4,x + mva aktwys,x note,x + mva aktwys+4,x note+4,x + dex + bpl p13 + + lda audctl + ora audctl+1 + ora audctl+2 + ora audctl+3 + sta aud1 + lda audctl+4 + ora audctl+5 + ora audctl+6 + ora audctl+7 + sta aud2 + rts + +; set pokey +pokey lda quadro + jeq pokey1 + jpl pokey2 + + lda pokeys+3 ; data for pokey 3 + tax + lsr @ + lsr @ + and #1 + tay + lda aud1,y + sta $d238 + txa + and #4 + tay + lda freqtabs,y + sta $d230 + lda voltabs,x + sta $d231 + lda freqtabs+1,y + sta $d232 + lda voltabs+1,x + sta $d233 + lda freqtabs+2,y + sta $d234 + lda voltabs+2,x + sta $d235 + lda freqtabs+3,y + sta $d236 + lda voltabs+3,x + sta $d237 + + lda pokeys+2 ; data for pokey 2 + tax + lsr @ + lsr @ + and #1 + tay + lda aud1,y + sta $d228 + txa + and #4 + tay + lda freqtabs,y + sta $d220 + lda voltabs,x + sta $d221 + lda freqtabs+1,y + sta $d222 + lda voltabs+1,x + sta $d223 + lda freqtabs+2,y + sta $d224 + lda voltabs+2,x + sta $d225 + lda freqtabs+3,y + sta $d226 + lda voltabs+3,x + sta $d227 + +pokey2 lda pokeys+1 ; data for pokey 1 + tax + lsr @ + lsr @ + and #1 + tay + lda aud1,y + sta $d218 + txa + ldy quadro + spl:and #4 + tay + lda freqtabs,y + sta $d210 + lda voltabs,x + sta $d211 + lda freqtabs+1,y + sta $d212 + lda voltabs+1,x + sta $d213 + lda freqtabs+2,y + sta $d214 + lda voltabs+2,x + sta $d215 + lda freqtabs+3,y + sta $d216 + lda voltabs+3,x + sta $d217 + +pokey1 lda pokeys ; data for pokey 0 + tax + lsr @ + lsr @ + and #1 + tay + lda aud1,y + sta $d208 + txa + ldy quadro + spl:and #4 + tay + lda freqtabs,y + sta $d200 + lda voltabs,x + sta $d201 + lda freqtabs+1,y + sta $d202 + lda voltabs+1,x + sta $d203 + lda freqtabs+2,y + sta $d204 + lda voltabs+2,x + sta $d205 + lda freqtabs+3,y + sta $d206 + lda voltabs+3,x + sta $d207 + rts + + els ; !!! + + rts + +pokey lda audctl+4 + ora audctl+5 + ora audctl+6 + ora audctl+7 + sta $d218 + lda frq+4 + sta $d210 + lda vol1ch+4 + ora znksz+4 + sta $d211 + lda frq+5 + sta $d212 + lda vol1ch+5 + ora znksz+5 + sta $d213 + lda frq+6 + sta $d214 + lda vol1ch+6 + ora znksz+6 + sta $d215 + lda frq+7 + sta $d216 + lda vol1ch+7 + ora znksz+7 + sta $d217 + + lda audctl+0 + ora audctl+1 + ora audctl+2 + ora audctl+3 + sta $d208 + lda frq+0 + sta $d200 + lda vol1ch+0 + ora znksz+0 + sta $d201 + lda frq+1 + sta $d202 + lda vol1ch+1 + ora znksz+1 + sta $d203 + lda frq+2 + sta $d204 + lda vol1ch+2 + ora znksz+2 + sta $d205 + lda frq+3 + sta $d206 + lda vol1ch+3 + ora znksz+3 + sta $d207 + rts + + eif ; !!! + +; sound processing +graj lda adrsnl,x + sta addr + lda adrsnh,x + sta addr+1 + + mva shiftfrq,x byte + mva shiftnote,x bajt + mva shiftfilter,x filter + + lda slupy,x + cmp sndlen,x + bcc n1 + sta opadst,x + lda sndlop,x + sta slupy,x + jmp n0 + +n1 lda opadst,x ; sound fading + beq n6 +n0 lda opad1,x + beq n7 + dec lopad1,x + bne n7 + sta lopad1,x + lda actvl1,x + beq n7 + sub #16 + sta actvl1,x +n7 lda opad2,x + beq n6 + dec lopad2,x + bne n6 + sta lopad2,x + + ift normal ; !!! + + lda actvl2,x + beq n6 + sub #16 + sta actvl2,x + + eif ; !!! + +n6 ldy aperm,x ; arpeggio + lda (addr),y + add wysdzw,x + add:sta bajt + dec lperm,x + bpl m1 + lda dperm,x + sta lperm,x + lda kolejn,x + beq m6 + add aperm,x + sta aperm,x + beq m7 + cmp ilperm,x + bcc m1 + lda #$ff + sta kolejn,x + jmp m1 + +m7 lda #1 + sta kolejn,x + jmp m1 + +m6 inc aperm,x + lda ilperm,x + cmp aperm,x + bcs m1 + lda #0 + sta aperm,x + +m1 lda #19 + add:sta addr + scc:inc addr+1 + + ldy slupy,x + lda (addr),y ; main sound data + and #$f0 + sta znksz,x + lda (addr),y + and #15 + ora actvl1,x + tay + lda voltab,y + ora maxvol + tay + lda voltab,y + sta vol1ch,x + + ift normal ; !!! + + ldy slupy,x + iny + lda (addr),y + and #15 + ora actvl2,x + tay + lda voltab,y + ora maxvol + tay + lda voltab,y + sta vol2ch,x + + eif ; !!! + + lda czekaj,x + bne m2 + lda typ,x + sta m5+1 +m5 bpl * ; jmp + jmp typ0 + nop + jmp typ1 + nop + jmp typ2 + nop + jmp typ3 + nop + jmp typ4 + nop + jmp typ5 + nop + jmp typ6 + nop + jmp typ7 + +m2 dec czekaj,x +m3 ldy slupy,x ; accents + iny + lda (addr),y + and #$70 + lsr @ + lsr @ + lsr @ + sta n5+1 + lda (addr),y + bmi n3 + lda mainaudctl,x + jmp n4 +n3 lda addaudctl,x +n4 and usedaudctl,x + sta audctl,x + iny + iny + tya + sta slupy,x + dey + lda (addr),y +n5 bcc * ; jmp + bcc a0 + bcc a1 + bcc a2 + bcc a3 + bcc a4 + bcc a5 + bcc a6 + bcc a7 + +; accents +a1 adc:sta shiftfrq,x + lda (addr),y +a0 add:sta byte + jmp grajreturn + +a3 adc:sta shiftnote,x + lda (addr),y +a2 add:sta bajt + jmp grajreturn + +a5 adc:sta shiftfilter,x + lda (addr),y +a4 add:sta filter + jmp grajreturn + +a6 sta byte + lda #0 +a7 sta bajt + jmp grajreturn + +; effects +typ1 lda typdat,x + and #3 + lsr @ + bcc t0 + bne t1 + lda param,x + add:sta byte +t0 dec ltyp,x + bpl typ0 + inc typdat,x + mva dtyp,x ltyp,x + jmp m3 + +t1 lda byte + sbc param,x ; sec + sta byte + dec ltyp,x + bpl typ0 + inc typdat,x + mva dtyp,x ltyp,x + jmp m3 + +typ2 ldy typdat,x + lda param,x + bmi t2 + iny + iny +t2 dey + tya + add:sta byte + dec ltyp,x + bpl typ0 + tya + sta typdat,x + cmp param,x + bne t3 + eor #$ff + sta param,x +t3 mva dtyp,x ltyp,x +typ0 jmp m3 + +typ3 ldy typdat,x + lda param,x + bmi t4 + iny + iny +t4 dey + tya + add:sta bajt + dec ltyp,x + bpl typ0 + tya + sta typdat,x + cmp param,x + bne t3 + eor #$ff + sta param,x + mva dtyp,x ltyp,x + jmp m3 + +typ4 lda typdat,x + add:sta byte + dec ltyp,x + bpl typ0 + lda param,x + add:sta typdat,x + mva dtyp,x ltyp,x + jmp m3 + +typ5 lda bajt + sub typdat,x + sta bajt + dec ltyp,x + bpl typ0 + lda param,x + add:sta typdat,x + mva dtyp,x ltyp,x + jmp m3 + +typ6 lda param,x + add:sta byte +typ7 jmp m3 ; placeholder for new type of sound + +;---------------- +; init functions + +; play song, X=number of song +songx ldy #16 +zm4 lda #0 + sta addr +zm5 lda #0 + sta addr+1 + mva #0 pozsng +d5 txa + beq inic + lda (addr),y + seq:bpl d4 + dex +d4 lda #17 + add:sta addr + scc:inc addr+1 + inc pozsng + bne d5 + ldx #0 + +; play song, X=line of song +playx lda #0 + sta byte + txa + sta pozsng + asl @ + rol byte + asl @ + rol byte + asl @ + rol byte + asl @ + rol byte + adc pozsng ; clc + scc:inc byte + clc +zm6 adc #0 + sta addr + lda byte +zm7 adc #0 + sta addr+1 +inic jsr stop + mwa addr adrsng + ldx #7 +i4 mva #$ff actvol,x + lda #$f0 + sta actvl1,x + + ift normal ; !!! + + sta actvl2,x + + eif ; !!! + + dex + bpl i4 + lda #3 + sta $d20f + sta $d21f + + ift normal ; !!! + + sta $d22f + sta $d23f + + eif ; !!! + + dec pozsng + inx + stx ltempo + inx + stx pozptr + stx czygrc + rts + +i1 txa ; change of tempo + and #15 + sta tempo + rts +i2 stx czygrc ; pause, continue + rts + +init cmp #$10 ; A=$00 + jcc songx + cmp #$20 ; A=$10 + bcc playx + cmp #$30 ; A=$20 + jcc d2 + cmp #$40 ; A=$30 + bcc i1 + cmp #$50 ; A=$40 + jcc stop + cmp #$60 ; A=$50 + bcc i2 + cmp #$70 ; A=$60 + jcs i3 + sty bajt + +specialcode and #15 + asl @ + sta sc17+1 + lda bajt +sc17 bcc * ; jmp + bcc sc0 + bcc sc1 + bcc sc2 + bcc sc3 + bcc sc4 + bcc sc5 + bcc sc6 + bcc sc7 + bcc sc8 + bcc sc9 + bcc sc10 + bcc sc11 + bcc sc12 + bcc sc13 + bcc sc14 + bcc sc15 + +sc0 sta specialflag ; code 0: set special flag +sc10 equ * +sc11 equ * +sc12 equ * +sc13 equ * +sc14 equ * +sc15 equ * + rts + +; special codes +sc4 sta sndfilter,x + rts +sc5 sta mainaudctl,x + rts +sc6 sta addaudctl,x + rts +sc7 sta shiftfilter,x + rts +sc8 sta shiftfrq,x + rts +sc9 sta shiftnote,x + rts + +sc1 and #$70 + lsr @ + lsr @ + sta typ,x + and #$30 + sne:sta typdat,x + lda bajt + bmi sc16 + and #15 + sta param,x + rts + +sc16 and #15 + eor #$ff + add #1 + sta param,x + rts + +sc2 and #$3f + sta dtyp,x + sta ltyp,x + rts + +sc3 and #$80 + asl @ + rol @ + sta kolejn,x + lda bajt + and #$70 + lsr @ + lsr @ + lsr @ + lsr @ + sta ilperm,x + sne:sta kolejn,x + lda bajt + and #15 + sta dperm,x + sta lperm,x + lda aperm,x + cmp ilperm,x + bcc sc0 + lda ilperm,x + seq:sbc #1 ; sec + sta aperm,x + rts + +; init of new song +i3 sty addr + stx addr+1 + + ldy #25 + mva (addr),y+ quadro + mva (addr),y+ pokeys + mva (addr),y+ pokeys+1 + mva (addr),y+ pokeys+2 + mva (addr),y+ pokeys+3 + lda (addr),y + sta tempo + + lda addr ; low byte of instruments data + eor #$80 + smi:inx + sta zm8+1 + stx zm8+2 + + eor #$80 ; low byte of pattern data + smi:inx + sta zm2+1 + stx zm2+2 + + inx ; high byte of pattern data + sta zm3+1 + stx zm3+2 + + inx ; high byte of instrument data + sta zm9+1 + stx zm9+2 + + eor #$80 ; track data + smi:inx + sta adrsng + sta zm0+1 + sta zm4+1 + sta zm6+1 + stx adrsng+1 + stx zm1+1 + stx zm5+1 + stx zm7+1 + + mva #$f0 maxvol + lda #0 + sta czygrc + sta specialflag + +; stop playing +stop ldx #7 + lda #0 + sta czygrc +d9 sta czygrx,x + sta audctl,x + sta vol1ch,x + + ift normal ; !!! + + sta vol2ch,x + sta volume,x + sta $d230,x + sta $d220,x + + eif ; !!! + + sta $d210,x + sta $d200,x + dex + bpl d9 + sta $d218 + sta $d208 + + ift normal ; !!! + + sta $d238 + sta $d228 + sta aud1 + sta aud2 + + eif ; !!! + rts + +; procedures for play new instrument +d1 sta vol1ch,x ; if attempt to play empty sound - clear data + + ift normal ; !!! + + sta vol2ch,x + sta volume,x + + eif ; !!! + + sta audctl,x + rts + +d0 tya ; change only volume + sta actvol,x +d3 and #$f0 + sta actvl1,x + lda actvol,x + + ift normal ; !!! + + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + rts + +d2 and #7 + sta addr + txa + ldx addr + and #$3f + beq d0 + sta wysdzw,x + tya + bmi d2-1 + lda actvol,x + jsr d3 +dzwiek mva #0 czygrx,x +zm9 lda $ffff,y + beq d1 + sta adrsnh,x + sta addr+1 +zm8 lda $ffff,y + sta adrsnl,x + sta addr + tya + sta numdzw,x + + ldy #8 + mva (addr),y+ sndlen,x + mva (addr),y+ sndlop,x + mva (addr),y+ sndfilter,x + mva (addr),y+ mainaudctl,x + mva (addr),y+ addaudctl,x + mva (addr),y+ opad1,x + sta lopad1,x + mva (addr),y+ opad2,x + sta lopad2,x + lda (addr),y + and #$70 + lsr @ + lsr @ + sta typ,x + + lda (addr),y+ + bmi d7 + and #15 + sta param,x + jmp d8 +d7 and #15 + eor #$ff + add #1 + sta param,x + +d8 mva (addr),y+ czekaj,x + lda (addr),y+ + and #$3f + sta dtyp,x + sta ltyp,x + lda (addr),y + and #$80 + asl @ + rol @ + sta kolejn,x + lda (addr),y + and #$70 + lsr @ + lsr @ + lsr @ + lsr @ + sta ilperm,x + bne d6 + sta kolejn,x +d6 lda (addr),y- + and #15 + sta dperm,x + sta lperm,x + lda (addr),y + and #$c0 + ora wysdzw,x + sta wysdzw,x + tay + lda frqtab,y + sta frq,x + + lda #0 + sta slupy,x + sta typdat,x + sta opadst,x + sta aperm,x + sta shiftfrq,x + sta shiftnote,x + sta shiftfilter,x + lda #1 + sta czygrx,x + rts + +endplr end Index: apps/plugins/asap/players/rmt4.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\rmt4.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/tmc.asx =================================================================== --- apps/plugins/asap/players/tmc.asx (revision 0) +++ apps/plugins/asap/players/tmc.asx (revision 0) @@ -0,0 +1,963 @@ +*---------------* +* TMC Player * +*Jaskier/Taquart* +*---------------* + + org $0500 + +byte equ $fa +bajt equ $fb +addr equ $fc +adrsng equ $fe + +player equ * + jmp init + jmp play + jmp sound + +maxvol dta b(15) +volume dta d' ' +freqen dta d' ' +kanal dta d' ' +aktwys dta d' ' +numdzw dta d' ' +audctl dta d' ' +aud1 dta b(0) +aud2 dta b(0) + +voltab dta d' ' + dta d' !!!!!!!!' + dta d' !!!!!!!!""""' + dta d' !!!!!"""""###' + dta d' !!!!""""####$$' + dta d' !!!"""###$$$%%' + dta d' !!"""##$$$%%&&' + dta d' !!""##$$%%&&''''' + dta d' !!""##$$%%&&''''(' + dta d' !!""#$$%%&''''(()' + dta d' !!"##$%%&''''())*' + dta d' !!"#$$%&''''()**+' + dta d' !""#$%&&''()**+,' + dta d' !"##$%&''()**+,-' + dta d' !"#$%&''''()*+,-.' + dta d' !"#$%&''()*+,-./' + +frqtab dta b(0),b($f1),b($e4),b($d7) + dta b($cb),b($c0),b($b5),b($aa) + dta b($a1),b($98),b($8f),b($87) + dta b($7f),b($78),b($72),b($6b) + dta b($65),b($5f),b($5a),b($55) + dta b($50),b($4b),b($47),b($43) + dta b($3f),b($3c),b($38),b($35) + dta b($32),b($2f),b($2c),b($2a) + dta b($27),b($25),b($23),b($21) + dta b($1f),b($1d),b($1c),b($1a) + dta b($18),b($17),b($16),b($14) + dta b($13),b($12),b($11),b($10) + dta b(15),b(14),b(13),b(12) + dta b(11),b(10),b(9),b(8) + dta b(7),b(6),b(5),b(4) + dta b(3),b(2),b(1),b(0) + + dta b(0),b($f2),b($e6),b($da) + dta b($ce),b($bf),b($b6),b($aa) + dta b($a1),b($98),b($8f),b($89) + dta b($80),b($7a),b($71),b($6b) + dta b($65),b($5f),b($5c),b($56) + dta b($50),b($4d),b($47),b($44) + dta b($3e),b($3c),b($38),b($35) + dta b($32),b($2f),b($2d),b($2a) + dta b($28),b($25),b($23),b($21) + dta b($1f),b($1d),b($1c),b($1a) + dta b($18),b($17),b($16),b($14) + dta b($13),b($12),b($11),b($10) + dta b(15),b(14),b(13),b(12) + dta b(11),b(10),b(9),b(8) + dta b(7),b(6),b(5),b(4) + dta b(3),b(2),b(1),b(0) + + dta b(0),b($ff),b($f1),b($e4) + dta b($d8),b($ca),b($c0),b($b5) + dta b($ab),b($a2),b($99),b($8e) + dta b($87),b($7f),b($79),b($73) + dta b($70),b($66),b($61),b($5a) + dta b($55),b($52),b($4b),b($48) + dta b($43),b($3f),b($3c),b($39) + dta b($37),b($33),b($30),b($2d) + dta b($2a),b($28),b($25),b($24) + dta b($21),b($1f),b($1e),b($1c) + dta b($1b),b($19),b($17),b($16) + dta b($15),b($13),b($12),b($11) + dta b($10),b(15),b(14),b(13) + dta b(12),b(11),b(10),b(9) + dta b(8),b(7),b(6),b(5) + dta b(4),b(3),b(2),b(1) + + dta b(0),b($f3),b($e6),b($d9) + dta b($cc),b($c1),b($b5),b($ad) + dta b($a2),b($99),b($90),b($88) + dta b($80),b($79),b($72),b($6c) + dta b($66),b($60),b($5b),b($55) + dta b($51),b($4c),b($48),b($44) + dta b($40),b($3c),b($39),b($35) + dta b($32),b($2f),b($2d),b($2a) + dta b($28),b($25),b($23),b($21) + dta b($1f),b($1d),b($1c),b($1a) + dta b($18),b($17),b($16),b($14) + dta b($13),b($12),b($11),b($10) + dta b(15),b(14),b(13),b(12) + dta b(11),b(10),b(9),b(8) + dta b(7),b(6),b(5),b(4) + dta b(3),b(2),b(1),b(0) + +basslo dta b(0),b($f2),b($33),b($96) + dta b($e2),b($38),b($8c),b($00) + dta b($6a),b($e8),b($6a),b($ef) + dta b($80),b($08),b($ae),b($46) + dta b($e6),b($95),b($41),b($f6) + dta b($b0),b($6e),b($30),b($f6) + dta b($bb),b($84),b($52),b($22) + dta b($f4),b($c8),b($a0),b($7a) + dta b($55),b($34),b($14),b($f5) + dta b($d8),b($bd),b($a4),b($8d) + dta b($77),b($60),b($4e),b($38) + dta b($27),b($15),b($06),b($f7) + dta b($e8),b($db),b($cf),b($c3) + dta b($b8),b($ac),b($a2),b($9a) + dta b($90),b($88),b($7f),b($78) + dta b($70),b($6a),b($64),b($5e) + +basshi dta b(0),b(13),b(13),b(12) + dta b(11),b(11),b(10),b(10) + dta b(9),b(8),b(8),b(7) + dta b(7),b(7),b(6),b(6) + dta b(5),b(5),b(5),b(4) + dta b(4),b(4),b(4),b(3) + dta b(3),b(3),b(3),b(3) + dta b(2),b(2),b(2),b(2) + dta b(2),b(2),b(2),b(1) + dta b(1),b(1),b(1),b(1) + dta b(1),b(1),b(1),b(1) + dta b(1),b(1),b(1),b(0) + dta b(0),b(0),b(0),b(0) + dta b(0),b(0),b(0),b(0) + dta b(0),b(0),b(0),b(0) + dta b(0),b(0),b(0),b(0) + +czygrx dta d' ' +pozwpt dta d' ' +delay dta d' ' +numptr dta d' ' +poddzw dta d' ' +wysdzw dta d' ' +znksz dta d' ' +frq dta d' ' +vol1ch dta d' ' +vol2ch dta d' ' +adcvl1 dta d' ' +adcvl2 dta d' ' +adrsnl dta d' ' +adrsnh dta d' ' +slupy dta d' ' +opad1 dta d' ' +opad2 dta d' ' +lopad1 dta d' ' +lopad2 dta d' ' +typ dta d' ' +param dta d' ' +pomoc1 dta d' ' +pomoc2 dta d' ' +czekaj dta d' ' +dtyp dta d' ' +ltyp dta d' ' +ilperm dta d' ' +aperm dta d' ' +dperm dta d' ' +lperm dta d' ' +kolejn dta d' ' +tempo dta b(0) +ltempo dta b(0) +pozptr dta b(0) +czygrc dta b(0) + +przeci dta b(4),b(5),b(6),b(7) + dta b(0),b(1),b(2),b(3) +audtb1 dta b(4),b(2),b(0),b(0) + dta b(4),b(2),b(0),b(0) +audtb2 dta b(0),b(16),b(0),b(8) + dta b(0),b(16),b(0),b(8) + +play lda czygrc + beq r1-3 + lda pozptr + cmp #64 + bcc r1 + dec ltempo + beq *+5 + jmp sound + + ldx #7 + lda #0 +p1 sta pozwpt,x + sta delay,x + dex + bpl p1 + sta pozptr + tax + ldy #15 +p2 lda (adrsng),y + bpl p3 + dey + lda (adrsng),y + bpl *+5 + jmp stop + stx addr + asl @ + asl @ + rol addr + asl @ + rol addr + asl @ + rol addr +zm0 adc #0 + sta adrsng + lda addr +zm1 adc #0 + sta adrsng+1 + bcc p2-2 +p3 sta numptr,x + dey + lda (adrsng),y + sta poddzw,x + inx + dey + bpl p2 + clc + lda adrsng + adc #16 + sta adrsng + bcc *+4 + inc adrsng+1 + jmp sound + +r1 dec ltempo + bpl r1-3 + inc pozptr + lda tempo + sta ltempo + ldx #7 +r2 dec delay,x + bmi *+5 + jmp r14 + ldy numptr,x +zm2 lda $ffff,y + sta addr +zm3 lda $ffff,y + sta addr+1 + ldy pozwpt,x +r3 lda (addr),y + bne r4 + jsr nparam + jmp r13 +r4 cmp #$40 + bcs r5 + adc poddzw,x + sta wysdzw,x + jsr nparam + ldy numdzw,x + jsr dzwiek + jmp r13 +r5 bne r8 + iny + inc pozwpt,x + lda (addr),y + bpl r6 + sta bajt + jsr nparam + lda bajt +r6 and #$7f + bne r7 + lda #64 + sta pozptr + bne r13 +r7 sta tempo + sta ltempo + bne r13 +r8 cmp #$80 + bcs r11 + and #$3f + adc poddzw,x + sta wysdzw,x + iny + inc pozwpt,x + lda (addr),y + and #127 + bne r9 + lda #64 + sta pozptr + bne r10 +r9 sta tempo + sta ltempo +r10 jsr nparam + ldy numdzw,x + jsr dzwiek + jmp r13 +r11 cmp #$c0 + bcs r12 + and #$3f + sta numdzw,x + iny + inc pozwpt,x + jmp r3 +r12 and #$3f + sta delay,x +r13 inc pozwpt,x +r14 dex + bmi sound + jmp r2 + +sound ldx #7 +p5 lda czygrx,x + beq p6 + jsr graj + lda audctl,x + and audtb1,x + beq p6 + ldy #71 + lda (addr),y + clc + adc aktwys,x + sta aktwys+2,x + tay + lda frqtab,y + sec + adc pomoc1,x + sta frq+2,x +p6 dex + bpl p5 + + asl maxvol + asl maxvol + asl maxvol + asl maxvol + inx + stx addr + stx addr+1 + ldx #7 +p9 txa + tay + lda vol1ch,y + bne p10 + ldy przeci,x + lda vol2ch,y + bne p10 + txa + tay + lda #0 +p10 sta byte + tya + sta kanal,x + lda frq,y + sta freqen,x + lda audctl,y + sta bajt + ora addr+1 + sta addr+1 + lda bajt + and audtb1,x + beq p11 + lda frq+2,y + sta freqen+2,x +p11 lda bajt + and audtb2,x + beq p12 + lda aktwys,y + and #$3f + tay + iny + sty addr + lda basshi-1,y + sta freqen,x + jmp p13 +p12 ldy addr + beq p13 + lda basslo-1,y + sta freqen,x + lda #0 + sta addr +p13 lda byte + ora maxvol + tay + lda voltab,y + ldy kanal,x + ora znksz,y + sta volume,x + cpx #4 + bne p14 + lda addr+1 + sta aud2 + lda #0 + sta addr+1 +p14 dex + bpl p9 + lsr maxvol + lsr maxvol + lsr maxvol + lsr maxvol + lda addr+1 +quit ldx #3 + stx $d21f + stx $d20f + ldx freqen+4 + ldy freqen + stx $d210 + sty $d200 + ldx volume+4 + ldy volume + stx $d211 + sty $d201 + ldx freqen+5 + ldy freqen+1 + stx $d212 + sty $d202 + ldx volume+5 + ldy volume+1 + stx $d213 + sty $d203 + ldx freqen+6 + ldy freqen+2 + stx $d214 + sty $d204 + ldx volume+6 + ldy volume+2 + stx $d215 + sty $d205 + ldx freqen+7 + ldy freqen+3 + stx $d216 + sty $d206 + ldx volume+7 + ldy volume+3 + stx $d217 + sty $d207 + sta aud1 + ldx aud2 + stx $d218 + sta $d208 + rts + +graj lda adrsnl,x + sta addr + lda adrsnh,x + sta addr+1 + ldy slupy,x + cpy #63 + beq n6 + inc slupy,x + inc slupy,x + inc slupy,x + lda (addr),y + and #$f0 + sta znksz,x + lda (addr),y + and #15 + sec + sbc adcvl1,x + bpl n1 + lda #0 +n1 sta vol1ch,x + iny + lda (addr),y + and #15 + sec + sbc adcvl2,x + bpl n2 + lda #0 +n2 sta vol2ch,x + lda (addr),y + and #$f0 + beq n8 + bpl n3 + ldy #73 + lda (addr),y + ldy slupy,x + dey + dey + bpl n4 +n3 lda #0 +n4 sta audctl,x + lda (addr),y + and #$70 + beq n9 + lsr @ + lsr @ + sta n5+1 + lda #0 + sta pomoc1,x + iny + lda (addr),y +n5 bcc * + nop + nop + nop + nop + jmp a1 + nop + jmp a2 + nop + jmp a3 + nop + jmp a4 + nop + jmp a5 + nop + jmp a6 + nop + jmp a7 +n6 lda opad1,x + beq n7 + dec lopad1,x + bne n7 + sta lopad1,x + lda vol1ch,x + and #15 + beq n7 + dec vol1ch,x +n7 lda opad2,x + beq n8 + dec lopad2,x + bne n8 + sta lopad2,x + lda vol2ch,x + and #15 + beq n8 + dec vol2ch,x +n8 ldy #72 + lda (addr),y + sta audctl,x +n9 lda aperm,x + clc + adc #63 + tay + lda (addr),y + adc wysdzw,x + sta aktwys,x + tay + lda frqtab,y + sta frq,x + dec lperm,x + bpl m1 + lda dperm,x + sta lperm,x + lda kolejn,x + beq m6 + clc + adc aperm,x + sta aperm,x + beq m7 + cmp ilperm,x + bne m1 + lda #$fe +m7 clc + adc #1 + sta kolejn,x + bne m1 +m6 inc aperm,x + lda ilperm,x + cmp aperm,x + bcs m1 + lda #0 + sta aperm,x +m1 lda czekaj,x + beq m2 + dec czekaj,x + rts +m2 lda pomoc2,x + sta byte + lda param,x + sta bajt + jsr m4 + dec ltyp,x + bpl m4-1 + lda byte + sta pomoc2,x + lda bajt + sta param,x + lda dtyp,x + sta ltyp,x + rts +m4 lda typ,x + sta m5+1 +m5 bpl * + jmp typ0 + nop + jmp typ1 + nop + jmp typ2 + nop + jmp typ3 + nop + jmp typ4 + nop + jmp typ5 + nop + jmp typ6 + nop + jmp typ7 + +typ1 lda byte + inc byte + and #3 + lsr @ + bcc t2 + bne typ6 + lda bajt +t1 sta pomoc1,x + clc + adc frq,x + sta frq,x +typ0 rts +t2 lda #0 + sta pomoc1,x + rts +typ2 jsr t5 + jmp t1 +typ3 jsr t5 + clc + adc aktwys,x + jmp a5 +typ4 lda byte + sta pomoc1,x + clc + adc frq,x +t3 sta frq,x + lda byte + clc + adc bajt + sta byte + rts +typ5 lda aktwys,x + sec + sbc byte + sta aktwys,x + tay + lda frqtab,y + jmp t3 +typ6 lda frq,x + sec + sbc bajt + sta frq,x + sec + lda #0 + sbc bajt + sta pomoc1,x + rts +typ7 lda ltyp,x + bne typ0 + lda bajt + bpl t4 + lda vol2ch,x + beq typ0 + lda vol1ch,x + cmp #15 + beq typ0 + inc vol1ch,x + rts +t4 lda vol1ch,x + beq typ0 + lda vol2ch,x + cmp #15 + beq typ0 + inc vol2ch,x + rts +t5 ldy byte + lda bajt + bmi t6 + iny + iny +t6 dey + tya + sta byte + cmp bajt + bne t7 + lda bajt + eor #$ff + sta bajt +t7 tya + rts + +a2 adc frq,x +a1 sta frq,x + rts +a3 ldy wysdzw,x + adc frqtab,y + sta frq,x + tya + sta aktwys,x + rts +a4 and $d20a + sta frq,x + rts +a7 adc wysdzw,x +a5 sta aktwys,x + tay + lda frqtab,y + sta frq,x + rts +a6 sta aktwys,x + tay + lda frq,x + adc frqtab,y + sta frq,x + rts + +nparam iny + inc pozwpt,x + lda (addr),y + lsr @ + lsr @ + lsr @ + lsr @ + sta adcvl1,x + lda (addr),y + and #15 + sta adcvl2,x + rts + +songx jsr stop + ldy #15 +zm4 lda #0 + sta adrsng +zm5 lda #0 + sta adrsng+1 +d5 txa + beq inic +d3 lda (adrsng),y + bpl d4 + dex +d4 clc + lda adrsng + adc #16 + sta adrsng + bcc d5 + inc adrsng+1 + bcs d5 + +playx jsr stop + lda #0 + sta addr + txa + asl @ + asl @ + rol addr + asl @ + rol addr + asl @ + rol addr +zm6 adc #0 + sta adrsng + lda addr +zm7 adc #0 + sta adrsng+1 +inic lda #64 + sta pozptr + lda #1 + sta ltempo + sta czygrc + rts + +init cmp #$10 + bcc songx + cmp #$20 + bcc playx + cmp #$30 + bcs *+5 + jmp d2 + cmp #$40 + bcs i1 + txa + and #15 + beq i1-1 + sta tempo + rts +i1 cmp #$50 + bcc stop + cmp #$60 + bcs i2 + lda #0 +i3 sta czygrc + rts +i2 cmp #$70 + bcc i3 + + lda #1 + sta ltempo + lda #64 + sta pozptr + sty addr + stx addr+1 + ldy #30 + lda (addr),y + sta tempo + lda addr + clc + adc #32 + sta zm8+1 + bcc *+3 + inx + stx zm8+2 + clc + adc #$40 + sta zm9+1 + bcc *+3 + inx + stx zm9+2 + clc + adc #$40 + sta zm2+1 + bcc *+3 + inx + stx zm2+2 + clc + adc #$80 + sta zm3+1 + bcc *+3 + inx + stx zm3+2 + clc + adc #$80 + sta adrsng + sta zm0+1 + sta zm4+1 + sta zm6+1 + bcc *+3 + inx + stx adrsng+1 + stx zm1+1 + stx zm5+1 + stx zm7+1 + +stop ldy #7 + lda #0 + sta czygrc +d9 sta $d200,y + sta $d210,y + sta volume,y + sta vol1ch,y + sta vol2ch,y + sta audctl,y + sta czygrx,y + dey + bpl d9 + sta $d208 + sta $d218 + sta aud1 + sta aud2 + rts + +d1 sta vol1ch,x + sta vol2ch,x + sta audctl,x + lda wysdzw,x + sta aktwys,x + rts +d0 tya + eor #$f0 + lsr @ + lsr @ + lsr @ + lsr @ + sta adcvl1,x + tya + and #15 + eor #15 + sta adcvl2,x + rts +d2 and #7 + sta addr + txa + ldx addr + and #$3f + beq d0 + sta wysdzw,x +dzwiek lda #0 + sta czygrx,x +zm8 lda $ffff,y + sta adrsnl,x + sta addr +zm9 lda $ffff,y + sta adrsnh,x + sta addr+1 + ora addr + beq d1 + ldy #74 + lda (addr),y + sta opad1,x + sta lopad1,x + iny + lda (addr),y + sta opad2,x + sta lopad2,x + iny + lda (addr),y + and #$70 + lsr @ + lsr @ + sta typ,x + lda (addr),y + and #15 + sta param,x + lda (addr),y + bpl d7 + lda param,x + eor #$ff + clc + adc #1 + sta param,x +d7 iny + lda (addr),y + sta czekaj,x + iny + lda (addr),y + and #$3f + sta dtyp,x + sta ltyp,x + iny + lda (addr),y + and #$80 + beq d8 + lda #1 +d8 sta kolejn,x + lda (addr),y + and #$70 + lsr @ + lsr @ + lsr @ + lsr @ + sta ilperm,x + bne d6 + sta kolejn,x +d6 lda (addr),y + and #15 + sta dperm,x + sta lperm,x + dey + lda (addr),y + and #$c0 + clc + adc wysdzw,x + sta wysdzw,x + sta aktwys,x + tay + lda frqtab,y + sta frq,x + lda #0 + sta slupy,x + sta pomoc1,x + sta pomoc2,x + sta aperm,x + lda #1 + sta czygrx,x + rts + +endplr end Index: apps/plugins/asap/players.h =================================================================== --- apps/plugins/asap/players.h (revision 0) +++ apps/plugins/asap/players.h (revision 0) @@ -0,0 +1,947 @@ +static const unsigned char cmc_obx[] = { + 0xFF, 0xFF, 0x00, 0x05, 0xDC, 0x0C, 0x4C, 0x0F, 0x0B, 0x4C, 0x78, 0x05, 0x4C, 0xCB, 0x07, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xE3, 0xED, 0xE3, 0xA0, 0xF0, 0xEC, 0xE1, + 0xF9, 0xE5, 0xF2, 0xA0, 0xF6, 0xA0, 0xB2, 0xAE, 0xB1, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, + 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8D, 0x6E, + 0x05, 0x8E, 0x6F, 0x05, 0x8C, 0x70, 0x05, 0x29, 0x70, 0x4A, 0x4A, 0x4A, 0xAA, 0xBD, 0x91, 0x0B, + 0x8D, 0xA9, 0x05, 0xBD, 0x92, 0x0B, 0x8D, 0xAA, 0x05, 0xA9, 0x03, 0x8D, 0x0F, 0xD2, 0xD8, 0xA5, + 0xFE, 0x48, 0xA5, 0xFF, 0x48, 0xAC, 0x70, 0x05, 0xAE, 0x6F, 0x05, 0xAD, 0x6E, 0x05, 0x20, 0xB2, + 0x05, 0x68, 0x85, 0xFF, 0x68, 0x85, 0xFE, 0x60, 0xAD, 0x76, 0x05, 0x85, 0xFE, 0xAD, 0x77, 0x05, + 0x85, 0xFF, 0xA0, 0x00, 0x8A, 0xF0, 0x1C, 0xB1, 0xFE, 0xC9, 0x8F, 0xF0, 0x04, 0xC9, 0xEF, 0xD0, + 0x0C, 0xCA, 0xD0, 0x09, 0xC8, 0xC0, 0x54, 0xB0, 0x09, 0x98, 0xAA, 0x10, 0x06, 0xC8, 0xC0, 0x54, + 0x90, 0xE5, 0x60, 0x8E, 0x68, 0x05, 0x20, 0x7B, 0x06, 0xA9, 0x00, 0xA2, 0x09, 0x9D, 0x45, 0x05, + 0xCA, 0x10, 0xFA, 0x8D, 0x67, 0x05, 0xA9, 0x01, 0x8D, 0x71, 0x05, 0xA9, 0xFF, 0x8D, 0x6A, 0x05, + 0xAD, 0x72, 0x05, 0x85, 0xFE, 0xAD, 0x73, 0x05, 0x85, 0xFF, 0xA0, 0x13, 0xB1, 0xFE, 0xAA, 0xAD, + 0x76, 0x05, 0x85, 0xFE, 0xAD, 0x77, 0x05, 0x85, 0xFF, 0xAC, 0x68, 0x05, 0xB1, 0xFE, 0xC9, 0xCF, + 0xD0, 0x0D, 0x98, 0x18, 0x69, 0x55, 0xA8, 0xB1, 0xFE, 0x30, 0x0F, 0xAA, 0x4C, 0x34, 0x06, 0xC9, + 0x8F, 0xF0, 0x07, 0xC9, 0xEF, 0xF0, 0x03, 0x88, 0x10, 0xE2, 0x8E, 0x6C, 0x05, 0x8E, 0x6D, 0x05, + 0x60, 0x29, 0x0F, 0xF0, 0xF5, 0x8E, 0xDA, 0x0A, 0x8E, 0xF0, 0x0A, 0x8E, 0xFF, 0x0A, 0x8C, 0xDB, + 0x0A, 0x8C, 0xF1, 0x0A, 0x8C, 0x00, 0x0B, 0x60, 0x8E, 0x72, 0x05, 0x86, 0xFE, 0x8C, 0x73, 0x05, + 0x84, 0xFF, 0x18, 0x8A, 0x69, 0x14, 0x8D, 0x74, 0x05, 0x98, 0x69, 0x00, 0x8D, 0x75, 0x05, 0x8E, + 0x76, 0x05, 0xC8, 0xC8, 0x8C, 0x77, 0x05, 0xA0, 0x13, 0xB1, 0xFE, 0x8D, 0x6C, 0x05, 0x8D, 0x6D, + 0x05, 0xA2, 0x08, 0xA9, 0x00, 0x8D, 0x71, 0x05, 0x9D, 0x00, 0xD2, 0xE0, 0x03, 0xB0, 0x08, 0x9D, + 0x09, 0x05, 0xA9, 0xFF, 0x9D, 0x39, 0x05, 0xCA, 0x10, 0xE9, 0xA9, 0x80, 0xA2, 0x03, 0x9D, 0x4B, + 0x05, 0xCA, 0x10, 0xFA, 0x60, 0xA9, 0x01, 0x8D, 0x71, 0x05, 0xA9, 0x00, 0xF0, 0xEE, 0x29, 0x03, + 0xC9, 0x03, 0xF0, 0xF0, 0xE0, 0x40, 0xB0, 0xEC, 0xC0, 0x1A, 0xB0, 0xE8, 0xAA, 0xA9, 0x80, 0x9D, + 0x4B, 0x05, 0xA9, 0x00, 0x9D, 0x39, 0x05, 0x9D, 0x3C, 0x05, 0x9D, 0x3F, 0x05, 0xAD, 0x6F, 0x05, + 0x9D, 0x0C, 0x05, 0xAD, 0x70, 0x05, 0x0A, 0x0A, 0x0A, 0x85, 0xFE, 0x18, 0xAD, 0x72, 0x05, 0x69, + 0x30, 0x48, 0xAD, 0x73, 0x05, 0x69, 0x01, 0xA8, 0x68, 0x18, 0x65, 0xFE, 0x9D, 0x61, 0x05, 0x98, + 0x69, 0x00, 0x9D, 0x64, 0x05, 0x18, 0xAD, 0x72, 0x05, 0x69, 0x94, 0x85, 0xFE, 0xAD, 0x73, 0x05, + 0x69, 0x00, 0x85, 0xFF, 0xAD, 0x70, 0x05, 0x0A, 0x6D, 0x70, 0x05, 0x0A, 0xA8, 0xB1, 0xFE, 0x9D, + 0x4F, 0x05, 0xC8, 0xB1, 0xFE, 0x9D, 0x52, 0x05, 0x29, 0x07, 0x8D, 0x6E, 0x05, 0xC8, 0xB1, 0xFE, + 0x9D, 0x55, 0x05, 0xC8, 0xB1, 0xFE, 0x9D, 0x58, 0x05, 0xC8, 0xB1, 0xFE, 0x9D, 0x5B, 0x05, 0xC8, + 0xB1, 0xFE, 0x9D, 0x5E, 0x05, 0xA0, 0x00, 0xAD, 0x6E, 0x05, 0xC9, 0x03, 0xD0, 0x02, 0xA0, 0x02, + 0xC9, 0x07, 0xD0, 0x02, 0xA0, 0x04, 0xB9, 0xAF, 0x0B, 0x85, 0xFE, 0xB9, 0xB0, 0x0B, 0x85, 0xFF, + 0xBD, 0x55, 0x05, 0x4A, 0x4A, 0x4A, 0x4A, 0x18, 0x6D, 0x6F, 0x05, 0x8D, 0x6F, 0x05, 0x8D, 0xC2, + 0x07, 0xA8, 0xAD, 0x6E, 0x05, 0xC9, 0x07, 0xD0, 0x0F, 0x98, 0x0A, 0xA8, 0xB1, 0xFE, 0x9D, 0x2D, + 0x05, 0xC8, 0x8C, 0x6F, 0x05, 0x4C, 0x83, 0x07, 0xB1, 0xFE, 0x9D, 0x2D, 0x05, 0xBD, 0x55, 0x05, + 0x29, 0x0F, 0x18, 0x6D, 0x6F, 0x05, 0x8D, 0x6F, 0x05, 0xAC, 0x6F, 0x05, 0xAD, 0x6E, 0x05, 0xC9, + 0x05, 0x08, 0xB1, 0xFE, 0x28, 0xF0, 0x08, 0xDD, 0x2D, 0x05, 0xD0, 0x03, 0x38, 0xE9, 0x01, 0x9D, + 0x30, 0x05, 0xBD, 0x4F, 0x05, 0x48, 0x29, 0x03, 0xA8, 0xB9, 0xB5, 0x0B, 0x9D, 0x36, 0x05, 0x68, + 0x4A, 0x4A, 0x4A, 0x4A, 0xA0, 0x3E, 0xC9, 0x0F, 0xF0, 0x10, 0xA0, 0x37, 0xC9, 0x0E, 0xF0, 0x0A, + 0xA0, 0x30, 0xC9, 0x0D, 0xF0, 0x04, 0x18, 0x69, 0x00, 0xA8, 0xB9, 0xB9, 0x0B, 0x9D, 0x33, 0x05, + 0x60, 0xD8, 0xA5, 0xFC, 0x48, 0xA5, 0xFD, 0x48, 0xA5, 0xFE, 0x48, 0xA5, 0xFF, 0x48, 0xAD, 0x71, + 0x05, 0xD0, 0x03, 0x4C, 0x02, 0x0B, 0xAD, 0x4E, 0x05, 0xF0, 0x03, 0x4C, 0x6B, 0x09, 0xAD, 0x6C, + 0x05, 0xCD, 0x6D, 0x05, 0xF0, 0x03, 0x4C, 0x58, 0x09, 0xAD, 0x67, 0x05, 0xF0, 0x03, 0x4C, 0xDC, + 0x08, 0xA2, 0x02, 0xBC, 0x4B, 0x05, 0x30, 0x03, 0x9D, 0x4B, 0x05, 0x9D, 0x45, 0x05, 0xCA, 0x10, + 0xF2, 0xAD, 0x76, 0x05, 0x85, 0xFC, 0xAD, 0x77, 0x05, 0x85, 0xFD, 0xAC, 0x68, 0x05, 0x84, 0xFE, + 0xCC, 0x6A, 0x05, 0xD0, 0x19, 0xAD, 0x6B, 0x05, 0xF0, 0x14, 0xAD, 0x68, 0x05, 0xAC, 0x69, 0x05, + 0x8C, 0x68, 0x05, 0xCE, 0x6B, 0x05, 0xD0, 0xE8, 0x8D, 0x68, 0x05, 0xA8, 0x10, 0xE2, 0xA2, 0x00, + 0xB1, 0xFC, 0xC9, 0xFE, 0xD0, 0x0E, 0xAC, 0x68, 0x05, 0xC8, 0xC4, 0xFE, 0xF0, 0x43, 0x8C, 0x68, + 0x05, 0x4C, 0x1A, 0x08, 0x9D, 0x42, 0x05, 0x18, 0x98, 0x69, 0x55, 0xA8, 0xE8, 0xE0, 0x03, 0x90, + 0xDF, 0xAC, 0x68, 0x05, 0xB1, 0xFC, 0x10, 0x7A, 0xC9, 0xFF, 0xF0, 0x76, 0x4A, 0x4A, 0x4A, 0x29, + 0x0E, 0xAA, 0xBD, 0xA1, 0x0B, 0x8D, 0x7E, 0x08, 0xBD, 0xA2, 0x0B, 0x8D, 0x7F, 0x08, 0xAD, 0x43, + 0x05, 0x85, 0xFF, 0x20, 0x93, 0x08, 0x8C, 0x68, 0x05, 0xC0, 0x55, 0xB0, 0x04, 0xC4, 0xFE, 0xD0, + 0x8F, 0xA4, 0xFE, 0x8C, 0x68, 0x05, 0x4C, 0x02, 0x0B, 0x20, 0x94, 0x06, 0xA0, 0xFF, 0x60, 0x30, + 0xFB, 0xA8, 0x60, 0x30, 0xF7, 0x38, 0x98, 0xE5, 0xFF, 0xA8, 0x60, 0x30, 0xEF, 0x18, 0x98, 0x65, + 0xFF, 0xA8, 0x60, 0x30, 0xE7, 0x8D, 0x6C, 0x05, 0x8D, 0x6D, 0x05, 0xC8, 0x60, 0x30, 0xDD, 0xAD, + 0x44, 0x05, 0x30, 0xD8, 0x8D, 0x6B, 0x05, 0xC8, 0x8C, 0x69, 0x05, 0x18, 0x98, 0x65, 0xFF, 0x8D, + 0x6A, 0x05, 0x60, 0x88, 0x30, 0x0A, 0xB1, 0xFC, 0xC9, 0x8F, 0xF0, 0x04, 0xC9, 0xEF, 0xD0, 0xF3, + 0xC8, 0x60, 0xA2, 0x02, 0xBD, 0x48, 0x05, 0xF0, 0x05, 0xDE, 0x48, 0x05, 0x10, 0x63, 0xBD, 0x4B, + 0x05, 0xD0, 0x5E, 0xBC, 0x42, 0x05, 0xC0, 0x40, 0xB0, 0x57, 0xAD, 0x74, 0x05, 0x85, 0xFC, 0xAD, + 0x75, 0x05, 0x85, 0xFD, 0xB1, 0xFC, 0x85, 0xFE, 0x18, 0x98, 0x69, 0x40, 0xA8, 0xB1, 0xFC, 0x85, + 0xFF, 0x25, 0xFE, 0xC9, 0xFF, 0xF0, 0x3A, 0xBC, 0x45, 0x05, 0xB1, 0xFE, 0x29, 0xC0, 0xD0, 0x0C, + 0xB1, 0xFE, 0x29, 0x3F, 0x9D, 0x0F, 0x05, 0xFE, 0x45, 0x05, 0x10, 0xEB, 0xC9, 0x40, 0xD0, 0x13, + 0xB1, 0xFE, 0x29, 0x3F, 0x8D, 0x6F, 0x05, 0xBD, 0x0F, 0x05, 0x8D, 0x70, 0x05, 0x20, 0xBC, 0x06, + 0x4C, 0x48, 0x09, 0xC9, 0x80, 0xD0, 0x0A, 0xB1, 0xFE, 0x29, 0x3F, 0x9D, 0x48, 0x05, 0xFE, 0x45, + 0x05, 0xCA, 0x10, 0x90, 0xAE, 0x67, 0x05, 0xE8, 0x8A, 0x29, 0x3F, 0x8D, 0x67, 0x05, 0xCE, 0x6D, + 0x05, 0xD0, 0x0E, 0xAD, 0x6C, 0x05, 0x8D, 0x6D, 0x05, 0xAD, 0x67, 0x05, 0xD0, 0x03, 0xEE, 0x68, + 0x05, 0xAC, 0x30, 0x05, 0xAD, 0x52, 0x05, 0x29, 0x07, 0xC9, 0x05, 0xF0, 0x04, 0xC9, 0x06, 0xD0, + 0x01, 0x88, 0x8C, 0x27, 0x05, 0xA0, 0x00, 0xC9, 0x05, 0xF0, 0x04, 0xC9, 0x06, 0xD0, 0x02, 0xA0, + 0x02, 0xC9, 0x07, 0xD0, 0x02, 0xA0, 0x28, 0x8C, 0x2C, 0x05, 0xA2, 0x02, 0xBD, 0x52, 0x05, 0x29, + 0xE0, 0x9D, 0x28, 0x05, 0xBD, 0x61, 0x05, 0x85, 0xFC, 0xBD, 0x64, 0x05, 0x85, 0xFD, 0xBD, 0x39, + 0x05, 0xC9, 0xFF, 0xF0, 0x36, 0xC9, 0x0F, 0xD0, 0x20, 0xBD, 0x3F, 0x05, 0xF0, 0x2D, 0xDE, 0x3F, + 0x05, 0xBD, 0x3F, 0x05, 0xD0, 0x25, 0xBC, 0x09, 0x05, 0xF0, 0x01, 0x88, 0x98, 0x9D, 0x09, 0x05, + 0xBD, 0x58, 0x05, 0x9D, 0x3F, 0x05, 0x4C, 0xE5, 0x09, 0xBD, 0x39, 0x05, 0x4A, 0xA8, 0xB1, 0xFC, + 0x90, 0x04, 0x4A, 0x4A, 0x4A, 0x4A, 0x29, 0x0F, 0x9D, 0x09, 0x05, 0xBC, 0x2D, 0x05, 0xBD, 0x52, + 0x05, 0x29, 0x07, 0xC9, 0x01, 0xD0, 0x1F, 0x88, 0x98, 0xC8, 0xDD, 0x30, 0x05, 0x08, 0xA9, 0x01, + 0x28, 0xD0, 0x02, 0x0A, 0x0A, 0x3D, 0x3C, 0x05, 0xF0, 0x0C, 0xBC, 0x30, 0x05, 0xC0, 0xFF, 0xD0, + 0x05, 0xA9, 0x00, 0x9D, 0x09, 0x05, 0x98, 0x9D, 0x24, 0x05, 0xA9, 0x01, 0x8D, 0x6E, 0x05, 0xBD, + 0x39, 0x05, 0xC9, 0x0F, 0xF0, 0x38, 0x29, 0x07, 0xA8, 0xB9, 0xCD, 0x0C, 0x85, 0xFE, 0xBD, 0x39, + 0x05, 0x29, 0x08, 0x08, 0x8A, 0x28, 0x18, 0xF0, 0x02, 0x69, 0x03, 0xA8, 0xB9, 0x5B, 0x05, 0x25, + 0xFE, 0xF0, 0x1B, 0xBD, 0x33, 0x05, 0x9D, 0x24, 0x05, 0x8E, 0x6E, 0x05, 0xCA, 0x10, 0x08, 0x8D, + 0x27, 0x05, 0xA9, 0x00, 0x8D, 0x2C, 0x05, 0xE8, 0xBD, 0x36, 0x05, 0x9D, 0x28, 0x05, 0xBD, 0x39, + 0x05, 0x29, 0x0F, 0xC9, 0x0F, 0xF0, 0x10, 0xFE, 0x39, 0x05, 0xBD, 0x39, 0x05, 0xC9, 0x0F, 0xD0, + 0x06, 0xBD, 0x58, 0x05, 0x9D, 0x3F, 0x05, 0xBD, 0x4B, 0x05, 0x10, 0x0A, 0xBD, 0x09, 0x05, 0xD0, + 0x05, 0xA9, 0x40, 0x9D, 0x4B, 0x05, 0xFE, 0x3C, 0x05, 0xA0, 0x00, 0xBD, 0x52, 0x05, 0x4A, 0x4A, + 0x4A, 0x4A, 0x90, 0x01, 0x88, 0x4A, 0x90, 0x01, 0xC8, 0x18, 0x98, 0x7D, 0x2D, 0x05, 0x9D, 0x2D, + 0x05, 0xBD, 0x30, 0x05, 0xC9, 0xFF, 0xD0, 0x02, 0xA0, 0x00, 0x18, 0x98, 0x7D, 0x30, 0x05, 0x9D, + 0x30, 0x05, 0xCA, 0x30, 0x03, 0x4C, 0x96, 0x09, 0xAD, 0x28, 0x05, 0x8D, 0x2B, 0x05, 0xAD, 0x52, + 0x05, 0x29, 0x07, 0xAA, 0xA0, 0x03, 0xAD, 0x6E, 0x05, 0xF0, 0x03, 0xBC, 0xD5, 0x0C, 0x98, 0x48, + 0xB9, 0xB9, 0x0C, 0x08, 0x29, 0x7F, 0xAA, 0x98, 0x29, 0x03, 0x0A, 0xA8, 0xBD, 0x24, 0x05, 0x99, + 0x00, 0xD2, 0xC8, 0xBD, 0x09, 0x05, 0xE0, 0x03, 0xD0, 0x03, 0xAD, 0x09, 0x05, 0x1D, 0x28, 0x05, + 0x28, 0x10, 0x02, 0xA9, 0x00, 0x99, 0x00, 0xD2, 0x68, 0xA8, 0x88, 0x29, 0x03, 0xD0, 0xCF, 0xA0, + 0x08, 0xAD, 0x2C, 0x05, 0x99, 0x00, 0xD2, 0x18, 0x68, 0x85, 0xFF, 0x68, 0x85, 0xFE, 0x68, 0x85, + 0xFD, 0x68, 0x85, 0xFC, 0x60, 0x68, 0xAA, 0xF0, 0x4E, 0xC9, 0x02, 0xF0, 0x06, 0x68, 0x68, 0xCA, + 0xD0, 0xFB, 0x60, 0xA5, 0x14, 0xC5, 0x14, 0xF0, 0xFC, 0xAD, 0x24, 0x02, 0xC9, 0x86, 0xD0, 0x07, + 0xAD, 0x25, 0x02, 0xC9, 0x0B, 0xF0, 0xE6, 0xAD, 0x24, 0x02, 0x8D, 0x8F, 0x0B, 0xAD, 0x25, 0x02, + 0x8D, 0x90, 0x0B, 0xA9, 0x86, 0x8D, 0x24, 0x02, 0xA9, 0x0B, 0x8D, 0x25, 0x02, 0x68, 0x68, 0xF0, + 0x03, 0x38, 0xE9, 0x01, 0x8D, 0x5D, 0x0B, 0x68, 0xA8, 0x68, 0xAA, 0xA9, 0x70, 0x20, 0x78, 0x05, + 0xA9, 0x00, 0xA2, 0x00, 0x4C, 0x78, 0x05, 0xA5, 0x14, 0xC5, 0x14, 0xF0, 0xFC, 0xAD, 0x24, 0x02, + 0xC9, 0x86, 0xD0, 0xAE, 0xAD, 0x25, 0x02, 0xC9, 0x0B, 0xD0, 0xA7, 0xAD, 0x8F, 0x0B, 0x8D, 0x24, + 0x02, 0xAD, 0x90, 0x0B, 0x8D, 0x25, 0x02, 0xA9, 0x40, 0x4C, 0x78, 0x05, 0x20, 0xCB, 0x07, 0x90, + 0x03, 0x20, 0x75, 0x0B, 0x4C, 0xFF, 0xFF, 0xB2, 0x05, 0xDD, 0x05, 0xA8, 0x06, 0x3B, 0x06, 0x7B, + 0x06, 0x94, 0x06, 0x9F, 0x06, 0x52, 0x06, 0x93, 0x08, 0x99, 0x08, 0x9D, 0x08, 0xA5, 0x08, 0xAD, + 0x08, 0xB7, 0x08, 0xCD, 0x08, 0xB9, 0x0B, 0xFA, 0x0B, 0x3B, 0x0C, 0x80, 0xA0, 0x20, 0x40, 0xFF, + 0xF1, 0xE4, 0xD7, 0xCB, 0xC0, 0xB5, 0xAA, 0xA1, 0x98, 0x8F, 0x87, 0x7F, 0x78, 0x72, 0x6B, 0x65, + 0x5F, 0x5A, 0x55, 0x50, 0x4B, 0x47, 0x43, 0x3F, 0x3C, 0x38, 0x35, 0x32, 0x2F, 0x2C, 0x2A, 0x27, + 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, + 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xF2, 0xE9, 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, + 0x7A, 0x71, 0x6B, 0x65, 0x5F, 0x00, 0x56, 0x50, 0x67, 0x60, 0x5A, 0x55, 0x51, 0x4C, 0x48, 0x43, + 0x3F, 0x3D, 0x39, 0x34, 0x33, 0x39, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x00, 0x00, + 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, + 0x00, 0x38, 0x0B, 0x8C, 0x0A, 0x00, 0x0A, 0x6A, 0x09, 0xE8, 0x08, 0x6A, 0x08, 0xEF, 0x07, 0x80, + 0x07, 0x08, 0x07, 0xAE, 0x06, 0x46, 0x06, 0xE6, 0x05, 0x95, 0x05, 0x41, 0x05, 0xF6, 0x04, 0xB0, + 0x04, 0x6E, 0x04, 0x30, 0x04, 0xF6, 0x03, 0xBB, 0x03, 0x84, 0x03, 0x52, 0x03, 0x22, 0x03, 0xF4, + 0x02, 0xC8, 0x02, 0xA0, 0x02, 0x7A, 0x02, 0x55, 0x02, 0x34, 0x02, 0x14, 0x02, 0xF5, 0x01, 0xD8, + 0x01, 0xBD, 0x01, 0xA4, 0x01, 0x8D, 0x01, 0x77, 0x01, 0x60, 0x01, 0x4E, 0x01, 0x38, 0x01, 0x27, + 0x01, 0x15, 0x01, 0x06, 0x01, 0xF7, 0x00, 0xE8, 0x00, 0xDB, 0x00, 0xCF, 0x00, 0xC3, 0x00, 0xB8, + 0x00, 0xAC, 0x00, 0xA2, 0x00, 0x9A, 0x00, 0x90, 0x00, 0x88, 0x00, 0x7F, 0x00, 0x78, 0x00, 0x70, + 0x00, 0x6A, 0x00, 0x64, 0x00, 0x5E, 0x00, 0x57, 0x00, 0x52, 0x00, 0x32, 0x00, 0x0A, 0x00, 0x00, + 0x01, 0x02, 0x83, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x02, 0x83, 0x01, 0x00, 0x02, 0x03, 0x01, + 0x02, 0x80, 0x03, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x03, 0x03, 0x03, 0x03, 0x07, + 0x0B, 0x0F, 0x13 +}; +static const unsigned char mpt_obx[] = { + 0xFF, 0xFF, 0x00, 0x05, 0xB2, 0x0D, 0x4C, 0xCD, 0x0B, 0xAD, 0x2E, 0x07, 0xD0, 0x01, 0x60, 0xA9, + 0x00, 0x8D, 0x1C, 0x0E, 0xEE, 0x1D, 0x0E, 0xAD, 0x17, 0x0E, 0xCD, 0xBB, 0x0D, 0x90, 0x50, 0xCE, + 0x15, 0x0E, 0xF0, 0x03, 0x4C, 0xC5, 0x05, 0xA2, 0x00, 0x8E, 0x17, 0x0E, 0xA9, 0x00, 0x9D, 0xED, + 0x0D, 0x9D, 0xF5, 0x0D, 0xBD, 0xB3, 0x0D, 0x85, 0xEC, 0xBD, 0xB7, 0x0D, 0x85, 0xED, 0xAC, 0x16, + 0x0E, 0xB1, 0xEC, 0xC8, 0xC9, 0xFF, 0xF0, 0x07, 0xC9, 0xFE, 0xD0, 0x0F, 0x4C, 0x2A, 0x0C, 0xB1, + 0xEC, 0x30, 0xF9, 0x0A, 0xA8, 0x8C, 0x16, 0x0E, 0x4C, 0x3B, 0x05, 0x9D, 0xE9, 0x0D, 0xB1, 0xEC, + 0x9D, 0xD5, 0x0D, 0xE8, 0xE0, 0x04, 0xD0, 0xC4, 0xC8, 0x8C, 0x16, 0x0E, 0x4C, 0xC5, 0x05, 0xCE, + 0x15, 0x0E, 0x10, 0x57, 0xAD, 0xBC, 0x0D, 0x8D, 0x15, 0x0E, 0xA2, 0x03, 0xDE, 0xF5, 0x0D, 0x10, + 0x44, 0xBD, 0xE9, 0x0D, 0x0A, 0xA8, 0xB9, 0xFF, 0xFF, 0x85, 0xEC, 0xC8, 0xB9, 0xFF, 0xFF, 0x85, + 0xED, 0x05, 0xEC, 0xF0, 0x30, 0xBD, 0xED, 0x0D, 0x8D, 0x1F, 0x0E, 0x20, 0x3E, 0x07, 0xAC, 0x1F, + 0x0E, 0xC8, 0x98, 0x9D, 0xED, 0x0D, 0xBD, 0xF1, 0x0D, 0x9D, 0xF5, 0x0D, 0xE0, 0x02, 0xD0, 0x15, + 0xBD, 0xC5, 0x0D, 0x49, 0x0F, 0x0A, 0x0A, 0x0A, 0x0A, 0x69, 0x45, 0x8D, 0xA1, 0x0D, 0xA9, 0x0A, + 0x69, 0x00, 0x8D, 0xA2, 0x0D, 0xCA, 0x10, 0xB4, 0xEE, 0x17, 0x0E, 0xA2, 0x01, 0xAD, 0x1B, 0x0E, + 0xC9, 0x02, 0xF0, 0x02, 0xA2, 0x03, 0xAD, 0x1B, 0x0E, 0xC9, 0x02, 0xD0, 0x05, 0xEC, 0x19, 0x0E, + 0xF0, 0x03, 0x4C, 0x76, 0x06, 0xB5, 0xF0, 0x3D, 0x72, 0x06, 0xF0, 0x12, 0xA0, 0x28, 0xB1, 0xEC, + 0x18, 0x7D, 0xE1, 0x0D, 0x20, 0x75, 0x09, 0x38, 0x7D, 0x01, 0x0E, 0x9D, 0xCB, 0x0D, 0xCA, 0x10, + 0xD5, 0xA9, 0x03, 0x8D, 0x0F, 0xD2, 0xA5, 0xF1, 0x29, 0x10, 0xF0, 0x0F, 0xAC, 0xE2, 0x0D, 0xB9, + 0xC6, 0x09, 0x8D, 0xC9, 0x0D, 0xB9, 0x05, 0x0A, 0x8D, 0xCA, 0x0D, 0xAD, 0xC9, 0x0D, 0x8D, 0x00, + 0xD2, 0xAD, 0xCA, 0x0D, 0x8D, 0x02, 0xD2, 0xAD, 0xCB, 0x0D, 0x8D, 0x04, 0xD2, 0xAD, 0xCC, 0x0D, + 0x8D, 0x06, 0xD2, 0xAD, 0xC1, 0x0D, 0xA2, 0xFF, 0xAC, 0x1B, 0x0E, 0xC0, 0x01, 0xD0, 0x05, 0xAE, + 0x19, 0x0E, 0xF0, 0x03, 0x8D, 0x01, 0xD2, 0xAD, 0xC2, 0x0D, 0xE0, 0x01, 0xF0, 0x03, 0x8D, 0x03, + 0xD2, 0xC0, 0x02, 0xF0, 0x14, 0xAD, 0xC3, 0x0D, 0xE0, 0x02, 0xF0, 0x03, 0x8D, 0x05, 0xD2, 0xAD, + 0xC4, 0x0D, 0xE0, 0x03, 0xF0, 0x03, 0x8D, 0x07, 0xD2, 0xA5, 0xF0, 0x05, 0xF1, 0x05, 0xF2, 0x05, + 0xF3, 0x0D, 0x1C, 0x0E, 0x8D, 0x08, 0xD2, 0x60, 0x04, 0x02, 0x00, 0x00, 0xBD, 0xD9, 0x0D, 0x85, + 0xEC, 0xBD, 0xDD, 0x0D, 0x85, 0xED, 0x05, 0xEC, 0xD0, 0x08, 0x9D, 0xC1, 0x0D, 0x95, 0xF0, 0x4C, + 0xF8, 0x05, 0xB4, 0xF4, 0xC0, 0x20, 0xF0, 0x42, 0xB1, 0xEC, 0x38, 0xFD, 0xC5, 0x0D, 0x2C, 0x3A, + 0x07, 0xF0, 0x02, 0x29, 0xF0, 0x9D, 0xC1, 0x0D, 0xC8, 0xB1, 0xEC, 0x8D, 0x1E, 0x0E, 0xC8, 0x94, + 0xF4, 0x29, 0x07, 0xF0, 0x3C, 0xA8, 0xB9, 0x7E, 0x09, 0x8D, 0xCB, 0x06, 0xB9, 0x85, 0x09, 0x8D, + 0xCC, 0x06, 0xAD, 0x1E, 0x0E, 0x4A, 0x4A, 0x4A, 0x4A, 0x4A, 0x09, 0x28, 0xA8, 0xB1, 0xEC, 0x18, + 0x20, 0xFF, 0xFF, 0xA9, 0x00, 0x95, 0xF0, 0x4C, 0xF8, 0x05, 0xBD, 0x09, 0x0E, 0xF0, 0x12, 0xDE, + 0x0D, 0x0E, 0xD0, 0x0D, 0x9D, 0x0D, 0x0E, 0xBD, 0xC1, 0x0D, 0x29, 0x0F, 0xF0, 0x03, 0xDE, 0xC1, + 0x0D, 0xA0, 0x23, 0xB1, 0xEC, 0x95, 0xF0, 0xBD, 0x11, 0x0E, 0x18, 0x69, 0x25, 0xA8, 0x29, 0x03, + 0x9D, 0x11, 0x0E, 0x88, 0xB1, 0xEC, 0x7D, 0xD1, 0x0D, 0x9D, 0xE1, 0x0D, 0x20, 0x77, 0x09, 0x9D, + 0xC9, 0x0D, 0xBD, 0x05, 0x0E, 0xF0, 0x06, 0xDE, 0x05, 0x0E, 0x4C, 0xDF, 0x05, 0xBD, 0xBD, 0x0D, + 0x8D, 0x1E, 0x07, 0x10, 0xFE, 0x4C, 0xC2, 0x08, 0x00, 0x4C, 0xE5, 0x08, 0x00, 0x4C, 0xFB, 0x08, + 0x00, 0x4C, 0x15, 0x09, 0x00, 0x4C, 0x25, 0x09, 0x00, 0x4C, 0x38, 0x09, 0x00, 0x4C, 0x42, 0x09, + 0x10, 0x4C, 0x48, 0x09, 0xA9, 0x00, 0x9D, 0xC5, 0x0D, 0xAC, 0x1F, 0x0E, 0x88, 0xC8, 0xB1, 0xEC, + 0xC9, 0xFE, 0xD0, 0x04, 0x8C, 0x1F, 0x0E, 0x60, 0xC9, 0xE0, 0x90, 0x08, 0xAD, 0xBB, 0x0D, 0x8D, + 0x17, 0x0E, 0xD0, 0xE9, 0xC9, 0xD0, 0x90, 0x0A, 0x29, 0x0F, 0x8D, 0xBC, 0x0D, 0x8D, 0x15, 0x0E, + 0x10, 0xDB, 0xC9, 0xC0, 0x90, 0x09, 0x29, 0x0F, 0x49, 0x0F, 0x9D, 0xC5, 0x0D, 0x10, 0xCE, 0xC9, + 0x80, 0x90, 0x07, 0x29, 0x3F, 0x9D, 0xF1, 0x0D, 0x10, 0xC3, 0xC9, 0x40, 0x90, 0x1B, 0xC8, 0x8C, + 0x1F, 0x0E, 0x29, 0x1F, 0x9D, 0xE5, 0x0D, 0x0A, 0xA8, 0xB9, 0xFF, 0xFF, 0x9D, 0xD9, 0x0D, 0xC8, + 0xB9, 0xFF, 0xFF, 0x9D, 0xDD, 0x0D, 0x4C, 0x3E, 0x07, 0x8C, 0x1F, 0x0E, 0x8D, 0x1E, 0x0E, 0x18, + 0x7D, 0xD5, 0x0D, 0x9D, 0xD1, 0x0D, 0xAD, 0x1B, 0x0E, 0xF0, 0x42, 0xC9, 0x02, 0xF0, 0x3A, 0xBD, + 0xE5, 0x0D, 0xC9, 0x1F, 0xD0, 0x37, 0xAD, 0x1E, 0x0E, 0x38, 0xE9, 0x01, 0x29, 0x0F, 0xA8, 0xB1, + 0xFE, 0x85, 0xFD, 0x98, 0x09, 0x10, 0xA8, 0xB1, 0xFE, 0x85, 0xF8, 0xA0, 0x01, 0x05, 0xFD, 0xD0, + 0x02, 0xA0, 0x00, 0x8C, 0x1A, 0x0E, 0xA9, 0x00, 0x85, 0xFC, 0x9D, 0xD9, 0x0D, 0x9D, 0xDD, 0x0D, + 0x8A, 0x0A, 0x8D, 0x18, 0x0E, 0x8E, 0x19, 0x0E, 0x60, 0xE0, 0x02, 0xB0, 0x63, 0xBD, 0xD9, 0x0D, + 0x85, 0xEE, 0xBD, 0xDD, 0x0D, 0x85, 0xEF, 0x05, 0xEE, 0xF0, 0x4A, 0xA0, 0x20, 0xB1, 0xEE, 0x29, + 0x0F, 0x9D, 0xF9, 0x0D, 0xB1, 0xEE, 0x29, 0x70, 0x4A, 0x4A, 0x9D, 0xBD, 0x0D, 0xC8, 0xB1, 0xEE, + 0x0A, 0x0A, 0x48, 0x29, 0x3F, 0x9D, 0x05, 0x0E, 0x68, 0x29, 0xC0, 0x9D, 0xCD, 0x0D, 0xC8, 0xB1, + 0xEE, 0x9D, 0x09, 0x0E, 0x9D, 0x0D, 0x0E, 0xA9, 0x00, 0x95, 0xF4, 0x9D, 0x11, 0x0E, 0x9D, 0xFD, + 0x0D, 0x9D, 0x01, 0x0E, 0xBD, 0xD1, 0x0D, 0x9D, 0xE1, 0x0D, 0x20, 0x75, 0x09, 0x9D, 0xC9, 0x0D, + 0xEC, 0x19, 0x0E, 0xF0, 0x01, 0x60, 0xA0, 0xFF, 0x8C, 0x19, 0x0E, 0xC8, 0x8C, 0x1A, 0x0E, 0x60, + 0xE0, 0x02, 0xD0, 0x33, 0xAC, 0xD3, 0x0D, 0xB9, 0x45, 0x0B, 0x8D, 0x79, 0x0D, 0xB9, 0x81, 0x0B, + 0x8D, 0x7F, 0x0D, 0xA9, 0x00, 0x85, 0xF9, 0x85, 0xFA, 0xAD, 0xE7, 0x0D, 0x29, 0x0F, 0xA8, 0xB1, + 0xFE, 0x85, 0xFB, 0x98, 0x09, 0x10, 0xA8, 0xB1, 0xFE, 0x8D, 0x89, 0x0D, 0x05, 0xFB, 0xD0, 0x06, + 0x8D, 0x79, 0x0D, 0x8D, 0x7F, 0x0D, 0x60, 0xAD, 0xE8, 0x0D, 0x29, 0x0F, 0xA8, 0xB1, 0xFE, 0x85, + 0xFD, 0x98, 0x09, 0x10, 0xA8, 0xB1, 0xFE, 0x05, 0xFD, 0xF0, 0x0F, 0xB1, 0xFE, 0x38, 0xE5, 0xFD, + 0x85, 0xF8, 0xA9, 0x00, 0x85, 0xFC, 0xA9, 0x8D, 0xD0, 0x02, 0xA9, 0xAD, 0x8D, 0x61, 0x0D, 0x8D, + 0x38, 0x0D, 0xA9, 0x18, 0x8D, 0x07, 0xD2, 0x60, 0xAD, 0x1D, 0x0E, 0x29, 0x07, 0x4A, 0x4A, 0x90, + 0x12, 0xD0, 0x18, 0xBD, 0xF9, 0x0D, 0x18, 0x9D, 0x01, 0x0E, 0x7D, 0xC9, 0x0D, 0x9D, 0xC9, 0x0D, + 0x4C, 0xDF, 0x05, 0xA9, 0x00, 0x9D, 0x01, 0x0E, 0x4C, 0xDF, 0x05, 0xBD, 0xC9, 0x0D, 0x38, 0xFD, + 0xF9, 0x0D, 0x9D, 0xC9, 0x0D, 0x38, 0xA9, 0x00, 0xFD, 0xF9, 0x0D, 0x9D, 0x01, 0x0E, 0x4C, 0xDF, + 0x05, 0xBD, 0xFD, 0x0D, 0x18, 0x9D, 0x01, 0x0E, 0x7D, 0xC9, 0x0D, 0x9D, 0xC9, 0x0D, 0x18, 0xBD, + 0xFD, 0x0D, 0x7D, 0xF9, 0x0D, 0x9D, 0xFD, 0x0D, 0x4C, 0xDF, 0x05, 0xBD, 0xE1, 0x0D, 0x38, 0xFD, + 0xFD, 0x0D, 0x9D, 0xE1, 0x0D, 0x20, 0x75, 0x09, 0x4C, 0x05, 0x09, 0xA9, 0x00, 0x38, 0xFD, 0xFD, + 0x0D, 0x9D, 0x01, 0x0E, 0xBD, 0xC9, 0x0D, 0x38, 0xFD, 0xFD, 0x0D, 0x4C, 0x05, 0x09, 0xBD, 0xE1, + 0x0D, 0x18, 0x7D, 0xFD, 0x0D, 0x4C, 0x1C, 0x09, 0x20, 0x55, 0x09, 0x4C, 0xD0, 0x08, 0x20, 0x55, + 0x09, 0x18, 0x7D, 0xE1, 0x0D, 0x20, 0x9B, 0x09, 0x4C, 0xDF, 0x05, 0xBC, 0xFD, 0x0D, 0xBD, 0xF9, + 0x0D, 0x30, 0x02, 0xC8, 0xC8, 0x88, 0x98, 0x9D, 0xFD, 0x0D, 0xDD, 0xF9, 0x0D, 0xD0, 0x08, 0xBD, + 0xF9, 0x0D, 0x49, 0xFF, 0x9D, 0xF9, 0x0D, 0xBD, 0xFD, 0x0D, 0x60, 0x29, 0x3F, 0x1D, 0xCD, 0x0D, + 0xA8, 0xB9, 0xFF, 0xFF, 0x60, 0x94, 0x91, 0x98, 0xA5, 0xAD, 0xB4, 0xC0, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x40, 0x00, 0x20, 0x00, 0x7D, 0xC9, 0x0D, 0x9D, 0xC9, 0x0D, 0x60, 0x7D, 0xD1, + 0x0D, 0x9D, 0xE1, 0x0D, 0x20, 0x75, 0x09, 0x9D, 0xC9, 0x0D, 0x60, 0x9D, 0xC9, 0x0D, 0xBD, 0x8D, + 0x09, 0x10, 0x0C, 0x9D, 0xC9, 0x0D, 0xA9, 0x80, 0xD0, 0x05, 0x9D, 0xC9, 0x0D, 0xA9, 0x01, 0x0D, + 0x1C, 0x0E, 0x8D, 0x1C, 0x0E, 0x60, 0x2D, 0x0A, 0xD2, 0x9D, 0xC9, 0x0D, 0x60, 0xF2, 0x33, 0x96, + 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, 0xEF, 0x80, 0x08, 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, + 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, 0x22, 0xF4, 0xC8, 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, + 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, 0x38, 0x27, 0x15, 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, + 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, 0x78, 0x70, 0x6A, 0x64, 0x5E, 0x0D, 0x0D, 0x0C, 0x0B, + 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, + 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x16, 0x16, 0x17, 0x17, 0x17, + 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x1A, 0x15, 0x15, 0x16, 0x16, 0x16, + 0x17, 0x17, 0x18, 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1A, 0x1B, 0x14, 0x15, 0x15, 0x16, 0x16, + 0x17, 0x17, 0x18, 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B, 0x14, 0x14, 0x15, 0x15, 0x16, + 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B, 0x1C, 0x13, 0x14, 0x14, 0x15, 0x16, + 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1C, 0x13, 0x13, 0x14, 0x15, 0x15, + 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1B, 0x1B, 0x1C, 0x1D, 0x12, 0x13, 0x14, 0x14, 0x15, + 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1B, 0x1C, 0x1C, 0x1D, 0x12, 0x13, 0x13, 0x14, 0x15, + 0x16, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1D, 0x1D, 0x12, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1B, 0x1C, 0x1D, 0x1E, 0x11, 0x12, 0x13, 0x14, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1C, 0x1D, 0x1E, 0x11, 0x12, 0x13, 0x13, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x11, 0x12, 0x12, 0x13, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1E, 0x10, 0x11, 0x12, 0x13, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x22, 0x24, 0x26, 0x29, + 0x2B, 0x2E, 0x30, 0x33, 0x37, 0x3A, 0x3D, 0x41, 0x45, 0x49, 0x4D, 0x52, 0x57, 0x5C, 0x61, 0x67, + 0x6E, 0x74, 0x7B, 0x82, 0x8A, 0x92, 0x9B, 0xA4, 0xAE, 0xB8, 0xC3, 0xCF, 0xDC, 0xE9, 0xF6, 0x05, + 0x15, 0x25, 0x37, 0x49, 0x5D, 0x71, 0x87, 0x9F, 0xB8, 0xD2, 0xED, 0x0B, 0x2A, 0x4B, 0x6E, 0x93, + 0xBA, 0xE3, 0x0F, 0x3E, 0x70, 0xA4, 0xDB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x03, 0x03, 0xE5, 0x2A, 0x40, 0x59, 0x64, 0xEE, 0x08, 0xA6, 0x0B, 0x0C, 0x0C, 0x0C, 0x0C, + 0x0C, 0x0D, 0x0D, 0x8E, 0x32, 0x07, 0x8C, 0x36, 0x07, 0x29, 0x07, 0xA8, 0xB9, 0xBD, 0x0B, 0x8D, + 0xE3, 0x0B, 0xB9, 0xC5, 0x0B, 0x8D, 0xE4, 0x0B, 0x4C, 0xFF, 0xFF, 0xAD, 0x36, 0x07, 0xAE, 0x32, + 0x07, 0x8D, 0x94, 0x07, 0x8D, 0x9B, 0x07, 0x8E, 0x95, 0x07, 0x8E, 0x9C, 0x07, 0x18, 0x69, 0x40, + 0x8D, 0x81, 0x05, 0x8D, 0x87, 0x05, 0x90, 0x01, 0xE8, 0x8E, 0x82, 0x05, 0x8E, 0x88, 0x05, 0x18, + 0x69, 0x80, 0x8D, 0x7C, 0x09, 0x90, 0x01, 0xE8, 0x8E, 0x7D, 0x09, 0xE8, 0x8D, 0x1F, 0x0C, 0x8E, + 0x20, 0x0C, 0xA2, 0x09, 0xBD, 0xFF, 0xFF, 0x9D, 0xB3, 0x0D, 0xCA, 0x10, 0xF7, 0xCE, 0xBC, 0x0D, + 0xA9, 0x00, 0x8D, 0x2E, 0x07, 0xA2, 0x62, 0x9D, 0xBD, 0x0D, 0xCA, 0x10, 0xFA, 0xA2, 0x08, 0x9D, + 0x00, 0xD2, 0xCA, 0x10, 0xFA, 0x60, 0x20, 0x2A, 0x0C, 0xAD, 0x32, 0x07, 0x0A, 0x8D, 0x16, 0x0E, + 0xAD, 0xBB, 0x0D, 0x8D, 0x17, 0x0E, 0xA9, 0x01, 0x8D, 0x15, 0x0E, 0x8D, 0x2E, 0x07, 0x60, 0xAD, + 0x36, 0x07, 0x85, 0xFE, 0xAD, 0x32, 0x07, 0x85, 0xFF, 0x60, 0xAD, 0x36, 0x07, 0x29, 0x03, 0xAA, + 0xAD, 0x32, 0x07, 0x20, 0xC6, 0x07, 0xAD, 0x1A, 0x0E, 0xF0, 0xEE, 0x0E, 0x36, 0x07, 0x20, 0xBE, + 0x0C, 0xA9, 0x01, 0x8D, 0x1B, 0x0E, 0xAD, 0x1A, 0x0E, 0xF0, 0xDE, 0xC9, 0x01, 0xD0, 0x05, 0xA0, + 0x00, 0xEE, 0x1A, 0x0E, 0xB1, 0xFC, 0xAE, 0x18, 0x0E, 0x4A, 0x4A, 0x4A, 0x4A, 0x09, 0x10, 0x8D, + 0x0A, 0xD4, 0x8D, 0x0A, 0xD4, 0x9D, 0x01, 0xD2, 0xB1, 0xFC, 0x09, 0x10, 0x8D, 0x0A, 0xD4, 0x8D, + 0x0A, 0xD4, 0x9D, 0x01, 0xD2, 0xC8, 0xD0, 0xCE, 0xE6, 0xFD, 0xA5, 0xFD, 0xC5, 0xF8, 0xD0, 0xC6, + 0x8C, 0x1A, 0x0E, 0x60, 0x90, 0x15, 0xA9, 0xEA, 0x8D, 0x99, 0x0C, 0x8D, 0x9A, 0x0C, 0x8D, 0x9B, + 0x0C, 0x8D, 0xA6, 0x0C, 0x8D, 0xA7, 0x0C, 0x8D, 0xA8, 0x0C, 0x60, 0xA9, 0x8D, 0x8D, 0x99, 0x0C, + 0x8D, 0xA6, 0x0C, 0xA9, 0x0A, 0x8D, 0x9A, 0x0C, 0x8D, 0xA7, 0x0C, 0xA9, 0xD4, 0x8D, 0x9B, 0x0C, + 0x8D, 0xA8, 0x0C, 0x60, 0xA9, 0x00, 0x8D, 0x1A, 0x0E, 0xAD, 0x32, 0x07, 0x4A, 0x20, 0xBE, 0x0C, + 0xA9, 0x01, 0x8D, 0x1B, 0x0E, 0x20, 0x80, 0x0C, 0xAD, 0x1B, 0x0E, 0xD0, 0xF8, 0x60, 0xA9, 0x02, + 0x8D, 0x1B, 0x0E, 0x8D, 0x19, 0x0E, 0xA9, 0x18, 0x8D, 0x07, 0xD2, 0xA9, 0x11, 0x85, 0xFA, 0xA9, + 0x0D, 0x85, 0xFB, 0xA9, 0xAD, 0x8D, 0x61, 0x0D, 0x8D, 0x38, 0x0D, 0xA0, 0x00, 0x8C, 0x79, 0x0D, + 0x8C, 0x7F, 0x0D, 0xAE, 0x0B, 0xD4, 0xB1, 0xFC, 0x4A, 0x4A, 0x4A, 0x4A, 0x09, 0x10, 0x8D, 0x07, + 0xD2, 0x20, 0x75, 0x0D, 0xEC, 0x0B, 0xD4, 0xF0, 0xFB, 0x8D, 0x05, 0xD2, 0xAE, 0x0B, 0xD4, 0xB1, + 0xFC, 0xE6, 0xFC, 0xD0, 0x10, 0xE6, 0xFD, 0xC6, 0xF8, 0xD0, 0x0A, 0xA9, 0xAD, 0x8D, 0x61, 0x0D, + 0x8D, 0x38, 0x0D, 0xA9, 0x08, 0x09, 0x10, 0x8D, 0x07, 0xD2, 0x20, 0x75, 0x0D, 0xEC, 0x0B, 0xD4, + 0xF0, 0xFB, 0x8D, 0x05, 0xD2, 0xAD, 0x1B, 0x0E, 0xD0, 0xB9, 0x60, 0x18, 0xA5, 0xF9, 0x69, 0x00, + 0x85, 0xF9, 0xA5, 0xFA, 0x69, 0x00, 0x85, 0xFA, 0x90, 0x0F, 0xE6, 0xFB, 0xA5, 0xFB, 0xC9, 0x00, + 0xD0, 0x07, 0x8C, 0x79, 0x0D, 0x8C, 0x7F, 0x0D, 0x60, 0xB1, 0xFA, 0x24, 0xF9, 0x30, 0x04, 0x4A, + 0x4A, 0x4A, 0x4A, 0x29, 0x0F, 0xA8, 0xB9, 0x45, 0x0A, 0xA0, 0x00, 0x60, 0xA0, 0x00, 0x8C, 0x1B, + 0x0E, 0x8C, 0x1A, 0x0E, 0x88, 0x8C, 0x19, 0x0E, 0x60 +}; +static const unsigned char rmt4_obx[] = { + 0xFF, 0xFF, 0x90, 0x03, 0x60, 0x0B, 0x80, 0x00, 0x80, 0x20, 0x80, 0x40, 0x00, 0xC0, 0x80, 0x80, + 0x80, 0xA0, 0x00, 0xC0, 0x40, 0xC0, 0x00, 0x01, 0x05, 0x0B, 0x15, 0x00, 0x01, 0xFF, 0xFF, 0x01, + 0x01, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x01, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF2, 0x33, 0x96, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, + 0xEF, 0x80, 0x08, 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, + 0x22, 0xF4, 0xC8, 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, + 0x38, 0x27, 0x15, 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, + 0x78, 0x70, 0x6A, 0x64, 0x5E, 0x00, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0xF2, 0xE6, + 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0x7A, 0x71, 0x6B, 0x65, 0x5F, 0x5C, + 0x56, 0x50, 0x4D, 0x47, 0x44, 0x3E, 0x3C, 0x38, 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, + 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, + 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0xFF, 0xF1, 0xE4, 0xD8, 0xCA, 0xC0, 0xB5, 0xAB, 0xA2, 0x99, + 0x8E, 0x87, 0x7F, 0x79, 0x73, 0x70, 0x66, 0x61, 0x5A, 0x55, 0x52, 0x4B, 0x48, 0x43, 0x3F, 0x3C, + 0x39, 0x37, 0x33, 0x30, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x1C, 0x1B, 0x19, 0x17, + 0x16, 0x15, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xF3, 0xE6, 0xD9, 0xCC, 0xC1, 0xB5, 0xAD, 0xA2, 0x99, 0x90, + 0x88, 0x80, 0x79, 0x72, 0x6C, 0x66, 0x60, 0x5B, 0x55, 0x51, 0x4C, 0x48, 0x44, 0x40, 0x3C, 0x39, + 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, + 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x0D, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, + 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, + 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, + 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, + 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, + 0x07, 0x07, 0x08, 0x09, 0x09, 0x0A, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, + 0x07, 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x0D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x4C, 0x0F, 0x06, 0x4C, 0xFC, 0x07, 0x4C, 0x21, 0x08, 0x4C, + 0x58, 0x06, 0x4C, 0x2B, 0x0B, 0x86, 0xD3, 0x84, 0xD4, 0x48, 0xA0, 0xA8, 0xA9, 0x00, 0x99, 0x7F, + 0x02, 0x88, 0xD0, 0xFA, 0xA0, 0x04, 0xB1, 0xD3, 0x8D, 0x15, 0x08, 0xC8, 0xB1, 0xD3, 0x8D, 0x24, + 0x03, 0xC8, 0xB1, 0xD3, 0x8D, 0x05, 0x08, 0x8D, 0x26, 0x03, 0xA0, 0x08, 0xB1, 0xD3, 0x99, 0xC3, + 0x00, 0xC8, 0xC0, 0x10, 0xD0, 0xF6, 0x68, 0x48, 0x0A, 0x0A, 0x18, 0x65, 0xD1, 0x85, 0xD1, 0x68, + 0x08, 0x29, 0xC0, 0x0A, 0x2A, 0x2A, 0x28, 0x65, 0xD2, 0x85, 0xD2, 0x20, 0x6E, 0x06, 0xA9, 0x00, + 0x8D, 0x08, 0xD2, 0xA0, 0x03, 0x8C, 0x0F, 0xD2, 0xA0, 0x08, 0x99, 0x00, 0xD2, 0x88, 0x10, 0xFA, + 0xAD, 0x05, 0x08, 0x60, 0xA2, 0x00, 0x8E, 0x27, 0x03, 0x8A, 0xA8, 0xB1, 0xD1, 0xC9, 0xFE, 0xB0, + 0x2D, 0xA8, 0xB1, 0xCD, 0x9D, 0x80, 0x02, 0xB1, 0xCF, 0x9D, 0x84, 0x02, 0xA9, 0x00, 0x9D, 0x88, + 0x02, 0xA9, 0x01, 0x9D, 0x8C, 0x02, 0xA9, 0x80, 0x9D, 0xB4, 0x02, 0xE8, 0xE0, 0x04, 0xD0, 0xD9, + 0xA5, 0xD1, 0x18, 0x69, 0x04, 0x85, 0xD1, 0x90, 0x1B, 0xE6, 0xD2, 0x4C, 0xBE, 0x06, 0xF0, 0x04, + 0xA9, 0x00, 0xF0, 0xDF, 0xA0, 0x02, 0xB1, 0xD1, 0xAA, 0xC8, 0xB1, 0xD1, 0x85, 0xD2, 0x86, 0xD1, + 0xA2, 0x00, 0xF0, 0xB5, 0xAD, 0x24, 0x03, 0x8D, 0x16, 0x07, 0xA2, 0xFF, 0xE8, 0xDE, 0x8C, 0x02, + 0xD0, 0x45, 0xBD, 0x80, 0x02, 0x85, 0xD3, 0xBD, 0x84, 0x02, 0x85, 0xD4, 0xBC, 0x88, 0x02, 0xFE, + 0x88, 0x02, 0xB1, 0xD3, 0x85, 0xD9, 0x29, 0x3F, 0xC9, 0x3D, 0xF0, 0x11, 0xB0, 0x38, 0x9D, 0x90, + 0x02, 0x9D, 0x10, 0x03, 0xC8, 0xB1, 0xD3, 0x4A, 0x29, 0x7E, 0x9D, 0xB4, 0x02, 0xA9, 0x01, 0x9D, + 0x8C, 0x02, 0xBC, 0x88, 0x02, 0xFE, 0x88, 0x02, 0xB1, 0xD3, 0x4A, 0x66, 0xD9, 0x4A, 0x66, 0xD9, + 0xA5, 0xD9, 0x29, 0xF0, 0x9D, 0x94, 0x02, 0xE0, 0x03, 0xD0, 0xB1, 0xA9, 0xFF, 0x8D, 0x24, 0x03, + 0x8D, 0x25, 0x03, 0x4C, 0x65, 0x07, 0xC9, 0x3F, 0xF0, 0x1B, 0xA5, 0xD9, 0x29, 0xC0, 0xF0, 0x09, + 0x0A, 0x2A, 0x2A, 0x9D, 0x8C, 0x02, 0x4C, 0x11, 0x07, 0xC8, 0xB1, 0xD3, 0x9D, 0x8C, 0x02, 0xFE, + 0x88, 0x02, 0x4C, 0x11, 0x07, 0xA5, 0xD9, 0x30, 0x0C, 0xC8, 0xB1, 0xD3, 0x8D, 0x16, 0x07, 0xFE, + 0x88, 0x02, 0x4C, 0xD6, 0x06, 0xC9, 0xFF, 0xF0, 0x09, 0xC8, 0xB1, 0xD3, 0x9D, 0x88, 0x02, 0x4C, + 0xD6, 0x06, 0x4C, 0x6E, 0x06, 0x4C, 0x21, 0x08, 0xCA, 0x30, 0xFA, 0xBC, 0xB4, 0x02, 0x30, 0xF8, + 0xB1, 0xCB, 0x9D, 0xB8, 0x02, 0x85, 0xD7, 0xC8, 0xB1, 0xCB, 0x9D, 0xBC, 0x02, 0x85, 0xD8, 0xA9, + 0x01, 0x9D, 0x14, 0x03, 0xA8, 0xB1, 0xD7, 0x9D, 0x04, 0x03, 0xC8, 0xB1, 0xD7, 0x9D, 0xC4, 0x02, + 0xC8, 0xB1, 0xD7, 0x9D, 0xC8, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xF0, 0x02, 0x29, 0x3F, 0x9D, 0x08, + 0x03, 0xB1, 0xD7, 0x29, 0x40, 0x9D, 0xF4, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0x20, 0x03, 0xC8, 0xB1, + 0xD7, 0x9D, 0xD0, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xD8, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xDC, 0x02, + 0xC8, 0xB1, 0xD7, 0xA8, 0xB9, 0xA0, 0x03, 0x9D, 0xE0, 0x02, 0x9D, 0xE4, 0x02, 0xB9, 0xA1, 0x03, + 0x9D, 0xE8, 0x02, 0xA0, 0x0A, 0xB1, 0xD7, 0x9D, 0xEC, 0x02, 0xA9, 0x80, 0x9D, 0xD4, 0x02, 0x9D, + 0xB4, 0x02, 0x0A, 0x9D, 0xCC, 0x02, 0x9D, 0x9C, 0x02, 0xA8, 0xB1, 0xD7, 0x9D, 0x00, 0x03, 0x69, + 0x00, 0x9D, 0xC0, 0x02, 0xA9, 0x0C, 0x9D, 0xFC, 0x02, 0xA8, 0xB1, 0xD7, 0x9D, 0xF8, 0x02, 0x4C, + 0x62, 0x07, 0x20, 0x2B, 0x0B, 0xCE, 0x26, 0x03, 0xD0, 0x1D, 0xA9, 0xFF, 0x8D, 0x26, 0x03, 0xCE, + 0x25, 0x03, 0xD0, 0x13, 0xEE, 0x27, 0x03, 0xAD, 0x27, 0x03, 0xC9, 0xFF, 0xF0, 0x03, 0x4C, 0xBE, + 0x06, 0x4C, 0x6E, 0x06, 0x4C, 0x5F, 0x0A, 0xA9, 0x04, 0x85, 0xD6, 0xA2, 0x03, 0xBD, 0xBC, 0x02, + 0xF0, 0xF2, 0x85, 0xD4, 0xBD, 0xB8, 0x02, 0x85, 0xD3, 0xBC, 0xC0, 0x02, 0xB1, 0xD3, 0x85, 0xD9, + 0xC8, 0xB1, 0xD3, 0x85, 0xDA, 0xC8, 0xB1, 0xD3, 0x85, 0xDB, 0xC8, 0x98, 0xDD, 0xC4, 0x02, 0x90, + 0x0A, 0xF0, 0x08, 0xA9, 0x80, 0x9D, 0xCC, 0x02, 0xBD, 0xC8, 0x02, 0x9D, 0xC0, 0x02, 0xA5, 0xD9, + 0x29, 0x0F, 0x1D, 0x94, 0x02, 0xA8, 0xB9, 0x00, 0x05, 0x85, 0xDC, 0xA5, 0xDA, 0x29, 0x0E, 0xA8, + 0xB9, 0x90, 0x03, 0x85, 0xD5, 0xA5, 0xDC, 0x19, 0x91, 0x03, 0x9D, 0x1C, 0x03, 0xBD, 0xDC, 0x02, + 0xF0, 0x28, 0xC9, 0x01, 0xD0, 0x21, 0xBD, 0x9C, 0x02, 0x18, 0x7D, 0xEC, 0x02, 0x18, 0xBC, 0xE0, + 0x02, 0x79, 0xA5, 0x03, 0x9D, 0x9C, 0x02, 0xC8, 0x98, 0xDD, 0xE8, 0x02, 0xD0, 0x03, 0xBD, 0xE4, + 0x02, 0x9D, 0xE0, 0x02, 0x4C, 0xA4, 0x08, 0xDE, 0xDC, 0x02, 0xBC, 0x00, 0x03, 0xC0, 0x0D, 0x90, + 0x3C, 0xBD, 0x08, 0x03, 0x10, 0x31, 0x98, 0xDD, 0xFC, 0x02, 0xD0, 0x08, 0xBD, 0x04, 0x03, 0x9D, + 0xFC, 0x02, 0xD0, 0x03, 0xFE, 0xFC, 0x02, 0xBD, 0xB8, 0x02, 0x85, 0xD7, 0xBD, 0xBC, 0x02, 0x85, + 0xD8, 0xBC, 0xFC, 0x02, 0xB1, 0xD7, 0xBC, 0xF4, 0x02, 0xF0, 0x04, 0x18, 0x7D, 0xF8, 0x02, 0x9D, + 0xF8, 0x02, 0xBD, 0xF0, 0x02, 0x29, 0x3F, 0x38, 0xE9, 0x01, 0x9D, 0x08, 0x03, 0xBD, 0xCC, 0x02, + 0x10, 0x1F, 0xBD, 0x94, 0x02, 0xF0, 0x1A, 0xDD, 0xD8, 0x02, 0xF0, 0x15, 0x90, 0x13, 0xA8, 0xBD, + 0xD4, 0x02, 0x18, 0x7D, 0xD0, 0x02, 0x9D, 0xD4, 0x02, 0x90, 0x06, 0x98, 0xE9, 0x10, 0x9D, 0x94, + 0x02, 0xA9, 0x00, 0x85, 0xDD, 0xA5, 0xDA, 0x9D, 0x0C, 0x03, 0x29, 0x70, 0x4A, 0x4A, 0x8D, 0x1C, + 0x09, 0x90, 0xFE, 0x4C, 0xD2, 0x09, 0xEA, 0x4C, 0x3C, 0x09, 0xEA, 0x4C, 0x41, 0x09, 0xEA, 0x4C, + 0x4B, 0x09, 0xEA, 0x4C, 0x57, 0x09, 0xEA, 0x4C, 0x66, 0x09, 0xEA, 0x4C, 0xA9, 0x09, 0xEA, 0x4C, + 0xB8, 0x09, 0xA5, 0xDB, 0x4C, 0x15, 0x0A, 0xA5, 0xDB, 0x85, 0xDD, 0xBD, 0x90, 0x02, 0x4C, 0xD8, + 0x09, 0xBD, 0x90, 0x02, 0x18, 0x65, 0xDB, 0x9D, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xBD, 0x9C, 0x02, + 0x18, 0x65, 0xDB, 0x9D, 0x9C, 0x02, 0xBD, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xBD, 0xF0, 0x02, 0x10, + 0x0C, 0xBC, 0x90, 0x02, 0xB1, 0xD5, 0x18, 0x7D, 0xF8, 0x02, 0x4C, 0x87, 0x09, 0xBD, 0x90, 0x02, + 0x18, 0x7D, 0xF8, 0x02, 0xC9, 0x3D, 0x90, 0x02, 0xA9, 0x3F, 0xA8, 0xB1, 0xD5, 0x9D, 0xA0, 0x02, + 0xA4, 0xDB, 0xD0, 0x03, 0x9D, 0xA4, 0x02, 0x98, 0x4A, 0x4A, 0x4A, 0x4A, 0x9D, 0xA8, 0x02, 0x9D, + 0xAC, 0x02, 0xA5, 0xDB, 0x29, 0x0F, 0x9D, 0xB0, 0x02, 0xBD, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xA5, + 0xDB, 0x18, 0x7D, 0x14, 0x03, 0x9D, 0x14, 0x03, 0xBD, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xA5, 0xDB, + 0xC9, 0x80, 0xF0, 0x06, 0x9D, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xBD, 0x1C, 0x03, 0x09, 0xF0, 0x9D, + 0x1C, 0x03, 0xBD, 0x90, 0x02, 0x4C, 0xD8, 0x09, 0xBD, 0x90, 0x02, 0x18, 0x65, 0xDB, 0xBC, 0xF0, + 0x02, 0x30, 0x1F, 0x18, 0x7D, 0xF8, 0x02, 0xC9, 0x3D, 0x90, 0x07, 0xA9, 0x00, 0x9D, 0x1C, 0x03, + 0xA9, 0x3F, 0x9D, 0x10, 0x03, 0xA8, 0xB1, 0xD5, 0x18, 0x7D, 0x9C, 0x02, 0x18, 0x65, 0xDD, 0x4C, + 0x15, 0x0A, 0xC9, 0x3D, 0x90, 0x07, 0xA9, 0x00, 0x9D, 0x1C, 0x03, 0xA9, 0x3F, 0xA8, 0xBD, 0x9C, + 0x02, 0x18, 0x7D, 0xF8, 0x02, 0x18, 0x71, 0xD5, 0x18, 0x65, 0xDD, 0x9D, 0x18, 0x03, 0xBD, 0xAC, + 0x02, 0xF0, 0x32, 0xDE, 0xAC, 0x02, 0xD0, 0x2D, 0xBD, 0xA8, 0x02, 0x9D, 0xAC, 0x02, 0xBD, 0xA4, + 0x02, 0xDD, 0xA0, 0x02, 0xF0, 0x1F, 0xB0, 0x0D, 0x7D, 0xB0, 0x02, 0xB0, 0x12, 0xDD, 0xA0, 0x02, + 0xB0, 0x0D, 0x4C, 0x4C, 0x0A, 0xFD, 0xB0, 0x02, 0x90, 0x05, 0xDD, 0xA0, 0x02, 0xB0, 0x03, 0xBD, + 0xA0, 0x02, 0x9D, 0xA4, 0x02, 0xA5, 0xDA, 0x29, 0x01, 0xF0, 0x0A, 0xBD, 0xA4, 0x02, 0x18, 0x7D, + 0x9C, 0x02, 0x9D, 0x18, 0x03, 0xCA, 0x30, 0x03, 0x4C, 0x27, 0x08, 0xAD, 0x20, 0x03, 0x0D, 0x21, + 0x03, 0x0D, 0x22, 0x03, 0x0D, 0x23, 0x03, 0xAA, 0x8E, 0x2C, 0x0B, 0xAD, 0x0C, 0x03, 0x10, 0x21, + 0xAD, 0x1C, 0x03, 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x18, 0x03, 0x18, 0x6D, 0x14, 0x03, 0x8D, 0x1A, + 0x03, 0xAD, 0x1E, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x1E, 0x03, 0x8A, 0x09, 0x04, + 0xAA, 0xAD, 0x0D, 0x03, 0x10, 0x21, 0xAD, 0x1D, 0x03, 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x19, 0x03, + 0x18, 0x6D, 0x15, 0x03, 0x8D, 0x1B, 0x03, 0xAD, 0x1F, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, + 0x8D, 0x1F, 0x03, 0x8A, 0x09, 0x02, 0xAA, 0xEC, 0x2C, 0x0B, 0xD0, 0x5E, 0xAD, 0x0D, 0x03, 0x29, + 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x1D, 0x03, 0x29, 0x0F, 0xF0, 0x1F, 0xAC, 0x11, 0x03, 0xB9, + 0xC0, 0x03, 0x8D, 0x18, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x19, 0x03, 0xAD, 0x1C, 0x03, 0x29, 0x10, + 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x1C, 0x03, 0x8A, 0x09, 0x50, 0xAA, 0xAD, 0x0F, 0x03, 0x29, 0x0E, + 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x1F, 0x03, 0x29, 0x0F, 0xF0, 0x1F, 0xAC, 0x13, 0x03, 0xB9, 0xC0, + 0x03, 0x8D, 0x1A, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x1B, 0x03, 0xAD, 0x1E, 0x03, 0x29, 0x10, 0xD0, + 0x05, 0xA9, 0x00, 0x8D, 0x1E, 0x03, 0x8A, 0x09, 0x28, 0xAA, 0x8E, 0x2C, 0x0B, 0xAD, 0x26, 0x03, + 0x60, 0xA0, 0xFF, 0xAD, 0x18, 0x03, 0xAE, 0x1C, 0x03, 0x8D, 0x00, 0xD2, 0x8E, 0x01, 0xD2, 0xAD, + 0x19, 0x03, 0xAE, 0x1D, 0x03, 0x8D, 0x02, 0xD2, 0x8E, 0x03, 0xD2, 0xAD, 0x1A, 0x03, 0xAE, 0x1E, + 0x03, 0x8D, 0x04, 0xD2, 0x8E, 0x05, 0xD2, 0xAD, 0x1B, 0x03, 0xAE, 0x1F, 0x03, 0x8D, 0x06, 0xD2, + 0x8E, 0x07, 0xD2, 0x8C, 0x08, 0xD2, 0x60 +}; +static const unsigned char rmt8_obx[] = { + 0xFF, 0xFF, 0x90, 0x03, 0x6C, 0x0C, 0x80, 0x00, 0x80, 0x20, 0x80, 0x40, 0x00, 0xC0, 0x80, 0x80, + 0x80, 0xA0, 0x00, 0xC0, 0x40, 0xC0, 0x00, 0x01, 0x05, 0x0B, 0x15, 0x00, 0x01, 0xFF, 0xFF, 0x01, + 0x01, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x01, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF2, 0x33, 0x96, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, + 0xEF, 0x80, 0x08, 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, + 0x22, 0xF4, 0xC8, 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, + 0x38, 0x27, 0x15, 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, + 0x78, 0x70, 0x6A, 0x64, 0x5E, 0x00, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0xF2, 0xE6, + 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0x7A, 0x71, 0x6B, 0x65, 0x5F, 0x5C, + 0x56, 0x50, 0x4D, 0x47, 0x44, 0x3E, 0x3C, 0x38, 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, + 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, + 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0xFF, 0xF1, 0xE4, 0xD8, 0xCA, 0xC0, 0xB5, 0xAB, 0xA2, 0x99, + 0x8E, 0x87, 0x7F, 0x79, 0x73, 0x70, 0x66, 0x61, 0x5A, 0x55, 0x52, 0x4B, 0x48, 0x43, 0x3F, 0x3C, + 0x39, 0x37, 0x33, 0x30, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x1C, 0x1B, 0x19, 0x17, + 0x16, 0x15, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xF3, 0xE6, 0xD9, 0xCC, 0xC1, 0xB5, 0xAD, 0xA2, 0x99, 0x90, + 0x88, 0x80, 0x79, 0x72, 0x6C, 0x66, 0x60, 0x5B, 0x55, 0x51, 0x4C, 0x48, 0x44, 0x40, 0x3C, 0x39, + 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, + 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x0D, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, + 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, + 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, + 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, + 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, + 0x07, 0x07, 0x08, 0x09, 0x09, 0x0A, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, + 0x07, 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x0D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x4C, 0x0F, 0x06, 0x4C, 0x09, 0x08, 0x4C, 0x2E, 0x08, 0x4C, + 0x5C, 0x06, 0x4C, 0x02, 0x0C, 0x86, 0xD3, 0x84, 0xD4, 0x48, 0xA0, 0x00, 0x98, 0x99, 0x00, 0x02, + 0x99, 0x4C, 0x02, 0xC8, 0xD0, 0xF7, 0xA0, 0x04, 0xB1, 0xD3, 0x8D, 0x22, 0x08, 0xC8, 0xB1, 0xD3, + 0x8D, 0x48, 0x03, 0xC8, 0xB1, 0xD3, 0x8D, 0x12, 0x08, 0x8D, 0x4A, 0x03, 0xA0, 0x08, 0xB1, 0xD3, + 0x99, 0xC3, 0x00, 0xC8, 0xC0, 0x10, 0xD0, 0xF6, 0x68, 0x48, 0x0A, 0x0A, 0x0A, 0x18, 0x65, 0xD1, + 0x85, 0xD1, 0x68, 0x08, 0x29, 0xE0, 0x0A, 0x2A, 0x2A, 0x2A, 0x28, 0x65, 0xD2, 0x85, 0xD2, 0x20, + 0x7B, 0x06, 0xA9, 0x00, 0x8D, 0x08, 0xD2, 0x8D, 0x18, 0xD2, 0xA0, 0x03, 0x8C, 0x0F, 0xD2, 0x8C, + 0x1F, 0xD2, 0xA0, 0x08, 0x99, 0x00, 0xD2, 0x99, 0x10, 0xD2, 0x88, 0x10, 0xF7, 0xAD, 0x12, 0x08, + 0x60, 0xA2, 0x00, 0x8E, 0x4B, 0x03, 0x8A, 0xA8, 0xB1, 0xD1, 0xC9, 0xFE, 0xB0, 0x2D, 0xA8, 0xB1, + 0xCD, 0x9D, 0x00, 0x02, 0xB1, 0xCF, 0x9D, 0x08, 0x02, 0xA9, 0x00, 0x9D, 0x10, 0x02, 0xA9, 0x01, + 0x9D, 0x18, 0x02, 0xA9, 0x80, 0x9D, 0x68, 0x02, 0xE8, 0xE0, 0x08, 0xD0, 0xD9, 0xA5, 0xD1, 0x18, + 0x69, 0x08, 0x85, 0xD1, 0x90, 0x1B, 0xE6, 0xD2, 0x4C, 0xCB, 0x06, 0xF0, 0x04, 0xA9, 0x00, 0xF0, + 0xDF, 0xA0, 0x02, 0xB1, 0xD1, 0xAA, 0xC8, 0xB1, 0xD1, 0x85, 0xD2, 0x86, 0xD1, 0xA2, 0x00, 0xF0, + 0xB5, 0xAD, 0x48, 0x03, 0x8D, 0x23, 0x07, 0xA2, 0xFF, 0xE8, 0xDE, 0x18, 0x02, 0xD0, 0x45, 0xBD, + 0x00, 0x02, 0x85, 0xD3, 0xBD, 0x08, 0x02, 0x85, 0xD4, 0xBC, 0x10, 0x02, 0xFE, 0x10, 0x02, 0xB1, + 0xD3, 0x85, 0xD9, 0x29, 0x3F, 0xC9, 0x3D, 0xF0, 0x11, 0xB0, 0x38, 0x9D, 0x20, 0x02, 0x9D, 0x20, + 0x03, 0xC8, 0xB1, 0xD3, 0x4A, 0x29, 0x7E, 0x9D, 0x68, 0x02, 0xA9, 0x01, 0x9D, 0x18, 0x02, 0xBC, + 0x10, 0x02, 0xFE, 0x10, 0x02, 0xB1, 0xD3, 0x4A, 0x66, 0xD9, 0x4A, 0x66, 0xD9, 0xA5, 0xD9, 0x29, + 0xF0, 0x9D, 0x28, 0x02, 0xE0, 0x07, 0xD0, 0xB1, 0xA9, 0xFF, 0x8D, 0x48, 0x03, 0x8D, 0x49, 0x03, + 0x4C, 0x72, 0x07, 0xC9, 0x3F, 0xF0, 0x1B, 0xA5, 0xD9, 0x29, 0xC0, 0xF0, 0x09, 0x0A, 0x2A, 0x2A, + 0x9D, 0x18, 0x02, 0x4C, 0x1E, 0x07, 0xC8, 0xB1, 0xD3, 0x9D, 0x18, 0x02, 0xFE, 0x10, 0x02, 0x4C, + 0x1E, 0x07, 0xA5, 0xD9, 0x30, 0x0C, 0xC8, 0xB1, 0xD3, 0x8D, 0x23, 0x07, 0xFE, 0x10, 0x02, 0x4C, + 0xE3, 0x06, 0xC9, 0xFF, 0xF0, 0x09, 0xC8, 0xB1, 0xD3, 0x9D, 0x10, 0x02, 0x4C, 0xE3, 0x06, 0x4C, + 0x7B, 0x06, 0x4C, 0x2E, 0x08, 0xCA, 0x30, 0xFA, 0xBC, 0x68, 0x02, 0x30, 0xF8, 0xB1, 0xCB, 0x9D, + 0x70, 0x02, 0x85, 0xD7, 0xC8, 0xB1, 0xCB, 0x9D, 0x78, 0x02, 0x85, 0xD8, 0xA9, 0x01, 0x9D, 0x28, + 0x03, 0xA8, 0xB1, 0xD7, 0x9D, 0x08, 0x03, 0xC8, 0xB1, 0xD7, 0x9D, 0x88, 0x02, 0xC8, 0xB1, 0xD7, + 0x9D, 0x90, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xE0, 0x02, 0x29, 0x3F, 0x9D, 0x10, 0x03, 0xB1, 0xD7, + 0x29, 0x40, 0x9D, 0xE8, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0x40, 0x03, 0xC8, 0xB1, 0xD7, 0x9D, 0xA0, + 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xB0, 0x02, 0xC8, 0xB1, 0xD7, 0x9D, 0xB8, 0x02, 0xC8, 0xB1, 0xD7, + 0xA8, 0xB9, 0xA0, 0x03, 0x9D, 0xC0, 0x02, 0x9D, 0xC8, 0x02, 0xB9, 0xA1, 0x03, 0x9D, 0xD0, 0x02, + 0xA0, 0x0A, 0xB1, 0xD7, 0x9D, 0xD8, 0x02, 0xA9, 0x80, 0x9D, 0xA8, 0x02, 0x9D, 0x68, 0x02, 0x0A, + 0x9D, 0x98, 0x02, 0x9D, 0x38, 0x02, 0xA8, 0xB1, 0xD7, 0x9D, 0x00, 0x03, 0x69, 0x00, 0x9D, 0x80, + 0x02, 0xA9, 0x0C, 0x9D, 0xF8, 0x02, 0xA8, 0xB1, 0xD7, 0x9D, 0xF0, 0x02, 0x4C, 0x6F, 0x07, 0x20, + 0x02, 0x0C, 0xCE, 0x4A, 0x03, 0xD0, 0x1D, 0xA9, 0xFF, 0x8D, 0x4A, 0x03, 0xCE, 0x49, 0x03, 0xD0, + 0x13, 0xEE, 0x4B, 0x03, 0xAD, 0x4B, 0x03, 0xC9, 0xFF, 0xF0, 0x03, 0x4C, 0xCB, 0x06, 0x4C, 0x7B, + 0x06, 0x4C, 0x74, 0x0A, 0xA9, 0x04, 0x85, 0xD6, 0xA2, 0x07, 0xBD, 0x78, 0x02, 0xF0, 0xF2, 0x85, + 0xD4, 0xBD, 0x70, 0x02, 0x85, 0xD3, 0xBC, 0x80, 0x02, 0xB1, 0xD3, 0x85, 0xD9, 0xC8, 0xB1, 0xD3, + 0x85, 0xDA, 0xC8, 0xB1, 0xD3, 0x85, 0xDB, 0xC8, 0x98, 0xDD, 0x88, 0x02, 0x90, 0x0A, 0xF0, 0x08, + 0xA9, 0x80, 0x9D, 0x98, 0x02, 0xBD, 0x90, 0x02, 0x9D, 0x80, 0x02, 0xA5, 0xD9, 0xE0, 0x04, 0x90, + 0x04, 0x4A, 0x4A, 0x4A, 0x4A, 0x29, 0x0F, 0x1D, 0x28, 0x02, 0xA8, 0xB9, 0x00, 0x05, 0x85, 0xDC, + 0xA5, 0xDA, 0x29, 0x0E, 0xA8, 0xB9, 0x90, 0x03, 0x85, 0xD5, 0xA5, 0xDC, 0x19, 0x91, 0x03, 0x9D, + 0x38, 0x03, 0xBD, 0xB8, 0x02, 0xF0, 0x28, 0xC9, 0x01, 0xD0, 0x21, 0xBD, 0x38, 0x02, 0x18, 0x7D, + 0xD8, 0x02, 0x18, 0xBC, 0xC0, 0x02, 0x79, 0xA5, 0x03, 0x9D, 0x38, 0x02, 0xC8, 0x98, 0xDD, 0xD0, + 0x02, 0xD0, 0x03, 0xBD, 0xC8, 0x02, 0x9D, 0xC0, 0x02, 0x4C, 0xB9, 0x08, 0xDE, 0xB8, 0x02, 0xBC, + 0x00, 0x03, 0xC0, 0x0D, 0x90, 0x3C, 0xBD, 0x10, 0x03, 0x10, 0x31, 0x98, 0xDD, 0xF8, 0x02, 0xD0, + 0x08, 0xBD, 0x08, 0x03, 0x9D, 0xF8, 0x02, 0xD0, 0x03, 0xFE, 0xF8, 0x02, 0xBD, 0x70, 0x02, 0x85, + 0xD7, 0xBD, 0x78, 0x02, 0x85, 0xD8, 0xBC, 0xF8, 0x02, 0xB1, 0xD7, 0xBC, 0xE8, 0x02, 0xF0, 0x04, + 0x18, 0x7D, 0xF0, 0x02, 0x9D, 0xF0, 0x02, 0xBD, 0xE0, 0x02, 0x29, 0x3F, 0x38, 0xE9, 0x01, 0x9D, + 0x10, 0x03, 0xBD, 0x98, 0x02, 0x10, 0x1F, 0xBD, 0x28, 0x02, 0xF0, 0x1A, 0xDD, 0xB0, 0x02, 0xF0, + 0x15, 0x90, 0x13, 0xA8, 0xBD, 0xA8, 0x02, 0x18, 0x7D, 0xA0, 0x02, 0x9D, 0xA8, 0x02, 0x90, 0x06, + 0x98, 0xE9, 0x10, 0x9D, 0x28, 0x02, 0xA9, 0x00, 0x85, 0xDD, 0xA5, 0xDA, 0x9D, 0x18, 0x03, 0x29, + 0x70, 0x4A, 0x4A, 0x8D, 0x31, 0x09, 0x90, 0xFE, 0x4C, 0xE7, 0x09, 0xEA, 0x4C, 0x51, 0x09, 0xEA, + 0x4C, 0x56, 0x09, 0xEA, 0x4C, 0x60, 0x09, 0xEA, 0x4C, 0x6C, 0x09, 0xEA, 0x4C, 0x7B, 0x09, 0xEA, + 0x4C, 0xBE, 0x09, 0xEA, 0x4C, 0xCD, 0x09, 0xA5, 0xDB, 0x4C, 0x2A, 0x0A, 0xA5, 0xDB, 0x85, 0xDD, + 0xBD, 0x20, 0x02, 0x4C, 0xED, 0x09, 0xBD, 0x20, 0x02, 0x18, 0x65, 0xDB, 0x9D, 0x20, 0x02, 0x4C, + 0xED, 0x09, 0xBD, 0x38, 0x02, 0x18, 0x65, 0xDB, 0x9D, 0x38, 0x02, 0xBD, 0x20, 0x02, 0x4C, 0xED, + 0x09, 0xBD, 0xE0, 0x02, 0x10, 0x0C, 0xBC, 0x20, 0x02, 0xB1, 0xD5, 0x18, 0x7D, 0xF0, 0x02, 0x4C, + 0x9C, 0x09, 0xBD, 0x20, 0x02, 0x18, 0x7D, 0xF0, 0x02, 0xC9, 0x3D, 0x90, 0x02, 0xA9, 0x3F, 0xA8, + 0xB1, 0xD5, 0x9D, 0x40, 0x02, 0xA4, 0xDB, 0xD0, 0x03, 0x9D, 0x48, 0x02, 0x98, 0x4A, 0x4A, 0x4A, + 0x4A, 0x9D, 0x50, 0x02, 0x9D, 0x58, 0x02, 0xA5, 0xDB, 0x29, 0x0F, 0x9D, 0x60, 0x02, 0xBD, 0x20, + 0x02, 0x4C, 0xED, 0x09, 0xA5, 0xDB, 0x18, 0x7D, 0x28, 0x03, 0x9D, 0x28, 0x03, 0xBD, 0x20, 0x02, + 0x4C, 0xED, 0x09, 0xA5, 0xDB, 0xC9, 0x80, 0xF0, 0x06, 0x9D, 0x20, 0x02, 0x4C, 0xED, 0x09, 0xBD, + 0x38, 0x03, 0x09, 0xF0, 0x9D, 0x38, 0x03, 0xBD, 0x20, 0x02, 0x4C, 0xED, 0x09, 0xBD, 0x20, 0x02, + 0x18, 0x65, 0xDB, 0xBC, 0xE0, 0x02, 0x30, 0x1F, 0x18, 0x7D, 0xF0, 0x02, 0xC9, 0x3D, 0x90, 0x07, + 0xA9, 0x00, 0x9D, 0x38, 0x03, 0xA9, 0x3F, 0x9D, 0x20, 0x03, 0xA8, 0xB1, 0xD5, 0x18, 0x7D, 0x38, + 0x02, 0x18, 0x65, 0xDD, 0x4C, 0x2A, 0x0A, 0xC9, 0x3D, 0x90, 0x07, 0xA9, 0x00, 0x9D, 0x38, 0x03, + 0xA9, 0x3F, 0xA8, 0xBD, 0x38, 0x02, 0x18, 0x7D, 0xF0, 0x02, 0x18, 0x71, 0xD5, 0x18, 0x65, 0xDD, + 0x9D, 0x30, 0x03, 0xBD, 0x58, 0x02, 0xF0, 0x32, 0xDE, 0x58, 0x02, 0xD0, 0x2D, 0xBD, 0x50, 0x02, + 0x9D, 0x58, 0x02, 0xBD, 0x48, 0x02, 0xDD, 0x40, 0x02, 0xF0, 0x1F, 0xB0, 0x0D, 0x7D, 0x60, 0x02, + 0xB0, 0x12, 0xDD, 0x40, 0x02, 0xB0, 0x0D, 0x4C, 0x61, 0x0A, 0xFD, 0x60, 0x02, 0x90, 0x05, 0xDD, + 0x40, 0x02, 0xB0, 0x03, 0xBD, 0x40, 0x02, 0x9D, 0x48, 0x02, 0xA5, 0xDA, 0x29, 0x01, 0xF0, 0x0A, + 0xBD, 0x48, 0x02, 0x18, 0x7D, 0x38, 0x02, 0x9D, 0x30, 0x03, 0xCA, 0x30, 0x03, 0x4C, 0x34, 0x08, + 0xAD, 0x40, 0x03, 0x0D, 0x41, 0x03, 0x0D, 0x42, 0x03, 0x0D, 0x43, 0x03, 0xAA, 0x8E, 0x65, 0x0C, + 0xAD, 0x18, 0x03, 0x10, 0x21, 0xAD, 0x38, 0x03, 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x30, 0x03, 0x18, + 0x6D, 0x28, 0x03, 0x8D, 0x32, 0x03, 0xAD, 0x3A, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, + 0x3A, 0x03, 0x8A, 0x09, 0x04, 0xAA, 0xAD, 0x19, 0x03, 0x10, 0x21, 0xAD, 0x39, 0x03, 0x29, 0x0F, + 0xF0, 0x1A, 0xAD, 0x31, 0x03, 0x18, 0x6D, 0x29, 0x03, 0x8D, 0x33, 0x03, 0xAD, 0x3B, 0x03, 0x29, + 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3B, 0x03, 0x8A, 0x09, 0x02, 0xAA, 0xEC, 0x65, 0x0C, 0xD0, + 0x5E, 0xAD, 0x19, 0x03, 0x29, 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x39, 0x03, 0x29, 0x0F, 0xF0, + 0x1F, 0xAC, 0x21, 0x03, 0xB9, 0xC0, 0x03, 0x8D, 0x30, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x31, 0x03, + 0xAD, 0x38, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x38, 0x03, 0x8A, 0x09, 0x50, 0xAA, + 0xAD, 0x1B, 0x03, 0x29, 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x3B, 0x03, 0x29, 0x0F, 0xF0, 0x1F, + 0xAC, 0x23, 0x03, 0xB9, 0xC0, 0x03, 0x8D, 0x32, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x33, 0x03, 0xAD, + 0x3A, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3A, 0x03, 0x8A, 0x09, 0x28, 0xAA, 0x8E, + 0x65, 0x0C, 0xAD, 0x44, 0x03, 0x0D, 0x45, 0x03, 0x0D, 0x46, 0x03, 0x0D, 0x47, 0x03, 0xAA, 0x8E, + 0x03, 0x0C, 0xAD, 0x1C, 0x03, 0x10, 0x21, 0xAD, 0x3C, 0x03, 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x34, + 0x03, 0x18, 0x6D, 0x2C, 0x03, 0x8D, 0x36, 0x03, 0xAD, 0x3E, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, + 0x00, 0x8D, 0x3E, 0x03, 0x8A, 0x09, 0x04, 0xAA, 0xAD, 0x1D, 0x03, 0x10, 0x21, 0xAD, 0x3D, 0x03, + 0x29, 0x0F, 0xF0, 0x1A, 0xAD, 0x35, 0x03, 0x18, 0x6D, 0x2D, 0x03, 0x8D, 0x37, 0x03, 0xAD, 0x3F, + 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3F, 0x03, 0x8A, 0x09, 0x02, 0xAA, 0xEC, 0x03, + 0x0C, 0xD0, 0x5E, 0xAD, 0x1D, 0x03, 0x29, 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x3D, 0x03, 0x29, + 0x0F, 0xF0, 0x1F, 0xAC, 0x25, 0x03, 0xB9, 0xC0, 0x03, 0x8D, 0x34, 0x03, 0xB9, 0xC0, 0x04, 0x8D, + 0x35, 0x03, 0xAD, 0x3C, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3C, 0x03, 0x8A, 0x09, + 0x50, 0xAA, 0xAD, 0x1F, 0x03, 0x29, 0x0E, 0xC9, 0x06, 0xD0, 0x26, 0xAD, 0x3F, 0x03, 0x29, 0x0F, + 0xF0, 0x1F, 0xAC, 0x27, 0x03, 0xB9, 0xC0, 0x03, 0x8D, 0x36, 0x03, 0xB9, 0xC0, 0x04, 0x8D, 0x37, + 0x03, 0xAD, 0x3E, 0x03, 0x29, 0x10, 0xD0, 0x05, 0xA9, 0x00, 0x8D, 0x3E, 0x03, 0x8A, 0x09, 0x28, + 0xAA, 0x8E, 0x03, 0x0C, 0xAD, 0x4A, 0x03, 0x60, 0xA0, 0xFF, 0xAD, 0x34, 0x03, 0xAE, 0x30, 0x03, + 0x8D, 0x10, 0xD2, 0x8E, 0x00, 0xD2, 0xAD, 0x3C, 0x03, 0xAE, 0x38, 0x03, 0x8D, 0x11, 0xD2, 0x8E, + 0x01, 0xD2, 0xAD, 0x35, 0x03, 0xAE, 0x31, 0x03, 0x8D, 0x12, 0xD2, 0x8E, 0x02, 0xD2, 0xAD, 0x3D, + 0x03, 0xAE, 0x39, 0x03, 0x8D, 0x13, 0xD2, 0x8E, 0x03, 0xD2, 0xAD, 0x36, 0x03, 0xAE, 0x32, 0x03, + 0x8D, 0x14, 0xD2, 0x8E, 0x04, 0xD2, 0xAD, 0x3E, 0x03, 0xAE, 0x3A, 0x03, 0x8D, 0x15, 0xD2, 0x8E, + 0x05, 0xD2, 0xAD, 0x37, 0x03, 0xAE, 0x33, 0x03, 0x8D, 0x16, 0xD2, 0x8E, 0x06, 0xD2, 0xAD, 0x3F, + 0x03, 0xAE, 0x3B, 0x03, 0x8D, 0x17, 0xD2, 0x8E, 0x07, 0xD2, 0xA9, 0xFF, 0x8C, 0x18, 0xD2, 0x8D, + 0x08, 0xD2, 0x60 +}; +static const unsigned char tmc_obx[] = { + 0xFF, 0xFF, 0x00, 0x05, 0x68, 0x0F, 0x4C, 0xCE, 0x0D, 0x4C, 0xD0, 0x08, 0x4C, 0xEF, 0x09, 0x0F, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, + 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, + 0x04, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, + 0x05, 0x05, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, + 0x06, 0x06, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, + 0x07, 0x07, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, + 0x07, 0x08, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x08, 0x09, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, 0x07, 0x07, 0x08, 0x09, + 0x09, 0x0A, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, 0x09, 0x0A, + 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0A, + 0x0B, 0x0C, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0A, 0x0B, + 0x0C, 0x0D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, + 0x0D, 0x0E, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, + 0x0E, 0x0F, 0x00, 0xF1, 0xE4, 0xD7, 0xCB, 0xC0, 0xB5, 0xAA, 0xA1, 0x98, 0x8F, 0x87, 0x7F, 0x78, + 0x72, 0x6B, 0x65, 0x5F, 0x5A, 0x55, 0x50, 0x4B, 0x47, 0x43, 0x3F, 0x3C, 0x38, 0x35, 0x32, 0x2F, + 0x2C, 0x2A, 0x27, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, + 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x00, 0x00, 0xF2, 0xE6, 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, 0x8F, 0x89, 0x80, 0x7A, + 0x71, 0x6B, 0x65, 0x5F, 0x5C, 0x56, 0x50, 0x4D, 0x47, 0x44, 0x3E, 0x3C, 0x38, 0x35, 0x32, 0x2F, + 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, + 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x00, 0x00, 0xFF, 0xF1, 0xE4, 0xD8, 0xCA, 0xC0, 0xB5, 0xAB, 0xA2, 0x99, 0x8E, 0x87, 0x7F, + 0x79, 0x73, 0x70, 0x66, 0x61, 0x5A, 0x55, 0x52, 0x4B, 0x48, 0x43, 0x3F, 0x3C, 0x39, 0x37, 0x33, + 0x30, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x1C, 0x1B, 0x19, 0x17, 0x16, 0x15, 0x13, + 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x00, 0xF3, 0xE6, 0xD9, 0xCC, 0xC1, 0xB5, 0xAD, 0xA2, 0x99, 0x90, 0x88, 0x80, 0x79, + 0x72, 0x6C, 0x66, 0x60, 0x5B, 0x55, 0x51, 0x4C, 0x48, 0x44, 0x40, 0x3C, 0x39, 0x35, 0x32, 0x2F, + 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, 0x16, 0x14, 0x13, 0x12, + 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x00, 0x00, 0xF2, 0x33, 0x96, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, 0xEF, 0x80, 0x08, + 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, 0x22, 0xF4, 0xC8, + 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, 0x38, 0x27, 0x15, + 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, 0x78, 0x70, 0x6A, + 0x64, 0x5E, 0x00, 0x0D, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, + 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x02, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x08, 0x00, 0x10, 0x00, 0x08, 0xAD, 0xB7, 0x08, 0xF0, 0x5E, 0xAD, 0xB6, 0x08, 0xC9, 0x40, + 0x90, 0x5A, 0xCE, 0xB5, 0x08, 0xF0, 0x03, 0x4C, 0xEF, 0x09, 0xA2, 0x07, 0xA9, 0x00, 0x9D, 0xC4, + 0x07, 0x9D, 0xCC, 0x07, 0xCA, 0x10, 0xF7, 0x8D, 0xB6, 0x08, 0xAA, 0xA0, 0x0F, 0xB1, 0xFE, 0x10, + 0x20, 0x88, 0xB1, 0xFE, 0x10, 0x03, 0x4C, 0x5F, 0x0E, 0x86, 0xFC, 0x0A, 0x0A, 0x26, 0xFC, 0x0A, + 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x69, 0x00, 0x85, 0xFE, 0xA5, 0xFC, 0x69, 0x00, 0x85, 0xFF, 0x90, + 0xDA, 0x9D, 0xD4, 0x07, 0x88, 0xB1, 0xFE, 0x9D, 0xDC, 0x07, 0xE8, 0x88, 0x10, 0xCF, 0x18, 0xA5, + 0xFE, 0x69, 0x10, 0x85, 0xFE, 0x90, 0x02, 0xE6, 0xFF, 0x4C, 0xEF, 0x09, 0xCE, 0xB5, 0x08, 0x10, + 0xF8, 0xEE, 0xB6, 0x08, 0xAD, 0xB4, 0x08, 0x8D, 0xB5, 0x08, 0xA2, 0x07, 0xDE, 0xCC, 0x07, 0x30, + 0x03, 0x4C, 0xE9, 0x09, 0xBC, 0xD4, 0x07, 0xB9, 0xFF, 0xFF, 0x85, 0xFC, 0xB9, 0xFF, 0xFF, 0x85, + 0xFD, 0xBC, 0xC4, 0x07, 0xB1, 0xFC, 0xD0, 0x06, 0x20, 0x6D, 0x0D, 0x4C, 0xE6, 0x09, 0xC9, 0x40, + 0xB0, 0x12, 0x7D, 0xDC, 0x07, 0x9D, 0xE4, 0x07, 0x20, 0x6D, 0x0D, 0xBC, 0x2A, 0x05, 0x20, 0xBC, + 0x0E, 0x4C, 0xE6, 0x09, 0xD0, 0x22, 0xC8, 0xFE, 0xC4, 0x07, 0xB1, 0xFC, 0x10, 0x07, 0x85, 0xFB, + 0x20, 0x6D, 0x0D, 0xA5, 0xFB, 0x29, 0x7F, 0xD0, 0x07, 0xA9, 0x40, 0x8D, 0xB6, 0x08, 0xD0, 0x4C, + 0x8D, 0xB4, 0x08, 0x8D, 0xB5, 0x08, 0xD0, 0x44, 0xC9, 0x80, 0xB0, 0x2B, 0x29, 0x3F, 0x7D, 0xDC, + 0x07, 0x9D, 0xE4, 0x07, 0xC8, 0xFE, 0xC4, 0x07, 0xB1, 0xFC, 0x29, 0x7F, 0xD0, 0x07, 0xA9, 0x40, + 0x8D, 0xB6, 0x08, 0xD0, 0x06, 0x8D, 0xB4, 0x08, 0x8D, 0xB5, 0x08, 0x20, 0x6D, 0x0D, 0xBC, 0x2A, + 0x05, 0x20, 0xBC, 0x0E, 0x4C, 0xE6, 0x09, 0xC9, 0xC0, 0xB0, 0x0C, 0x29, 0x3F, 0x9D, 0x2A, 0x05, + 0xC8, 0xFE, 0xC4, 0x07, 0x4C, 0x5E, 0x09, 0x29, 0x3F, 0x9D, 0xCC, 0x07, 0xFE, 0xC4, 0x07, 0xCA, + 0x30, 0x03, 0x4C, 0x46, 0x09, 0xA2, 0x07, 0xBD, 0xBC, 0x07, 0xF0, 0x21, 0x20, 0x2E, 0x0B, 0xBD, + 0x32, 0x05, 0x3D, 0xC0, 0x08, 0xF0, 0x16, 0xA0, 0x47, 0xB1, 0xFC, 0x18, 0x7D, 0x22, 0x05, 0x9D, + 0x24, 0x05, 0xA8, 0xB9, 0x3C, 0x06, 0x38, 0x7D, 0x64, 0x08, 0x9D, 0xF6, 0x07, 0xCA, 0x10, 0xD7, + 0x0E, 0x09, 0x05, 0x0E, 0x09, 0x05, 0x0E, 0x09, 0x05, 0x0E, 0x09, 0x05, 0xE8, 0x86, 0xFC, 0x86, + 0xFD, 0xA2, 0x07, 0x8A, 0xA8, 0xB9, 0xFC, 0x07, 0xD0, 0x0C, 0xBC, 0xB8, 0x08, 0xB9, 0x04, 0x08, + 0xD0, 0x04, 0x8A, 0xA8, 0xA9, 0x00, 0x85, 0xFA, 0x98, 0x9D, 0x1A, 0x05, 0xB9, 0xF4, 0x07, 0x9D, + 0x12, 0x05, 0xB9, 0x32, 0x05, 0x85, 0xFB, 0x05, 0xFD, 0x85, 0xFD, 0xA5, 0xFB, 0x3D, 0xC0, 0x08, + 0xF0, 0x06, 0xB9, 0xF6, 0x07, 0x9D, 0x14, 0x05, 0xA5, 0xFB, 0x3D, 0xC8, 0x08, 0xF0, 0x12, 0xB9, + 0x22, 0x05, 0x29, 0x3F, 0xA8, 0xC8, 0x84, 0xFC, 0xB9, 0x7B, 0x07, 0x9D, 0x12, 0x05, 0x4C, 0x89, + 0x0A, 0xA4, 0xFC, 0xF0, 0x0A, 0xB9, 0x3B, 0x07, 0x9D, 0x12, 0x05, 0xA9, 0x00, 0x85, 0xFC, 0xA5, + 0xFA, 0x0D, 0x09, 0x05, 0xA8, 0xB9, 0x3C, 0x05, 0xBC, 0x1A, 0x05, 0x19, 0xEC, 0x07, 0x9D, 0x0A, + 0x05, 0xE0, 0x04, 0xD0, 0x09, 0xA5, 0xFD, 0x8D, 0x3B, 0x05, 0xA9, 0x00, 0x85, 0xFD, 0xCA, 0x10, + 0x82, 0x4E, 0x09, 0x05, 0x4E, 0x09, 0x05, 0x4E, 0x09, 0x05, 0x4E, 0x09, 0x05, 0xA5, 0xFD, 0xA2, + 0x03, 0x8E, 0x1F, 0xD2, 0x8E, 0x0F, 0xD2, 0xAE, 0x16, 0x05, 0xAC, 0x12, 0x05, 0x8E, 0x10, 0xD2, + 0x8C, 0x00, 0xD2, 0xAE, 0x0E, 0x05, 0xAC, 0x0A, 0x05, 0x8E, 0x11, 0xD2, 0x8C, 0x01, 0xD2, 0xAE, + 0x17, 0x05, 0xAC, 0x13, 0x05, 0x8E, 0x12, 0xD2, 0x8C, 0x02, 0xD2, 0xAE, 0x0F, 0x05, 0xAC, 0x0B, + 0x05, 0x8E, 0x13, 0xD2, 0x8C, 0x03, 0xD2, 0xAE, 0x18, 0x05, 0xAC, 0x14, 0x05, 0x8E, 0x14, 0xD2, + 0x8C, 0x04, 0xD2, 0xAE, 0x10, 0x05, 0xAC, 0x0C, 0x05, 0x8E, 0x15, 0xD2, 0x8C, 0x05, 0xD2, 0xAE, + 0x19, 0x05, 0xAC, 0x15, 0x05, 0x8E, 0x16, 0xD2, 0x8C, 0x06, 0xD2, 0xAE, 0x11, 0x05, 0xAC, 0x0D, + 0x05, 0x8E, 0x17, 0xD2, 0x8C, 0x07, 0xD2, 0x8D, 0x3A, 0x05, 0xAE, 0x3B, 0x05, 0x8E, 0x18, 0xD2, + 0x8D, 0x08, 0xD2, 0x60, 0xBD, 0x1C, 0x08, 0x85, 0xFC, 0xBD, 0x24, 0x08, 0x85, 0xFD, 0xBC, 0x2C, + 0x08, 0xC0, 0x3F, 0xF0, 0x7B, 0xFE, 0x2C, 0x08, 0xFE, 0x2C, 0x08, 0xFE, 0x2C, 0x08, 0xB1, 0xFC, + 0x29, 0xF0, 0x9D, 0xEC, 0x07, 0xB1, 0xFC, 0x29, 0x0F, 0x38, 0xFD, 0x0C, 0x08, 0x10, 0x02, 0xA9, + 0x00, 0x9D, 0xFC, 0x07, 0xC8, 0xB1, 0xFC, 0x29, 0x0F, 0x38, 0xFD, 0x14, 0x08, 0x10, 0x02, 0xA9, + 0x00, 0x9D, 0x04, 0x08, 0xB1, 0xFC, 0x29, 0xF0, 0xF0, 0x74, 0x10, 0x0B, 0xA0, 0x49, 0xB1, 0xFC, + 0xBC, 0x2C, 0x08, 0x88, 0x88, 0x10, 0x02, 0xA9, 0x00, 0x9D, 0x32, 0x05, 0xB1, 0xFC, 0x29, 0x70, + 0xF0, 0x63, 0x4A, 0x4A, 0x8D, 0x9A, 0x0B, 0xA9, 0x00, 0x9D, 0x64, 0x08, 0xC8, 0xB1, 0xFC, 0x90, + 0xFE, 0xEA, 0xEA, 0xEA, 0xEA, 0x4C, 0x38, 0x0D, 0xEA, 0x4C, 0x35, 0x0D, 0xEA, 0x4C, 0x3C, 0x0D, + 0xEA, 0x4C, 0x4A, 0x0D, 0xEA, 0x4C, 0x54, 0x0D, 0xEA, 0x4C, 0x5F, 0x0D, 0xEA, 0x4C, 0x51, 0x0D, + 0xBD, 0x34, 0x08, 0xF0, 0x12, 0xDE, 0x44, 0x08, 0xD0, 0x0D, 0x9D, 0x44, 0x08, 0xBD, 0xFC, 0x07, + 0x29, 0x0F, 0xF0, 0x03, 0xDE, 0xFC, 0x07, 0xBD, 0x3C, 0x08, 0xF0, 0x12, 0xDE, 0x4C, 0x08, 0xD0, + 0x0D, 0x9D, 0x4C, 0x08, 0xBD, 0x04, 0x08, 0x29, 0x0F, 0xF0, 0x03, 0xDE, 0x04, 0x08, 0xA0, 0x48, + 0xB1, 0xFC, 0x9D, 0x32, 0x05, 0xBD, 0x94, 0x08, 0x18, 0x69, 0x3F, 0xA8, 0xB1, 0xFC, 0x7D, 0xE4, + 0x07, 0x9D, 0x22, 0x05, 0xA8, 0xB9, 0x3C, 0x06, 0x9D, 0xF4, 0x07, 0xDE, 0xA4, 0x08, 0x10, 0x33, + 0xBD, 0x9C, 0x08, 0x9D, 0xA4, 0x08, 0xBD, 0xAC, 0x08, 0xF0, 0x18, 0x18, 0x7D, 0x94, 0x08, 0x9D, + 0x94, 0x08, 0xF0, 0x07, 0xDD, 0x8C, 0x08, 0xD0, 0x1A, 0xA9, 0xFE, 0x18, 0x69, 0x01, 0x9D, 0xAC, + 0x08, 0xD0, 0x10, 0xFE, 0x94, 0x08, 0xBD, 0x8C, 0x08, 0xDD, 0x94, 0x08, 0xB0, 0x05, 0xA9, 0x00, + 0x9D, 0x94, 0x08, 0xBD, 0x74, 0x08, 0xF0, 0x04, 0xDE, 0x74, 0x08, 0x60, 0xBD, 0x6C, 0x08, 0x85, + 0xFA, 0xBD, 0x5C, 0x08, 0x85, 0xFB, 0x20, 0x69, 0x0C, 0xDE, 0x84, 0x08, 0x10, 0x10, 0xA5, 0xFA, + 0x9D, 0x6C, 0x08, 0xA5, 0xFB, 0x9D, 0x5C, 0x08, 0xBD, 0x7C, 0x08, 0x9D, 0x84, 0x08, 0x60, 0xBD, + 0x54, 0x08, 0x8D, 0x70, 0x0C, 0x10, 0xFE, 0x4C, 0xA7, 0x0C, 0xEA, 0x4C, 0x90, 0x0C, 0xEA, 0x4C, + 0xAE, 0x0C, 0xEA, 0x4C, 0xB4, 0x0C, 0xEA, 0x4C, 0xBE, 0x0C, 0xEA, 0x4C, 0xD2, 0x0C, 0xEA, 0x4C, + 0xE2, 0x0C, 0xEA, 0x4C, 0xF4, 0x0C, 0xA5, 0xFA, 0xE6, 0xFA, 0x29, 0x03, 0x4A, 0x90, 0x0F, 0xD0, + 0x47, 0xA5, 0xFB, 0x9D, 0x64, 0x08, 0x18, 0x7D, 0xF4, 0x07, 0x9D, 0xF4, 0x07, 0x60, 0xA9, 0x00, + 0x9D, 0x64, 0x08, 0x60, 0x20, 0x1D, 0x0D, 0x4C, 0x9D, 0x0C, 0x20, 0x1D, 0x0D, 0x18, 0x7D, 0x22, + 0x05, 0x4C, 0x54, 0x0D, 0xA5, 0xFA, 0x9D, 0x64, 0x08, 0x18, 0x7D, 0xF4, 0x07, 0x9D, 0xF4, 0x07, + 0xA5, 0xFA, 0x18, 0x65, 0xFB, 0x85, 0xFA, 0x60, 0xBD, 0x22, 0x05, 0x38, 0xE5, 0xFA, 0x9D, 0x22, + 0x05, 0xA8, 0xB9, 0x3C, 0x06, 0x4C, 0xC7, 0x0C, 0xBD, 0xF4, 0x07, 0x38, 0xE5, 0xFB, 0x9D, 0xF4, + 0x07, 0x38, 0xA9, 0x00, 0xE5, 0xFB, 0x9D, 0x64, 0x08, 0x60, 0xBD, 0x84, 0x08, 0xD0, 0xAE, 0xA5, + 0xFB, 0x10, 0x10, 0xBD, 0x04, 0x08, 0xF0, 0xA5, 0xBD, 0xFC, 0x07, 0xC9, 0x0F, 0xF0, 0x9E, 0xFE, + 0xFC, 0x07, 0x60, 0xBD, 0xFC, 0x07, 0xF0, 0x95, 0xBD, 0x04, 0x08, 0xC9, 0x0F, 0xF0, 0x8E, 0xFE, + 0x04, 0x08, 0x60, 0xA4, 0xFA, 0xA5, 0xFB, 0x30, 0x02, 0xC8, 0xC8, 0x88, 0x98, 0x85, 0xFA, 0xC5, + 0xFB, 0xD0, 0x06, 0xA5, 0xFB, 0x49, 0xFF, 0x85, 0xFB, 0x98, 0x60, 0x7D, 0xF4, 0x07, 0x9D, 0xF4, + 0x07, 0x60, 0xBC, 0xE4, 0x07, 0x79, 0x3C, 0x06, 0x9D, 0xF4, 0x07, 0x98, 0x9D, 0x22, 0x05, 0x60, + 0x2D, 0x0A, 0xD2, 0x9D, 0xF4, 0x07, 0x60, 0x7D, 0xE4, 0x07, 0x9D, 0x22, 0x05, 0xA8, 0xB9, 0x3C, + 0x06, 0x9D, 0xF4, 0x07, 0x60, 0x9D, 0x22, 0x05, 0xA8, 0xBD, 0xF4, 0x07, 0x79, 0x3C, 0x06, 0x9D, + 0xF4, 0x07, 0x60, 0xC8, 0xFE, 0xC4, 0x07, 0xB1, 0xFC, 0x4A, 0x4A, 0x4A, 0x4A, 0x9D, 0x0C, 0x08, + 0xB1, 0xFC, 0x29, 0x0F, 0x9D, 0x14, 0x08, 0x60, 0x20, 0x5F, 0x0E, 0xA0, 0x0F, 0xA9, 0x00, 0x85, + 0xFE, 0xA9, 0x00, 0x85, 0xFF, 0x8A, 0xF0, 0x2E, 0xB1, 0xFE, 0x10, 0x01, 0xCA, 0x18, 0xA5, 0xFE, + 0x69, 0x10, 0x85, 0xFE, 0x90, 0xEF, 0xE6, 0xFF, 0xB0, 0xEB, 0x20, 0x5F, 0x0E, 0xA9, 0x00, 0x85, + 0xFC, 0x8A, 0x0A, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x69, 0x00, 0x85, 0xFE, + 0xA5, 0xFC, 0x69, 0x00, 0x85, 0xFF, 0xA9, 0x40, 0x8D, 0xB6, 0x08, 0xA9, 0x01, 0x8D, 0xB5, 0x08, + 0x8D, 0xB7, 0x08, 0x60, 0xC9, 0x10, 0x90, 0xB0, 0xC9, 0x20, 0x90, 0xCE, 0xC9, 0x30, 0xB0, 0x03, + 0x4C, 0xAE, 0x0E, 0xC9, 0x40, 0xB0, 0x09, 0x8A, 0x29, 0x0F, 0xF0, 0x03, 0x8D, 0xB4, 0x08, 0x60, + 0xC9, 0x50, 0x90, 0x71, 0xC9, 0x60, 0xB0, 0x06, 0xA9, 0x00, 0x8D, 0xB7, 0x08, 0x60, 0xC9, 0x70, + 0x90, 0xF8, 0xA9, 0x01, 0x8D, 0xB5, 0x08, 0xA9, 0x40, 0x8D, 0xB6, 0x08, 0x84, 0xFC, 0x86, 0xFD, + 0xA0, 0x1E, 0xB1, 0xFC, 0x8D, 0xB4, 0x08, 0xA5, 0xFC, 0x18, 0x69, 0x20, 0x8D, 0xC2, 0x0E, 0x90, + 0x01, 0xE8, 0x8E, 0xC3, 0x0E, 0x18, 0x69, 0x40, 0x8D, 0xCA, 0x0E, 0x90, 0x01, 0xE8, 0x8E, 0xCB, + 0x0E, 0x18, 0x69, 0x40, 0x8D, 0x52, 0x09, 0x90, 0x01, 0xE8, 0x8E, 0x53, 0x09, 0x18, 0x69, 0x80, + 0x8D, 0x57, 0x09, 0x90, 0x01, 0xE8, 0x8E, 0x58, 0x09, 0x18, 0x69, 0x80, 0x85, 0xFE, 0x8D, 0x10, + 0x09, 0x8D, 0x88, 0x0D, 0x8D, 0xB7, 0x0D, 0x90, 0x01, 0xE8, 0x86, 0xFF, 0x8E, 0x16, 0x09, 0x8E, + 0x8C, 0x0D, 0x8E, 0xBD, 0x0D, 0xA0, 0x07, 0xA9, 0x00, 0x8D, 0xB7, 0x08, 0x99, 0x00, 0xD2, 0x99, + 0x10, 0xD2, 0x99, 0x0A, 0x05, 0x99, 0xFC, 0x07, 0x99, 0x04, 0x08, 0x99, 0x32, 0x05, 0x99, 0xBC, + 0x07, 0x88, 0x10, 0xE8, 0x8D, 0x08, 0xD2, 0x8D, 0x18, 0xD2, 0x8D, 0x3A, 0x05, 0x8D, 0x3B, 0x05, + 0x60, 0x9D, 0xFC, 0x07, 0x9D, 0x04, 0x08, 0x9D, 0x32, 0x05, 0xBD, 0xE4, 0x07, 0x9D, 0x22, 0x05, + 0x60, 0x98, 0x49, 0xF0, 0x4A, 0x4A, 0x4A, 0x4A, 0x9D, 0x0C, 0x08, 0x98, 0x29, 0x0F, 0x49, 0x0F, + 0x9D, 0x14, 0x08, 0x60, 0x29, 0x07, 0x85, 0xFC, 0x8A, 0xA6, 0xFC, 0x29, 0x3F, 0xF0, 0xE2, 0x9D, + 0xE4, 0x07, 0xA9, 0x00, 0x9D, 0xBC, 0x07, 0xB9, 0xFF, 0xFF, 0x9D, 0x1C, 0x08, 0x85, 0xFC, 0xB9, + 0xFF, 0xFF, 0x9D, 0x24, 0x08, 0x85, 0xFD, 0x05, 0xFC, 0xF0, 0xB6, 0xA0, 0x4A, 0xB1, 0xFC, 0x9D, + 0x34, 0x08, 0x9D, 0x44, 0x08, 0xC8, 0xB1, 0xFC, 0x9D, 0x3C, 0x08, 0x9D, 0x4C, 0x08, 0xC8, 0xB1, + 0xFC, 0x29, 0x70, 0x4A, 0x4A, 0x9D, 0x54, 0x08, 0xB1, 0xFC, 0x29, 0x0F, 0x9D, 0x5C, 0x08, 0xB1, + 0xFC, 0x10, 0x0B, 0xBD, 0x5C, 0x08, 0x49, 0xFF, 0x18, 0x69, 0x01, 0x9D, 0x5C, 0x08, 0xC8, 0xB1, + 0xFC, 0x9D, 0x74, 0x08, 0xC8, 0xB1, 0xFC, 0x29, 0x3F, 0x9D, 0x7C, 0x08, 0x9D, 0x84, 0x08, 0xC8, + 0xB1, 0xFC, 0x29, 0x80, 0xF0, 0x02, 0xA9, 0x01, 0x9D, 0xAC, 0x08, 0xB1, 0xFC, 0x29, 0x70, 0x4A, + 0x4A, 0x4A, 0x4A, 0x9D, 0x8C, 0x08, 0xD0, 0x03, 0x9D, 0xAC, 0x08, 0xB1, 0xFC, 0x29, 0x0F, 0x9D, + 0x9C, 0x08, 0x9D, 0xA4, 0x08, 0x88, 0xB1, 0xFC, 0x29, 0xC0, 0x18, 0x7D, 0xE4, 0x07, 0x9D, 0xE4, + 0x07, 0x9D, 0x22, 0x05, 0xA8, 0xB9, 0x3C, 0x06, 0x9D, 0xF4, 0x07, 0xA9, 0x00, 0x9D, 0x2C, 0x08, + 0x9D, 0x64, 0x08, 0x9D, 0x6C, 0x08, 0x9D, 0x94, 0x08, 0xA9, 0x01, 0x9D, 0xBC, 0x07, 0x60 +}; +static const unsigned char tm2_obx[] = { + 0xFF, 0xFF, 0x00, 0x02, 0x6B, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, + 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, + 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, + 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, + 0x07, 0x07, 0x08, 0x09, 0x09, 0x0A, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, + 0x07, 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x0D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0xF1, 0xE4, 0xD7, 0xCB, 0xC0, 0xB5, 0xAA, 0xA1, 0x98, + 0x8F, 0x87, 0x7F, 0x78, 0x72, 0x6B, 0x65, 0x5F, 0x5A, 0x55, 0x50, 0x4B, 0x47, 0x43, 0x3F, 0x3C, + 0x38, 0x35, 0x32, 0x2F, 0x2C, 0x2A, 0x27, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, + 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0xF2, 0xE9, 0xDA, 0xCE, 0xBF, 0xB6, 0xAA, 0xA1, 0x98, + 0x8F, 0x89, 0x80, 0x7A, 0x71, 0x6B, 0x65, 0x5F, 0x5C, 0x56, 0x50, 0x4D, 0x47, 0x44, 0x3E, 0x3C, + 0x38, 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, + 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0xFF, 0xF1, 0xE4, 0xD8, 0xCA, 0xC0, 0xB5, 0xAB, 0xA2, + 0x99, 0x8E, 0x87, 0x7F, 0x79, 0x73, 0x70, 0x66, 0x61, 0x5A, 0x55, 0x52, 0x4B, 0x48, 0x43, 0x3F, + 0x3C, 0x39, 0x37, 0x33, 0x30, 0x2D, 0x2A, 0x28, 0x25, 0x24, 0x21, 0x1F, 0x1E, 0x1C, 0x1B, 0x19, + 0x17, 0x16, 0x15, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, + 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xF3, 0xE6, 0xD9, 0xCC, 0xC1, 0xB5, 0xAD, 0xA2, 0x99, + 0x90, 0x88, 0x80, 0x79, 0x72, 0x6C, 0x66, 0x60, 0x5B, 0x55, 0x51, 0x4C, 0x48, 0x44, 0x40, 0x3C, + 0x39, 0x35, 0x32, 0x2F, 0x2D, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, 0x1C, 0x1A, 0x18, 0x17, + 0x16, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, 0x6A, 0xEF, 0x80, 0x08, + 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, 0x52, 0x22, 0xF4, 0xC8, + 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, 0x4E, 0x38, 0x27, 0x15, + 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, 0x7F, 0x78, 0x70, 0x6A, + 0x64, 0x5E, 0x57, 0x52, 0x32, 0x0A, 0x00, 0xF2, 0x33, 0x96, 0xE2, 0x38, 0x8C, 0x00, 0x6A, 0xE8, + 0x6A, 0xEF, 0x80, 0x08, 0xAE, 0x46, 0xE6, 0x95, 0x41, 0xF6, 0xB0, 0x6E, 0x30, 0xF6, 0xBB, 0x84, + 0x52, 0x22, 0xF4, 0xC8, 0xA0, 0x7A, 0x55, 0x34, 0x14, 0xF5, 0xD8, 0xBD, 0xA4, 0x8D, 0x77, 0x60, + 0x4E, 0x38, 0x27, 0x15, 0x06, 0xF7, 0xE8, 0xDB, 0xCF, 0xC3, 0xB8, 0xAC, 0xA2, 0x9A, 0x90, 0x88, + 0x7F, 0x78, 0x70, 0x6A, 0x64, 0x5E, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, + 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4C, 0xE4, 0x0D, 0x4C, 0xE3, 0x06, 0x4C, 0x9F, 0x08, 0x01, + 0x10, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, + 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x02, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x10, + 0x00, 0x08, 0x00, 0x10, 0x00, 0x08, 0x85, 0xD3, 0x81, 0xA9, 0x85, 0xD3, 0x81, 0xA9, 0x88, 0xB1, + 0xFA, 0x8D, 0x17, 0x05, 0xA2, 0x00, 0x86, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, + 0xFC, 0x0A, 0x26, 0xFC, 0x6D, 0x17, 0x05, 0x90, 0x02, 0xE6, 0xFC, 0x18, 0x69, 0x00, 0x85, 0xFA, + 0xA5, 0xFC, 0x69, 0x00, 0x85, 0xFB, 0x4C, 0x07, 0x07, 0x20, 0xB5, 0x09, 0xAD, 0x16, 0x05, 0xF0, + 0x05, 0xCE, 0x1C, 0x05, 0x30, 0x03, 0x4C, 0xA2, 0x08, 0xCE, 0x1D, 0x05, 0xD0, 0x52, 0xA2, 0x00, + 0xEE, 0x17, 0x05, 0xAD, 0x19, 0x05, 0x85, 0xFA, 0xAD, 0x1A, 0x05, 0x85, 0xFB, 0xA0, 0x10, 0xB1, + 0xFA, 0x30, 0xAB, 0xD0, 0x03, 0x4C, 0x2C, 0x0F, 0x8D, 0x1D, 0x05, 0x88, 0xB1, 0xFA, 0x88, 0x84, + 0xFC, 0xA8, 0xB9, 0xFF, 0xFF, 0x9D, 0x50, 0x05, 0xB9, 0xFF, 0xFF, 0x9D, 0x58, 0x05, 0xA9, 0x00, + 0x9D, 0x70, 0x05, 0x9D, 0x60, 0x05, 0xA4, 0xFC, 0xB1, 0xFA, 0x9D, 0x68, 0x05, 0xE8, 0x88, 0x10, + 0xDB, 0xA9, 0x11, 0x18, 0x65, 0xFA, 0x8D, 0x19, 0x05, 0xA9, 0x00, 0x65, 0xFB, 0x8D, 0x1A, 0x05, + 0xAD, 0x1B, 0x05, 0x8D, 0x1C, 0x05, 0xA2, 0x07, 0xDE, 0x70, 0x05, 0x30, 0x06, 0xCA, 0x10, 0xF8, + 0x4C, 0xA2, 0x08, 0xBD, 0x50, 0x05, 0x85, 0xFA, 0xBD, 0x58, 0x05, 0x85, 0xFB, 0xBC, 0x60, 0x05, + 0xB1, 0xFA, 0xD0, 0x1C, 0xC8, 0xB1, 0xFA, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, 0xB1, + 0xFA, 0x0A, 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0x4C, 0x57, 0x07, + 0xC9, 0x40, 0xB0, 0x4F, 0x7D, 0x68, 0x05, 0x9D, 0x98, 0x05, 0xC8, 0xB1, 0xFA, 0x10, 0x25, 0x29, + 0x7F, 0x85, 0xFC, 0xC8, 0xB1, 0xFA, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, 0xB1, 0xFA, + 0x0A, 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0xA4, 0xFC, 0x20, 0x9C, + 0x0F, 0x4C, 0x57, 0x07, 0xA8, 0xFE, 0x60, 0x05, 0xFE, 0x60, 0x05, 0xBD, 0xD0, 0x05, 0x29, 0xF0, + 0x9D, 0xD8, 0x05, 0xBD, 0xD0, 0x05, 0x0A, 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0x20, 0x9C, 0x0F, + 0x4C, 0x57, 0x07, 0xC9, 0x80, 0xB0, 0x25, 0x29, 0x3F, 0x18, 0x7D, 0x68, 0x05, 0x9D, 0x98, 0x05, + 0xC8, 0xB1, 0xFA, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, 0xB1, 0xFA, 0x0A, 0x0A, 0x0A, + 0x0A, 0x9D, 0xE0, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xD0, 0x0E, 0xC8, 0xB1, + 0xFA, 0x9D, 0x70, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xC9, 0xC0, 0xB0, 0x0F, + 0x29, 0x3F, 0x18, 0x7D, 0x68, 0x05, 0x9D, 0x98, 0x05, 0xFE, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xC9, + 0xD0, 0xB0, 0x0F, 0xC8, 0xFE, 0x60, 0x05, 0x29, 0x0F, 0x8D, 0x1B, 0x05, 0x8D, 0x1C, 0x05, 0x4C, + 0x6A, 0x07, 0xC9, 0xE0, 0xB0, 0x16, 0xB1, 0xFA, 0x85, 0xFC, 0xC8, 0xB1, 0xFA, 0x85, 0xFD, 0xC8, + 0x98, 0x9D, 0x60, 0x05, 0xA5, 0xFC, 0x20, 0x0E, 0x0E, 0x4C, 0x57, 0x07, 0xC9, 0xF0, 0xB0, 0x2E, + 0xB1, 0xFA, 0x85, 0xFC, 0xC8, 0xB1, 0xFA, 0x85, 0xFD, 0xA5, 0xFC, 0x20, 0x0E, 0x0E, 0xBC, 0x60, + 0x05, 0xC8, 0xC8, 0xB1, 0xFA, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, 0xB1, 0xFA, 0x0A, + 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0xC8, 0x98, 0x9D, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xC9, 0xFF, + 0xB0, 0x0B, 0xE9, 0xEF, 0x9D, 0x70, 0x05, 0xFE, 0x60, 0x05, 0x4C, 0x57, 0x07, 0xA9, 0x40, 0x9D, + 0x70, 0x05, 0x4C, 0x57, 0x07, 0x20, 0xB5, 0x09, 0xA2, 0x07, 0xBD, 0x78, 0x05, 0xF0, 0x73, 0x4C, + 0xD9, 0x0A, 0xBD, 0x0E, 0x05, 0xF0, 0x0E, 0xA9, 0x00, 0x9D, 0x20, 0x05, 0x9D, 0x28, 0x05, 0xCA, + 0x10, 0xE8, 0x4C, 0x1F, 0x09, 0xA4, 0xFD, 0xB9, 0x00, 0x03, 0x18, 0x65, 0xFC, 0x9D, 0x38, 0x05, + 0x98, 0x9D, 0xA0, 0x05, 0xBD, 0xB0, 0x05, 0x3D, 0xA8, 0x06, 0xF0, 0x28, 0xA5, 0xFD, 0x29, 0x7F, + 0xA8, 0xB9, 0x00, 0x04, 0x18, 0x65, 0xFC, 0x9D, 0x37, 0x05, 0xB9, 0x80, 0x04, 0x69, 0x00, 0x9D, + 0x38, 0x05, 0xA9, 0x00, 0x9D, 0x1F, 0x05, 0xBC, 0x98, 0x06, 0x99, 0x27, 0x05, 0xCA, 0xCA, 0x10, + 0xA9, 0x4C, 0x1F, 0x09, 0xBD, 0xB0, 0x05, 0x3D, 0xA0, 0x06, 0xF0, 0x16, 0xBD, 0x68, 0x06, 0x18, + 0x65, 0xFD, 0x9D, 0xA2, 0x05, 0xA8, 0xB9, 0x00, 0x03, 0x18, 0x65, 0xFC, 0x38, 0x65, 0xFE, 0x9D, + 0x3A, 0x05, 0xCA, 0x10, 0x85, 0xE8, 0x86, 0xFC, 0xA2, 0x03, 0xAD, 0x09, 0x05, 0xF0, 0x06, 0x29, + 0x40, 0xD0, 0x3C, 0xA2, 0x07, 0x8A, 0xA8, 0xB9, 0x20, 0x05, 0xD0, 0x0C, 0xBC, 0x98, 0x06, 0xB9, + 0x28, 0x05, 0xD0, 0x04, 0x8A, 0xA8, 0xA9, 0x00, 0x19, 0xA8, 0x05, 0x9D, 0x30, 0x05, 0xB9, 0x38, + 0x05, 0x9D, 0x48, 0x05, 0xB9, 0xA0, 0x05, 0x9D, 0x40, 0x05, 0xB9, 0xB0, 0x05, 0x05, 0xFC, 0x85, + 0xFC, 0xE0, 0x04, 0xD0, 0x03, 0x8D, 0x1F, 0x05, 0xCA, 0x10, 0xCA, 0x8D, 0x1E, 0x05, 0x60, 0xBD, + 0x20, 0x05, 0x1D, 0xA8, 0x05, 0x9D, 0x30, 0x05, 0xBD, 0x2C, 0x05, 0x1D, 0xAC, 0x05, 0x9D, 0x34, + 0x05, 0xBD, 0x38, 0x05, 0x9D, 0x48, 0x05, 0xBD, 0x3C, 0x05, 0x9D, 0x4C, 0x05, 0xBD, 0xA0, 0x05, + 0x9D, 0x40, 0x05, 0xBD, 0xA4, 0x05, 0x9D, 0x44, 0x05, 0xCA, 0x10, 0xD3, 0xAD, 0xB0, 0x05, 0x0D, + 0xB1, 0x05, 0x0D, 0xB2, 0x05, 0x0D, 0xB3, 0x05, 0x8D, 0x1E, 0x05, 0xAD, 0xB4, 0x05, 0x0D, 0xB5, + 0x05, 0x0D, 0xB6, 0x05, 0x0D, 0xB7, 0x05, 0x8D, 0x1F, 0x05, 0x60, 0xAD, 0x09, 0x05, 0xD0, 0x03, + 0x4C, 0x90, 0x0A, 0x30, 0x03, 0x4C, 0x48, 0x0A, 0xAD, 0x0D, 0x05, 0xAA, 0x4A, 0x4A, 0x29, 0x01, + 0xA8, 0xB9, 0x1E, 0x05, 0x8D, 0x38, 0xD2, 0x8A, 0x29, 0x04, 0xA8, 0xB9, 0x38, 0x05, 0x8D, 0x30, + 0xD2, 0xBD, 0x20, 0x05, 0x8D, 0x31, 0xD2, 0xB9, 0x39, 0x05, 0x8D, 0x32, 0xD2, 0xBD, 0x21, 0x05, + 0x8D, 0x33, 0xD2, 0xB9, 0x3A, 0x05, 0x8D, 0x34, 0xD2, 0xBD, 0x22, 0x05, 0x8D, 0x35, 0xD2, 0xB9, + 0x3B, 0x05, 0x8D, 0x36, 0xD2, 0xBD, 0x23, 0x05, 0x8D, 0x37, 0xD2, 0xAD, 0x0C, 0x05, 0xAA, 0x4A, + 0x4A, 0x29, 0x01, 0xA8, 0xB9, 0x1E, 0x05, 0x8D, 0x28, 0xD2, 0x8A, 0x29, 0x04, 0xA8, 0xB9, 0x38, + 0x05, 0x8D, 0x20, 0xD2, 0xBD, 0x20, 0x05, 0x8D, 0x21, 0xD2, 0xB9, 0x39, 0x05, 0x8D, 0x22, 0xD2, + 0xBD, 0x21, 0x05, 0x8D, 0x23, 0xD2, 0xB9, 0x3A, 0x05, 0x8D, 0x24, 0xD2, 0xBD, 0x22, 0x05, 0x8D, + 0x25, 0xD2, 0xB9, 0x3B, 0x05, 0x8D, 0x26, 0xD2, 0xBD, 0x23, 0x05, 0x8D, 0x27, 0xD2, 0xAD, 0x0B, + 0x05, 0xAA, 0x4A, 0x4A, 0x29, 0x01, 0xA8, 0xB9, 0x1E, 0x05, 0x8D, 0x18, 0xD2, 0x8A, 0xAC, 0x09, + 0x05, 0x10, 0x02, 0x29, 0x04, 0xA8, 0xB9, 0x38, 0x05, 0x8D, 0x10, 0xD2, 0xBD, 0x20, 0x05, 0x8D, + 0x11, 0xD2, 0xB9, 0x39, 0x05, 0x8D, 0x12, 0xD2, 0xBD, 0x21, 0x05, 0x8D, 0x13, 0xD2, 0xB9, 0x3A, + 0x05, 0x8D, 0x14, 0xD2, 0xBD, 0x22, 0x05, 0x8D, 0x15, 0xD2, 0xB9, 0x3B, 0x05, 0x8D, 0x16, 0xD2, + 0xBD, 0x23, 0x05, 0x8D, 0x17, 0xD2, 0xAD, 0x0A, 0x05, 0xAA, 0x4A, 0x4A, 0x29, 0x01, 0xA8, 0xB9, + 0x1E, 0x05, 0x8D, 0x08, 0xD2, 0x8A, 0xAC, 0x09, 0x05, 0x10, 0x02, 0x29, 0x04, 0xA8, 0xB9, 0x38, + 0x05, 0x8D, 0x00, 0xD2, 0xBD, 0x20, 0x05, 0x8D, 0x01, 0xD2, 0xB9, 0x39, 0x05, 0x8D, 0x02, 0xD2, + 0xBD, 0x21, 0x05, 0x8D, 0x03, 0xD2, 0xB9, 0x3A, 0x05, 0x8D, 0x04, 0xD2, 0xBD, 0x22, 0x05, 0x8D, + 0x05, 0xD2, 0xB9, 0x3B, 0x05, 0x8D, 0x06, 0xD2, 0xBD, 0x23, 0x05, 0x8D, 0x07, 0xD2, 0x60, 0xBD, + 0x80, 0x05, 0x85, 0xFA, 0xBD, 0x88, 0x05, 0x85, 0xFB, 0xBD, 0x80, 0x06, 0x85, 0xFC, 0xBD, 0x88, + 0x06, 0x85, 0xFD, 0xBD, 0x90, 0x06, 0x85, 0xFE, 0xBD, 0xB8, 0x05, 0xDD, 0xC0, 0x05, 0x90, 0x0C, + 0x9D, 0x08, 0x06, 0xBD, 0xC8, 0x05, 0x9D, 0xB8, 0x05, 0x4C, 0x0B, 0x0B, 0xBD, 0x08, 0x06, 0xF0, + 0x30, 0xBD, 0xE8, 0x05, 0xF0, 0x13, 0xDE, 0xF8, 0x05, 0xD0, 0x0E, 0x9D, 0xF8, 0x05, 0xBD, 0xD8, + 0x05, 0xF0, 0x06, 0x38, 0xE9, 0x10, 0x9D, 0xD8, 0x05, 0xBD, 0xF0, 0x05, 0xF0, 0x13, 0xDE, 0x00, + 0x06, 0xD0, 0x0E, 0x9D, 0x00, 0x06, 0xBD, 0xE0, 0x05, 0xF0, 0x06, 0x38, 0xE9, 0x10, 0x9D, 0xE0, + 0x05, 0xBC, 0x48, 0x06, 0xB1, 0xFA, 0x18, 0x7D, 0x98, 0x05, 0x18, 0x65, 0xFD, 0x85, 0xFD, 0xDE, + 0x58, 0x06, 0x10, 0x39, 0xBD, 0x50, 0x06, 0x9D, 0x58, 0x06, 0xBD, 0x60, 0x06, 0xF0, 0x1E, 0x18, + 0x7D, 0x48, 0x06, 0x9D, 0x48, 0x06, 0xF0, 0x0D, 0xDD, 0x40, 0x06, 0x90, 0x20, 0xA9, 0xFF, 0x9D, + 0x60, 0x06, 0x4C, 0x87, 0x0B, 0xA9, 0x01, 0x9D, 0x60, 0x06, 0x4C, 0x87, 0x0B, 0xFE, 0x48, 0x06, + 0xBD, 0x40, 0x06, 0xDD, 0x48, 0x06, 0xB0, 0x05, 0xA9, 0x00, 0x9D, 0x48, 0x06, 0xA9, 0x13, 0x18, + 0x65, 0xFA, 0x85, 0xFA, 0x90, 0x02, 0xE6, 0xFB, 0xBC, 0xB8, 0x05, 0xB1, 0xFA, 0x29, 0xF0, 0x9D, + 0xA8, 0x05, 0xB1, 0xFA, 0x29, 0x0F, 0x1D, 0xD8, 0x05, 0xA8, 0xB9, 0x00, 0x02, 0x05, 0xFF, 0xA8, + 0xB9, 0x00, 0x02, 0x9D, 0x20, 0x05, 0xBC, 0xB8, 0x05, 0xC8, 0xB1, 0xFA, 0x29, 0x0F, 0x1D, 0xE0, + 0x05, 0xA8, 0xB9, 0x00, 0x02, 0x05, 0xFF, 0xA8, 0xB9, 0x00, 0x02, 0x9D, 0x28, 0x05, 0xBD, 0x28, + 0x06, 0xD0, 0x27, 0xBD, 0x10, 0x06, 0x8D, 0xD4, 0x0B, 0x10, 0xFE, 0x4C, 0xD1, 0x0C, 0xEA, 0x4C, + 0x6C, 0x0C, 0xEA, 0x4C, 0xA7, 0x0C, 0xEA, 0x4C, 0xD4, 0x0C, 0xEA, 0x4C, 0x01, 0x0D, 0xEA, 0x4C, + 0x21, 0x0D, 0xEA, 0x4C, 0x41, 0x0D, 0xEA, 0x4C, 0x49, 0x0D, 0xDE, 0x28, 0x06, 0xBC, 0xB8, 0x05, + 0xC8, 0xB1, 0xFA, 0x29, 0x70, 0x4A, 0x4A, 0x4A, 0x8D, 0x22, 0x0C, 0xB1, 0xFA, 0x30, 0x06, 0xBD, + 0x70, 0x06, 0x4C, 0x12, 0x0C, 0xBD, 0x78, 0x06, 0x3D, 0xB0, 0x06, 0x9D, 0xB0, 0x05, 0xC8, 0xC8, + 0x98, 0x9D, 0xB8, 0x05, 0x88, 0xB1, 0xFA, 0x90, 0xFE, 0x90, 0x16, 0x90, 0x0C, 0x90, 0x22, 0x90, + 0x18, 0x90, 0x2E, 0x90, 0x24, 0x90, 0x32, 0x90, 0x34, 0x7D, 0x80, 0x06, 0x9D, 0x80, 0x06, 0xB1, + 0xFA, 0x18, 0x65, 0xFC, 0x85, 0xFC, 0x4C, 0xAC, 0x08, 0x7D, 0x88, 0x06, 0x9D, 0x88, 0x06, 0xB1, + 0xFA, 0x18, 0x65, 0xFD, 0x85, 0xFD, 0x4C, 0xAC, 0x08, 0x7D, 0x90, 0x06, 0x9D, 0x90, 0x06, 0xB1, + 0xFA, 0x18, 0x65, 0xFE, 0x85, 0xFE, 0x4C, 0xAC, 0x08, 0x85, 0xFC, 0xA9, 0x00, 0x85, 0xFD, 0x4C, + 0xAC, 0x08, 0xBD, 0x20, 0x06, 0x29, 0x03, 0x4A, 0x90, 0x0A, 0xD0, 0x19, 0xBD, 0x18, 0x06, 0x18, + 0x65, 0xFC, 0x85, 0xFC, 0xDE, 0x38, 0x06, 0x10, 0x4E, 0xFE, 0x20, 0x06, 0xBD, 0x30, 0x06, 0x9D, + 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xA5, 0xFC, 0xFD, 0x18, 0x06, 0x85, 0xFC, 0xDE, 0x38, 0x06, 0x10, + 0x36, 0xFE, 0x20, 0x06, 0xBD, 0x30, 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xBC, 0x20, 0x06, + 0xBD, 0x18, 0x06, 0x30, 0x02, 0xC8, 0xC8, 0x88, 0x98, 0x18, 0x65, 0xFC, 0x85, 0xFC, 0xDE, 0x38, + 0x06, 0x10, 0x14, 0x98, 0x9D, 0x20, 0x06, 0xDD, 0x18, 0x06, 0xD0, 0x05, 0x49, 0xFF, 0x9D, 0x18, + 0x06, 0xBD, 0x30, 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xBC, 0x20, 0x06, 0xBD, 0x18, 0x06, + 0x30, 0x02, 0xC8, 0xC8, 0x88, 0x98, 0x18, 0x65, 0xFD, 0x85, 0xFD, 0xDE, 0x38, 0x06, 0x10, 0xE7, + 0x98, 0x9D, 0x20, 0x06, 0xDD, 0x18, 0x06, 0xD0, 0xD8, 0x49, 0xFF, 0x9D, 0x18, 0x06, 0xBD, 0x30, + 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xBD, 0x20, 0x06, 0x18, 0x65, 0xFC, 0x85, 0xFC, 0xDE, + 0x38, 0x06, 0x10, 0xC3, 0xBD, 0x18, 0x06, 0x18, 0x7D, 0x20, 0x06, 0x9D, 0x20, 0x06, 0xBD, 0x30, + 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xA5, 0xFD, 0x38, 0xFD, 0x20, 0x06, 0x85, 0xFD, 0xDE, + 0x38, 0x06, 0x10, 0xA3, 0xBD, 0x18, 0x06, 0x18, 0x7D, 0x20, 0x06, 0x9D, 0x20, 0x06, 0xBD, 0x30, + 0x06, 0x9D, 0x38, 0x06, 0x4C, 0xF7, 0x0B, 0xBD, 0x18, 0x06, 0x18, 0x65, 0xFC, 0x85, 0xFC, 0x4C, + 0xF7, 0x0B, 0xA0, 0x10, 0xA9, 0x00, 0x85, 0xFA, 0xA9, 0x00, 0x85, 0xFB, 0xA9, 0x00, 0x8D, 0x17, + 0x05, 0x8A, 0xF0, 0x3F, 0xB1, 0xFA, 0xF0, 0x02, 0x10, 0x01, 0xCA, 0xA9, 0x11, 0x18, 0x65, 0xFA, + 0x85, 0xFA, 0x90, 0x02, 0xE6, 0xFB, 0xEE, 0x17, 0x05, 0xD0, 0xE6, 0xA2, 0x00, 0xA9, 0x00, 0x85, + 0xFC, 0x8A, 0x8D, 0x17, 0x05, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, 0xFC, 0x0A, 0x26, + 0xFC, 0x6D, 0x17, 0x05, 0x90, 0x02, 0xE6, 0xFC, 0x18, 0x69, 0x00, 0x85, 0xFA, 0xA5, 0xFC, 0x69, + 0x00, 0x85, 0xFB, 0x20, 0x2C, 0x0F, 0xA5, 0xFA, 0x8D, 0x19, 0x05, 0xA5, 0xFB, 0x8D, 0x1A, 0x05, + 0xA2, 0x07, 0xA9, 0xFF, 0x9D, 0xD0, 0x05, 0xA9, 0xF0, 0x9D, 0xD8, 0x05, 0x9D, 0xE0, 0x05, 0xCA, + 0x10, 0xF0, 0xA9, 0x03, 0x8D, 0x0F, 0xD2, 0x8D, 0x1F, 0xD2, 0x8D, 0x2F, 0xD2, 0x8D, 0x3F, 0xD2, + 0xCE, 0x17, 0x05, 0xE8, 0x8E, 0x1C, 0x05, 0xE8, 0x8E, 0x1D, 0x05, 0x8E, 0x16, 0x05, 0x60, 0x8A, + 0x29, 0x0F, 0x8D, 0x1B, 0x05, 0x60, 0x8E, 0x16, 0x05, 0x60, 0xC9, 0x10, 0xB0, 0x03, 0x4C, 0x4C, + 0x0D, 0xC9, 0x20, 0x90, 0x88, 0xC9, 0x30, 0xB0, 0x03, 0x4C, 0x85, 0x0F, 0xC9, 0x40, 0x90, 0xDF, + 0xC9, 0x50, 0xB0, 0x03, 0x4C, 0x2C, 0x0F, 0xC9, 0x60, 0x90, 0xDB, 0xC9, 0x70, 0x90, 0x03, 0x4C, + 0xB4, 0x0E, 0x84, 0xFD, 0x29, 0x0F, 0x0A, 0x8D, 0x17, 0x0E, 0xA5, 0xFD, 0x90, 0xFE, 0x90, 0x1E, + 0x90, 0x38, 0x90, 0x59, 0x90, 0x60, 0x90, 0x1A, 0x90, 0x1C, 0x90, 0x1E, 0x90, 0x20, 0x90, 0x22, + 0x90, 0x24, 0x90, 0x0D, 0x90, 0x0B, 0x90, 0x09, 0x90, 0x07, 0x90, 0x05, 0x90, 0x03, 0x8D, 0x18, + 0x05, 0x60, 0x9D, 0x68, 0x06, 0x60, 0x9D, 0x70, 0x06, 0x60, 0x9D, 0x78, 0x06, 0x60, 0x9D, 0x90, + 0x06, 0x60, 0x9D, 0x80, 0x06, 0x60, 0x9D, 0x88, 0x06, 0x60, 0x29, 0x70, 0x4A, 0x4A, 0x9D, 0x10, + 0x06, 0x29, 0x30, 0xD0, 0x03, 0x9D, 0x20, 0x06, 0xA5, 0xFD, 0x30, 0x06, 0x29, 0x0F, 0x9D, 0x18, + 0x06, 0x60, 0x29, 0x0F, 0x49, 0xFF, 0x18, 0x69, 0x01, 0x9D, 0x18, 0x06, 0x60, 0x29, 0x3F, 0x9D, + 0x30, 0x06, 0x9D, 0x38, 0x06, 0x60, 0x29, 0x80, 0x0A, 0x2A, 0x9D, 0x60, 0x06, 0xA5, 0xFD, 0x29, + 0x70, 0x4A, 0x4A, 0x4A, 0x4A, 0x9D, 0x40, 0x06, 0xD0, 0x03, 0x9D, 0x60, 0x06, 0xA5, 0xFD, 0x29, + 0x0F, 0x9D, 0x50, 0x06, 0x9D, 0x58, 0x06, 0xBD, 0x48, 0x06, 0xDD, 0x40, 0x06, 0x90, 0x8F, 0xBD, + 0x40, 0x06, 0xF0, 0x02, 0xE9, 0x01, 0x9D, 0x48, 0x06, 0x60, 0x84, 0xFA, 0x86, 0xFB, 0xA0, 0x19, + 0xB1, 0xFA, 0xC8, 0x8D, 0x09, 0x05, 0xB1, 0xFA, 0xC8, 0x8D, 0x0A, 0x05, 0xB1, 0xFA, 0xC8, 0x8D, + 0x0B, 0x05, 0xB1, 0xFA, 0xC8, 0x8D, 0x0C, 0x05, 0xB1, 0xFA, 0xC8, 0x8D, 0x0D, 0x05, 0xB1, 0xFA, + 0x8D, 0x1B, 0x05, 0xA5, 0xFA, 0x49, 0x80, 0x30, 0x01, 0xE8, 0x8D, 0xAC, 0x0F, 0x8E, 0xAD, 0x0F, + 0x49, 0x80, 0x30, 0x01, 0xE8, 0x8D, 0x1D, 0x07, 0x8E, 0x1E, 0x07, 0xE8, 0x8D, 0x23, 0x07, 0x8E, + 0x24, 0x07, 0xE8, 0x8D, 0xA2, 0x0F, 0x8E, 0xA3, 0x0F, 0x49, 0x80, 0x30, 0x01, 0xE8, 0x8D, 0x19, + 0x05, 0x8D, 0xD7, 0x06, 0x8D, 0x4F, 0x0D, 0x8D, 0x94, 0x0D, 0x8E, 0x1A, 0x05, 0x8E, 0xDD, 0x06, + 0x8E, 0x53, 0x0D, 0x8E, 0x9A, 0x0D, 0xA9, 0xF0, 0x85, 0xFF, 0xA9, 0x00, 0x8D, 0x16, 0x05, 0x8D, + 0x18, 0x05, 0xA2, 0x07, 0xA9, 0x00, 0x8D, 0x16, 0x05, 0x9D, 0x78, 0x05, 0x9D, 0xB0, 0x05, 0x9D, + 0x20, 0x05, 0x9D, 0x28, 0x05, 0x9D, 0x30, 0x05, 0x9D, 0x30, 0xD2, 0x9D, 0x20, 0xD2, 0x9D, 0x10, + 0xD2, 0x9D, 0x00, 0xD2, 0xCA, 0x10, 0xE2, 0x8D, 0x18, 0xD2, 0x8D, 0x08, 0xD2, 0x8D, 0x38, 0xD2, + 0x8D, 0x28, 0xD2, 0x8D, 0x1E, 0x05, 0x8D, 0x1F, 0x05, 0x60, 0x9D, 0x20, 0x05, 0x9D, 0x28, 0x05, + 0x9D, 0x30, 0x05, 0x9D, 0xB0, 0x05, 0x60, 0x98, 0x9D, 0xD0, 0x05, 0x29, 0xF0, 0x9D, 0xD8, 0x05, + 0xBD, 0xD0, 0x05, 0x0A, 0x0A, 0x0A, 0x0A, 0x9D, 0xE0, 0x05, 0x60, 0x29, 0x07, 0x85, 0xFA, 0x8A, + 0xA6, 0xFA, 0x29, 0x3F, 0xF0, 0xE1, 0x9D, 0x98, 0x05, 0x98, 0x30, 0xEE, 0xBD, 0xD0, 0x05, 0x20, + 0x75, 0x0F, 0xA9, 0x00, 0x9D, 0x78, 0x05, 0xB9, 0xFF, 0xFF, 0xF0, 0xBE, 0x9D, 0x88, 0x05, 0x85, + 0xFB, 0xB9, 0xFF, 0xFF, 0x9D, 0x80, 0x05, 0x85, 0xFA, 0x98, 0x9D, 0x90, 0x05, 0xA0, 0x08, 0xB1, + 0xFA, 0xC8, 0x9D, 0xC0, 0x05, 0xB1, 0xFA, 0xC8, 0x9D, 0xC8, 0x05, 0xB1, 0xFA, 0xC8, 0x9D, 0x68, + 0x06, 0xB1, 0xFA, 0xC8, 0x9D, 0x70, 0x06, 0xB1, 0xFA, 0xC8, 0x9D, 0x78, 0x06, 0xB1, 0xFA, 0xC8, + 0x9D, 0xE8, 0x05, 0x9D, 0xF8, 0x05, 0xB1, 0xFA, 0xC8, 0x9D, 0xF0, 0x05, 0x9D, 0x00, 0x06, 0xB1, + 0xFA, 0x29, 0x70, 0x4A, 0x4A, 0x9D, 0x10, 0x06, 0xB1, 0xFA, 0xC8, 0x30, 0x08, 0x29, 0x0F, 0x9D, + 0x18, 0x06, 0x4C, 0x09, 0x10, 0x29, 0x0F, 0x49, 0xFF, 0x18, 0x69, 0x01, 0x9D, 0x18, 0x06, 0xB1, + 0xFA, 0xC8, 0x9D, 0x28, 0x06, 0xB1, 0xFA, 0xC8, 0x29, 0x3F, 0x9D, 0x30, 0x06, 0x9D, 0x38, 0x06, + 0xB1, 0xFA, 0x29, 0x80, 0x0A, 0x2A, 0x9D, 0x60, 0x06, 0xB1, 0xFA, 0x29, 0x70, 0x4A, 0x4A, 0x4A, + 0x4A, 0x9D, 0x40, 0x06, 0xD0, 0x03, 0x9D, 0x60, 0x06, 0xB1, 0xFA, 0x88, 0x29, 0x0F, 0x9D, 0x50, + 0x06, 0x9D, 0x58, 0x06, 0xB1, 0xFA, 0x29, 0xC0, 0x1D, 0x98, 0x05, 0x9D, 0x98, 0x05, 0xA8, 0xB9, + 0x00, 0x03, 0x9D, 0x38, 0x05, 0xA9, 0x00, 0x9D, 0xB8, 0x05, 0x9D, 0x20, 0x06, 0x9D, 0x08, 0x06, + 0x9D, 0x48, 0x06, 0x9D, 0x80, 0x06, 0x9D, 0x88, 0x06, 0x9D, 0x90, 0x06, 0xA9, 0x01, 0x9D, 0x78, + 0x05, 0x60 +}; Index: apps/plugins/asap/players/cmc.asx =================================================================== --- apps/plugins/asap/players/cmc.asx (revision 0) +++ apps/plugins/asap/players/cmc.asx (revision 0) @@ -0,0 +1,944 @@ +*---------------------------* +* cmc player v 2.1 * +* by Marcin Lewandowski * +* based on cmc player v 2.0 * +* by Janusz Pelc * +*---------------------------* + + org $0500 + +*--- strona 0 + +addr equ $fc +word equ $fe + +*--- skoki + + jmp basic + jmp init + jmp play + +*--- dane + +volume dta d' ' +czest dta d' ' +numins dta d' ' + + dta c' cmc player v 2.1 '* + +frq dta d' ' +znieks dta d' ' +audc dta b(0) + +czest1 dta d' ' +czest2 dta d' ' +czest3 dta d' ' +zniek dta d' ' +count1 dta b($ff),b($ff),b($ff) +count2 dta d' ' +lopad dta d' ' +numptr dta d' ' +poswpt dta d' ' +ilewol dta d' ' +czygrx dta b($80),b($80),b($80) +czygrc dta b($80) + +dana0 dta d' ' +dana1 dta d' ' +dana2 dta d' ' +dana3 dta d' ' +dana4 dta d' ' +dana5 dta d' ' +ladr dta d' ' +hadr dta d' ' + +posptr dta b(0) +possng dta b(0) +pocrep dta b(0) +konrep dta b(0) +ilrep dta b(0) +tmpo dta b(0) +ltemp dta b(0) +b1 dta b(0) +b2 dta b(0) +b3 dta b(0) +czygr dta b(0) + +adrmus dta a(0) +adradr dta a(0) +adrsng dta a(0) + +*--- init + +init sta b1 + stx b2 + sty b3 + and #$70 + lsr @ + lsr @ + lsr @ + tax + lda tab1,x + sta zm1+1 + lda tab1+1,x + sta zm1+2 + lda #3 + sta $d20f + cld + lda word + pha + lda word+1 + pha + ldy b3 + ldx b2 + lda b1 +zm1 jsr graj + pla + sta word+1 + pla + sta word + rts + +graj lda adrsng + sta word + lda adrsng+1 + sta word+1 + ldy #0 + txa + beq grajx +l1 lda (word),y + cmp #$8f + beq l2 + cmp #$ef + bne l3 +l2 dex + bne l3 + iny + cpy #$54 + bcs l4 + tya + tax + bpl grajx +l3 iny + cpy #$54 + bcc l1 +l4 rts + +grajx stx possng + jsr skoncz + lda #0 + ldx #9 +l5 sta poswpt,x + dex + bpl l5 + sta posptr + lda #1 + sta czygr + lda #$ff + sta konrep + lda adrmus + sta word + lda adrmus+1 + sta word+1 + ldy #$13 + lda (word),y + tax + lda adrsng + sta word + lda adrsng+1 + sta word+1 + ldy possng +l6 lda (word),y + cmp #$cf + bne l7 + tya + clc + adc #$55 + tay + lda (word),y + bmi l8 + tax + jmp l8 +l7 cmp #$8f + beq l8 + cmp #$ef + beq l8 + dey + bpl l6 +l8 stx tmpo + stx ltemp + rts + +tempo and #$f + beq l8 + stx d0+1 + stx d1+1 + stx d2+1 + sty d0+2 + sty d1+2 + sty d2+2 + rts + +inic stx adrmus + stx word + sty adrmus+1 + sty word+1 + clc + txa + adc #$14 + sta adradr + tya + adc #0 + sta adradr+1 + stx adrsng + iny + iny + sty adrsng+1 + ldy #$13 + lda (word),y + sta tmpo + sta ltemp + +skoncz ldx #8 +l9 lda #0 + sta czygr + sta $d200,x + cpx #3 + bcs l10 + sta volume,x + lda #$ff + sta count1,x +l10 dex + bpl l9 + +przer lda #$80 +l11 ldx #3 +l12 sta czygrx,x + dex + bpl l12 +l13 rts + +kont lda #1 + sta czygr + lda #0 + beq l11 + +instr and #3 + cmp #3 + beq l13 + cpx #$40 + bcs l13 + cpy #26 + bcs l13 + tax + lda #$80 + sta czygrx,x + +inst lda #0 + sta count1,x + sta count2,x + sta lopad,x + lda b2 + sta czest,x + + lda b3 + asl @ + asl @ + asl @ + sta word + clc + lda adrmus + adc #$30 + pha + lda adrmus+1 + adc #1 + tay + pla + clc + adc word + sta ladr,x + tya + adc #0 + sta hadr,x + + clc + lda adrmus + adc #$94 + sta word + lda adrmus+1 + adc #0 + sta word+1 + lda b3 + asl @ + adc b3 + asl @ + tay + lda (word),y + sta dana0,x + iny + lda (word),y + sta dana1,x + and #7 + sta b1 + iny + lda (word),y + sta dana2,x + iny + lda (word),y + sta dana3,x + iny + lda (word),y + sta dana4,x + iny + lda (word),y + sta dana5,x + + ldy #0 + lda b1 + cmp #3 + bne l14 + ldy #2 +l14 cmp #7 + bne l15 + ldy #4 +l15 lda tab3,y + sta word + lda tab3+1,y + sta word+1 + lda dana2,x + lsr @ + lsr @ + lsr @ + lsr @ + clc + adc b2 + sta b2 + sta zm2+1 + tay + lda b1 + cmp #7 + bne l16 + tya + asl @ + tay + lda (word),y + sta czest1,x + iny + sty b2 + jmp l17 +l16 lda (word),y + sta czest1,x + lda dana2,x + and #$f + clc + adc b2 + sta b2 +l17 ldy b2 + lda b1 + cmp #5 + php + lda (word),y + plp + beq l18 + cmp czest1,x + bne l18 + sec + sbc #1 +l18 sta czest2,x + lda dana0,x + pha + and #3 + tay + lda tab4,y + sta zniek,x + pla + lsr @ + lsr @ + lsr @ + lsr @ + ldy #$3e + cmp #$f + beq l19 + ldy #$37 + cmp #$e + beq l19 + ldy #$30 + cmp #$d + beq l19 + clc +zm2 adc #0 + tay +l19 lda tab5,y + sta czest3,x + rts + +*--- play + +play cld + lda addr + pha + lda addr+1 + pha + lda word + pha + lda word+1 + pha + lda czygr + bne g1 + jmp end +g1 lda czygrc + beq g2 + jmp dal3 +g2 lda tmpo + cmp ltemp + beq g3 + jmp dal2 +g3 lda posptr + beq g4 + jmp dal1 +g4 ldx #2 +g5 ldy czygrx,x + bmi g6 + sta czygrx,x +g6 sta poswpt,x + dex + bpl g5 + + lda adrsng + sta addr + lda adrsng+1 + sta addr+1 + ldy possng + sty word +g7 cpy konrep + bne g8 + lda ilrep + beq g8 + lda possng + ldy pocrep + sty possng + dec ilrep + bne g7 + sta possng + tay + bpl g7 +g8 ldx #0 +g9 lda (addr),y + cmp #$fe + bne g10 + ldy possng + iny + cpy word + beq g11 + sty possng + jmp g7 +g10 sta numptr,x + clc + tya + adc #$55 + tay + inx + cpx #3 + bcc g9 + ldy possng + lda (addr),y + bpl dal1 + cmp #$ff + beq dal1 + lsr @ + lsr @ + lsr @ + and #$e + tax + lda tab2,x + sta zm3+1 + lda tab2+1,x + sta zm3+2 + lda numptr+1 + sta word+1 +zm3 jsr stop + sty possng + cpy #$55 + bcs g11 + cpy word + bne g7 +g11 ldy word + sty possng + jmp end + +stop jsr przer +g12 ldy #$ff + rts +jump bmi g12 + tay + rts +up bmi g12 + sec + tya + sbc word+1 + tay + rts +down bmi g12 + clc + tya + adc word+1 + tay + rts +temp bmi g12 + sta tmpo + sta ltemp + iny + rts +rep bmi g12 + lda numptr+2 + bmi g12 + sta ilrep + iny + sty pocrep + clc + tya + adc word+1 + sta konrep + rts +break dey + bmi g13 + lda (addr),y + cmp #$8f + beq g13 + cmp #$ef + bne break +g13 iny + rts + +dal1 ldx #2 +v1 lda ilewol,x + beq v2 + dec ilewol,x + bpl v7 +v2 lda czygrx,x + bne v7 + ldy numptr,x + cpy #$40 + bcs v7 + lda adradr + sta addr + lda adradr+1 + sta addr+1 + lda (addr),y + sta word + clc + tya + adc #$40 + tay + lda (addr),y + sta word+1 + and word + cmp #$ff + beq v7 +v3 ldy poswpt,x + lda (word),y + and #$c0 + bne v4 + lda (word),y + and #$3f + sta numins,x + inc poswpt,x + bpl v3 +v4 cmp #$40 + bne v5 + lda (word),y + and #$3f + sta b2 + lda numins,x + sta b3 + jsr inst + jmp v6 +v5 cmp #$80 + bne v7 + lda (word),y + and #$3f + sta ilewol,x +v6 inc poswpt,x +v7 dex + bpl v1 + + ldx posptr + inx + txa + and #$3f + sta posptr + +dal2 dec ltemp + bne dal3 + lda tmpo + sta ltemp + lda posptr + bne dal3 + inc possng + +dal3 ldy czest2 + lda dana1 + and #7 + cmp #5 + beq a1 + cmp #6 + bne a2 +a1 dey +a2 sty frq+3 + ldy #0 + cmp #5 + beq a3 + cmp #6 + bne a4 +a3 ldy #2 +a4 cmp #7 + bne a5 + ldy #$28 +a5 sty audc + + ldx #2 +loop lda dana1,x + and #$e0 + sta znieks,x + lda ladr,x + sta addr + lda hadr,x + sta addr+1 + lda count1,x + cmp #$ff + beq y4 + cmp #$f + bne y2 + lda lopad,x + beq y4 + dec lopad,x + lda lopad,x + bne y4 + ldy volume,x + beq y1 + dey +y1 tya + sta volume,x + lda dana3,x + sta lopad,x + jmp y4 +y2 lda count1,x + lsr @ + tay + lda (addr),y + bcc y3 + lsr @ + lsr @ + lsr @ + lsr @ +y3 and #$f + sta volume,x +y4 ldy czest1,x + lda dana1,x + and #7 + cmp #1 + bne y6 + dey + tya + iny + cmp czest2,x + php + lda #1 + plp + bne y5 + asl @ + asl @ +y5 and count2,x + beq y6 + ldy czest2,x + cpy #$ff + bne y6 + lda #0 + sta volume,x +y6 tya + sta frq,x + lda #1 + sta b1 + lda count1,x + cmp #$f + beq y9 + and #7 + tay + lda tab9,y + sta word + lda count1,x + and #8 + php + txa + plp + clc + beq y7 + adc #3 +y7 tay + lda dana4,y + and word + beq y9 + lda czest3,x + sta frq,x + stx b1 + dex + bpl y8 + sta frq+3 + lda #0 + sta audc +y8 inx + lda zniek,x + sta znieks,x +y9 lda count1,x + and #$f + cmp #$f + beq y10 + inc count1,x + lda count1,x + cmp #$f + bne y10 + lda dana3,x + sta lopad,x +y10 lda czygrx,x + bpl y11 + lda volume,x + bne y11 + lda #$40 + sta czygrx,x +y11 inc count2,x + ldy #0 + lda dana1,x + lsr @ + lsr @ + lsr @ + lsr @ + bcc y12 + dey +y12 lsr @ + bcc y13 + iny +y13 clc + tya + adc czest1,x + sta czest1,x + lda czest2,x + cmp #$ff + bne y14 + ldy #0 +y14 clc + tya + adc czest2,x + sta czest2,x + dex + bmi x1 + jmp loop + +x1 lda znieks + sta znieks+3 + lda dana1 + and #7 + tax + ldy #3 + lda b1 + beq x2 + ldy tab10,x +x2 tya + pha + lda tab8,y + php + and #$7f + tax + tya + and #3 + asl @ + tay + lda frq,x +d0 sta $d200,y + iny + lda volume,x + cpx #3 + bne x3 + lda volume +x3 ora znieks,x + plp + bpl d1 + lda #0 +d1 sta $d200,y + pla + tay + dey + and #3 + bne x2 + ldy #8 + lda audc +d2 sta $d200,y + + clc +end pla + sta word+1 + pla + sta word + pla + sta addr+1 + pla + sta addr + rts + +*--- basic + +basic pla + tax + beq p6 + cmp #2 + beq p2 +p1 pla + pla + dex + bne p1 + rts +p2 lda $14 + cmp $14 + beq *-2 + lda $224 + cmp p8 + beq p1 +p3 lda $224 + sta p9+1 + lda $225 + sta p9+2 + lda p8 + sta $225 + pla + pla + beq p4 + sec + sbc #1 +p4 sta p5+1 + pla + tay + pla + tax + lda #$70 + jsr init + lda #0 +p5 ldx #0 + jmp init +p6 lda $14 + cmp $14 + beq *-2 + lda $224 + cmp p8 + bne p2-1 +p7 lda p9+1 + sta $224 + lda p9+2 + sta $225 + lda #$40 + jmp init +p8 jsr play + bcc p9 + jsr p7 +p9 jmp $ffff + +*--- tablice + +tab1 dta a(graj) + dta a(grajx) + dta a(instr) + dta a(tempo) + dta a(skoncz) + dta a(przer) + dta a(kont) + dta a(inic) + +tab2 dta a(stop) + dta a(jump) + dta a(up) + dta a(down) + dta a(temp) + dta a(rep) + dta a(break) + +tab3 dta a(tab5) + dta a(tab6) + dta a(tab7) + +tab4 dta b($80),b($a0) + dta b($20),b($40) + +tab5 dta b($ff),b($f1),b($e4),b($d7) + dta b($cb),b($c0),b($b5),b($aa) + dta b($a1),b($98),b($8f),b($87) + dta b($7f),b($78),b($72),b($6b) + dta b($65),b($5f),b($5a),b($55) + dta b($50),b($4b),b($47),b($43) + dta b($3f),b($3c),b($38),b($35) + dta b($32),b($2f),b($2c),b($2a) + dta b($27),b($25),b($23),b($21) + dta b($1f),b($1d),b($1c),b($1a) + dta b($18),b($17),b($16),b($14) + dta b($13),b($12),b($11),b($10) + dta b($0f),b($0e),b($0d),b($0c) + dta b($0b),b($0a),b($09),b($08) + dta b($07),b($06),b($05),b($04) + dta b($03),b($02),b($01),b($00) + dta b($00) + +tab6 dta b($00),b($00),b($00),b($00) + dta b($f2),b($e9),b($da),b($ce) + dta b($bf),b($b6),b($aa),b($a1) + dta b($98),b($8f),b($89),b($80) + dta b($7a),b($71),b($6b),b($65) + dta b($5f),b($00),b($56),b($50) + dta b($67),b($60),b($5a),b($55) + dta b($51),b($4c),b($48),b($43) + dta b($3f),b($3d),b($39),b($34) + dta b($33),b($39),b($2d),b($2a) + dta b($28),b($25),b($24),b($21) + dta b($1f),b($1e),b($00),b($00) + dta b($0f),b($0e),b($0d),b($0c) + dta b($0b),b($0a),b($09),b($08) + dta b($07),b($06),b($05),b($04) + dta b($03),b($02),b($01),b($00) + dta b($00) + +tab7 dta a($b38),a($a8c),a($a00),a($96a) + dta a($8e8),a($86a),a($7ef),a($780) + dta a($708),a($6ae),a($646),a($5e6) + dta a($595),a($541),a($4f6),a($4b0) + dta a($46e),a($430),a($3f6),a($3bb) + dta a($384),a($352),a($322),a($2f4) + dta a($2c8),a($2a0),a($27a),a($255) + dta a($234),a($214),a($1f5),a($1d8) + dta a($1bd),a($1a4),a($18d),a($177) + dta a($160),a($14e),a($138),a($127) + dta a($115),a($106),a($0f7),a($0e8) + dta a($0db),a($0cf),a($0c3),a($0b8) + dta a($0ac),a($0a2),a($09a),a($090) + dta a($088),a($07f),a($078),a($070) + dta a($06a),a($064),a($05e),a($057) + dta a($052),a($032),a($00a) + +tab8 dta b($00),b($01),b($02),b($83) + dta b($00),b($01),b($02),b($03) + dta b($01),b($00),b($02),b($83) + dta b($01),b($00),b($02),b($03) + dta b($01),b($02),b($80),b($03) + +tab9 dta b($80),b($40),b($20),b($10) + dta b($08),b($04),b($02),b($01) + +tab10 dta b(3),b(3),b(3),b(3) + dta b(7),b($b),b($f),b($13) + +*--- koniec + + end Index: apps/plugins/asap/players/cmc.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\cmc.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/mpt.asx =================================================================== --- apps/plugins/asap/players/mpt.asx (revision 0) +++ apps/plugins/asap/players/mpt.asx (revision 0) @@ -0,0 +1,904 @@ +*----------------* +* Player MPT 2.4 * +* ver.spackowana * +*----------------* + + org $0500 + +*--- strona 0 + +addr equ $ec ,$ed +word equ $ee ,$ef +audzer equ $f0 ,$f1 ,$f2 ,$f3 +licslp equ $f4 ,$f5 ,$f6 ,$f7 +lensmp equ $f8 +lsbmsb equ $f9 +adrs1 equ $fa ,$fb +adrs2 equ $fc ,$fd +adrsmp equ $fe ,$ff + +*--- program + + jmp init + +play lda czygrc + bne *+3 + rts + lda #0 + sta oraaud + inc licz + lda pozptr + cmp maxptr + bcc r1 + dec zegar + beq p1 + jmp r5 +p1 ldx #0 + stx pozptr +p2 lda #0 + sta ptrwsk,x + sta licspc,x + lda adrtrl,x + sta addr + lda adrtrh,x + sta addr+1 + ldy pozsng +p3 lda (addr),y + iny + cmp #$ff + beq p5 + cmp #$fe + bne p6 +p4 jmp inic2 +p5 lda (addr),y + bmi p4 + asl @ + tay + sty pozsng + jmp p3 +p6 sta numptr,x + lda (addr),y + sta poddzw,x +p7 inx + cpx #4 + bne p2 + iny + sty pozsng + jmp r5 +r1 dec zegar + bpl r5 + lda tempo + sta zegar + ldx #3 +r2 dec licspc,x + bpl r4 + lda numptr,x + asl @ + tay +aptrlz lda $ffff,y + sta addr + iny +aptrhz lda $ffff,y + sta addr+1 + ora addr + beq r4 + lda ptrwsk,x + sta licptr + jsr newdzw + ldy licptr + iny + tya + sta ptrwsk,x + lda ilespc,x + sta licspc,x + cpx #2 + bne r4 + lda adcvol,x + eor #$f + asl @ + asl @ + asl @ + asl @ + adc volstb + adc #0 + sta volsmp+2 +r4 dex + bpl r2 + inc pozptr +r5 ldx #1 + lda typsmp + cmp #2 + beq r6 + ldx #3 +r6 lda typsmp + cmp #2 + bne r7 + cpx kansmp + beq r8 +r7 jmp dzwiek +r8 lda audzer,x + and filtry,x + beq r9 + ldy #$28 + lda (addr),y + clc + adc numdzw,x + jsr czest + sec + adc p1pom,x + sta freq+2,x +r9 dex + bpl r6 + lda #3 + sta $d20f + lda audzer+1 + and #$10 + beq w1 + ldy numdzw+1 + lda bsfrql,y + sta freq + lda bsfrqh,y + sta freq+1 +w1 lda freq + sta $d200 + lda freq+1 + sta $d202 + lda freq+2 + sta $d204 + lda freq+3 + sta $d206 + lda volume + ldx #$ff + ldy typsmp + cpy #1 + bne w2 + ldx kansmp + beq w3 +w2 sta $d201 +w3 lda volume+1 + cpx #1 + beq w4 + sta $d203 +w4 cpy #2 + beq w6 + lda volume+2 + cpx #2 + beq w5 + sta $d205 +w5 lda volume+3 + cpx #3 + beq w6 + sta $d207 +w6 lda audzer + ora audzer+1 + ora audzer+2 + ora audzer+3 + ora oraaud + sta $d208 + rts +filtry dta b(4),b(2),b(0),b(0) + +dzwiek lda adrinl,x + sta addr + lda adrinh,x + sta addr+1 + ora addr + bne d0 + sta volume,x + sta audzer,x + jmp r9 +d0 ldy licslp,x + cpy #$20 + beq d3 + lda (addr),y + sec + sbc adcvol,x + bit sprvol + beq d1 + and #$f0 +d1 sta volume,x + iny + lda (addr),y + sta przech + iny + sty licslp,x + and #7 + beq d4 + tay + lda akcadl-1,y + sta akjmpz+1 + lda akcadh-1,y + sta akjmpz+2 + lda przech + lsr @ + lsr @ + lsr @ + lsr @ + lsr @ + ora #$28 + tay + lda (addr),y + clc +akjmpz jsr $ffff +d2 lda #0 + sta audzer,x + jmp r9 +d3 lda p3max,x + beq d4 + dec p3lic,x + bne d4 + sta p3lic,x + lda volume,x + and #15 + beq d4 + dec volume,x +d4 ldy #$23 + lda (addr),y + sta audzer,x + lda trnlic,x + clc + adc #$25 + tay + and #3 + sta trnlic,x + dey + lda (addr),y + adc adcdzw,x + sta numdzw,x + jsr czest+2 + sta freq,x + lda p2lic,x + beq d5 + dec p2lic,x + jmp r8 +d5 lda branch,x + sta p1jmpz+1 +p1jmpz bpl * + jmp typ0dz + brk + jmp typ1dz + brk + jmp typ2dz + brk + jmp typ3dz +czygrc dta b(0) + jmp typ4dz +zapisx dta b(0) + jmp typ5dz +zapisy dta b(0) + jmp typ6dz +sprvol dta b($10) + jmp typ7dz + +newdzw lda #0 + sta adcvol,x + ldy licptr + dey +new iny + lda (addr),y + cmp #$fe + bne q0 + sty licptr + rts +q0 cmp #$e0 + bcc q1 + lda maxptr + sta pozptr + bne new +q1 cmp #$d0 + bcc q2 + and #15 + sta tempo + sta zegar + bpl new +q2 cmp #$c0 + bcc q3 + and #15 + eor #15 + sta adcvol,x + bpl new +q3 cmp #$80 + bcc q4 + and #$3f + sta ilespc,x + bpl new +q4 cmp #$40 + bcc q5 + iny + sty licptr + and #$1f + sta numsmp,x + asl @ + tay +ainslz lda $ffff,y + sta adrinl,x + iny +ainshz lda $ffff,y + sta adrinh,x + jmp newdzw + +q5 sty licptr + sta przech + clc + adc poddzw,x + sta adcdzw,x + lda typsmp + beq n9 + cmp #2 + beq n8 + lda numsmp,x + cmp #$1f + bne n9 + lda przech + sec + sbc #1 +n6 and #15 + tay + lda (adrsmp),y + sta adrs2+1 + tya + ora #$10 + tay + lda (adrsmp),y + sta lensmp + ldy #1 + ora adrs2+1 + bne n7 + ldy #0 +n7 sty czysmp + lda #0 + sta adrs2 + sta adrinl,x + sta adrinh,x + txa + asl @ + sta wsksmp + stx kansmp + rts +n8 cpx #2 + bcs nb +n9 lda adrinl,x + sta word + lda adrinh,x + sta word+1 + ora word + beq na-1 + ldy #$20 + lda (word),y + and #15 + sta p1lsb,x + lda (word),y + and #$70 + lsr @ + lsr @ + sta branch,x + iny + lda (word),y + asl @ + asl @ + pha + and #$3f + sta p2lic,x + pla + and #$c0 + sta frqwsk,x + iny + lda (word),y + sta p3max,x + sta p3lic,x + lda #0 + sta licslp,x + sta trnlic,x + sta p1lic,x + sta p1pom,x + lda adcdzw,x + sta numdzw,x + jsr czest + sta freq,x + cpx kansmp + beq na + rts +na ldy #$ff + sty kansmp + iny + sty czysmp + rts +nb cpx #2 + bne nd + ldy adcdzw+2 + lda frsmpl,y + sta smpl1z+1 + lda frsmph,y + sta smpl2z+1 + lda #0 + sta lsbmsb + sta adrs1 + lda numsmp+2 + and #15 + tay + lda (adrsmp),y + sta adrs1+1 + tya + ora #$10 + tay + lda (adrsmp),y + sta smpl3z+1 + ora adrs1+1 + bne nc + sta smpl1z+1 + sta smpl2z+1 +nc rts +nd lda numsmp+3 + and #15 + tay + lda (adrsmp),y + sta adrs2+1 + tya + ora #$10 + tay + lda (adrsmp),y + ora adrs2+1 + beq ne + lda (adrsmp),y + sec + sbc adrs2+1 + sta lensmp + lda #0 + sta adrs2 + lda #$8d + bne nf +ne lda #$ad +nf sta drum2z + sta drum1z + lda #$18 + sta $d207 + rts + +typ0dz lda licz + and #7 + lsr @ + lsr @ + bcc t2 + bne typ1dz + lda p1lsb,x +t1 clc + sta p1pom,x + adc freq,x + sta freq,x + jmp r8 +t2 lda #0 + sta p1pom,x + jmp r8 +typ1dz lda freq,x + sec + sbc p1lsb,x + sta freq,x + sec + lda #0 + sbc p1lsb,x + sta p1pom,x + jmp r8 +typ2dz lda p1lic,x + clc + sta p1pom,x + adc freq,x +t3 sta freq,x + clc + lda p1lic,x + adc p1lsb,x + sta p1lic,x + jmp r8 +typ3dz lda numdzw,x + sec + sbc p1lic,x +t4 sta numdzw,x + jsr czest + jmp t3 +typ4dz lda #0 + sec + sbc p1lic,x + sta p1pom,x + lda freq,x + sec + sbc p1lic,x + jmp t3 +typ5dz lda numdzw,x + clc + adc p1lic,x + jmp t4 +typ6dz jsr t5 + jmp t1 +typ7dz jsr t5 + clc + adc numdzw,x + jsr a3 + jmp r8 +t5 ldy p1lic,x + lda p1lsb,x + bmi t6 + iny + iny +t6 dey + tya + sta p1lic,x + cmp p1lsb,x + bne t7 + lda p1lsb,x + eor #$ff + sta p1lsb,x +t7 lda p1lic,x + rts +czest and #$3f + ora frqwsk,x + tay +t1frqz lda $ffff,y + rts + +akcadl dta l(a1),l(a0),l(a2) + dta l(a4),l(a5),l(a6),l(a8) +akcadh dta h(a1),h(a0),h(a2) + dta h(a4),h(a5),h(a6),h(a8) +audora dta b($40),b(0),b($20),b(0) + +a0 adc freq,x +a1 sta freq,x + rts +a2 adc adcdzw,x +a3 sta numdzw,x + jsr czest + sta freq,x + rts +a4 sta freq,x + lda audora,x + bpl a7 +a5 sta freq,x + lda #$80 + bne a7 +a6 sta freq,x + lda #1 +a7 ora oraaud + sta oraaud + rts +a8 and $d20a + sta freq,x +a9 rts + +bsfrql equ *-1 + dta b($f2),b($33),b($96) + dta b($e2),b($38),b($8c),b(0) + dta b($6a),b($e8),b($6a),b($ef) + dta b($80),b(8),b($ae),b($46) + dta b($e6),b($95),b($41),b($f6) + dta b($b0),b($6e),b($30),b($f6) + dta b($bb),b($84),b($52),b($22) + dta b($f4),b($c8),b($a0),b($7a) + dta b($55),b($34),b($14),b($f5) + dta b($d8),b($bd),b($a4),b($8d) + dta b($77),b($60),b($4e),b($38) + dta b($27),b($15),b(6),b($f7) + dta b($e8),b($db),b($cf),b($c3) + dta b($b8),b($ac),b($a2),b($9a) + dta b($90),b($88),b($7f),b($78) + dta b($70),b($6a),b($64),b($5e) + +bsfrqh equ *-1 + dta b(13,13,12,11,11,10,10,9,8,8,7,7,7,6,6) + dta b(5,5,5,4,4,4,4,3,3,3,3,3,2,2,2,2) + dta b(2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,0) + dta b(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0) + +volstb dta d'8888888888888888' + dta d'667777888889999:' + dta d'556667788899:::;' + dta d'455667788899::;;' + dta d'44556677899::;;<' + dta d'34456677899::;<<' + dta d'33455677899:;;<=' + dta d'23445677899:;<<=' + dta d'2334566789::;<==' + dta d'2234566789::;<=>' + dta d'1234566789::;<=>' + dta d'1234556789:;;<=>' + dta d'1234456789:;<<=>' + dta d'1233456789:;<==>' + dta d'1223456789:;<=>>' + dta d'0123456789:;<=>?' + +frsmpl dta b($20),b($22),b($24),b($26),b($29) + dta b($2b),b($2e),b($30),b($33),b($37) + dta b($3a),b($3d),b($41),b($45),b($49) + dta b($4d),b($52),b($57),b($5c),b($61) + dta b($67),b($6e),b($74),b($7b),b($82) + dta b($8a),b($92),b($9b),b($a4),b($ae) + dta b($b8),b($c3),b($cf),b($dc),b($e9) + dta b($f6),b(5),b($15),b($25),b($37) + dta b($49),b($5d),b($71),b($87),b($9f) + dta b($b8),b($d2),b($ed),b($b),b($2a) + dta b($4b),b($6e),b($93),b($ba),b($e3) + dta b($f),b($3e),b($70),b($a4),b($db) + +frsmph dta d' ' + dta d' ' + dta d' !!!!!!!!!' + dta d'!!!"""""""#####' + +*--- inicjacja + +iniadl dta l(inic0),l(inic2) + dta l(inic4),l(inic5) + dta l(inic6),l(inic7) + dta l(inic8),l(inic9) +iniadh dta h(inic0),h(inic2) + dta h(inic4),h(inic5) + dta h(inic6),h(inic7) + dta h(inic8),h(inic9) + +init stx zapisx + sty zapisy + and #7 + tay + lda iniadl,y + sta inic1+1 + lda iniadh,y + sta inic1+2 +inic1 jmp $ffff + +inic0 lda zapisy + ldx zapisx + sta ainslz+1 + sta ainshz+1 + stx ainslz+2 + stx ainshz+2 + clc + adc #$40 + sta aptrlz+1 + sta aptrhz+1 + bcc i2 + inx +i2 stx aptrlz+2 + stx aptrhz+2 + clc + adc #$80 + sta t1frqz+1 + bcc i4 + inx +i4 stx t1frqz+2 + inx + sta j4+1 + stx j4+2 + ldx #9 +j4 lda $ffff,x + sta adrtrl,x + dex + bpl j4 + dec tempo + +inic2 lda #0 + sta czygrc + ldx ressmp+1 + sta adrs1+1 + lda #$ad + sta drum2z + sta drum1z + ldy #0 + sty smpl1z+1 + sty smpl2z+1 +k2 ldx $d40b + lda (adrs2),y + lsr @ + lsr @ + lsr @ + lsr @ + ora #$10 +drum1z sta $d207 + jsr k6 +k3 cpx $d40b + beq k3 + sta $d205 + ldx $d40b + lda (adrs2),y + inc adrs2 + bne k4 + inc adrs2+1 + dec lensmp + bne k4 + lda #$ad + sta drum2z + sta drum1z + lda #8 +k4 ora #$10 +drum2z sta $d207 + jsr k6 +k5 cpx $d40b + beq k5 + sta $d205 + lda typsmp + bne k2 + rts + +k6 clc + lda lsbmsb +smpl1z adc #0 + sta lsbmsb + lda adrs1 +smpl2z adc #0 + sta adrs1 + bcc k7 + inc adrs1+1 + lda adrs1+1 +smpl3z cmp #0 + bne k7 + sty smpl1z+1 + sty smpl2z+1 + rts +k7 lda (adrs1),y + bit lsbmsb + bmi k8 + lsr @ + lsr @ + lsr @ + lsr @ +k8 and #15 + tay +volsmp lda volstb,y + ldy #0 + rts + +inic9 ldy #0 + sty typsmp + sty czysmp + dey + sty kansmp + rts + +*--- zmienne + +adrtrl org *+4 +adrtrh org *+4 +maxptr org *+1 +tempo org *+1 + +branch org *+4 +volume org *+4 +adcvol org *+4 +freq org *+4 +frqwsk org *+4 +adcdzw org *+4 +poddzw org *+4 +adrinl org *+4 +adrinh org *+4 +numdzw org *+4 +numsmp org *+4 +numptr org *+4 +ptrwsk org *+4 +ilespc org *+4 +licspc org *+4 +p1lsb org *+4 +p1lic org *+4 +p1pom org *+4 +p2lic org *+4 +p3max org *+4 +p3lic org *+4 +trnlic org *+4 +zegar org *+1 +pozsng org *+1 +pozptr org *+1 +wsksmp org *+1 +kansmp org *+1 +czysmp org *+1 +typsmp org *+1 +oraaud org *+1 +licz org *+1 +przech org *+1 +licptr org *+1 + + end Index: apps/plugins/asap/players/mpt.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\mpt.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/rmt.asx =================================================================== --- apps/plugins/asap/players/rmt.asx (revision 0) +++ apps/plugins/asap/players/rmt.asx (revision 0) @@ -0,0 +1,1326 @@ +;* +;* Raster Music Tracker, RMT Atari routine version 1.20051226 +;* (c) Radek Sterba, Raster/C.P.U., 2002 - 2005 +;* http://raster.atari.org +;* +;* Warnings: +;* +;* 1. RMT player routine needs 19 itself reserved bytes in zero page (no accessed +;* from any other routines) as well as cca 1KB of memory before the "PLAYER" +;* address for frequency tables and functionary variables. It's: +;* a) from PLAYER-$400 to PLAYER for stereo RMTplayer +;* b) from PLAYER-$380 to PLAYER for mono RMTplayer +;* +;* 2. RMT player routine MUST (!!!) be compiled from the begin of the memory page. +;* i.e. "PLAYER" address can be $..00 only! +;* +;* 3. Because of RMTplayer provides a lot of effects, it spent a lot of CPU time. +;* +;* STEREOMODE equ 0 ;0 => compile RMTplayer for 4 tracks mono +;* ;1 => compile RMTplayer for 8 tracks stereo +;* ;2 => compile RMTplayer for 4 tracks stereo L1 R2 R3 L4 +;* ;3 => compile RMTplayer for 4 tracks stereo L1 L2 R3 R4 +;* +PLAYER equ $0600 +;* + IFT STEREOMODE==1 +TRACKS equ 8 + ELS +TRACKS equ 4 + EIF +;* +;* RMT FEATures definitions +;* For optimizations of RMT player routine to concrete RMT modul only! +;* --------BEGIN-------- +FEAT_INSTRSPEED equ 0 ;* cca 21 or 5 bytes +FEAT_CONSTANTSPEED equ 0 ;* cca 28 bytes +;* VARIOUS COMMANDS +FEAT_COMMAND1 equ 1 ;* cca 8 bytes +FEAT_COMMAND2 equ 1 ;* cca 20 bytes (+save 1 address in zero page) and quicker whole RMT routine +FEAT_COMMAND3 equ 1 ;* cca 12 bytes +FEAT_COMMAND4 equ 1 ;* cca 15 bytes +FEAT_COMMAND5 equ 1 ;* cca 67 bytes +FEAT_COMMAND6 equ 1 ;* cca 15 bytes +;* COMMAND7 SETNOTE (i.e. command 7 with parameter != $80) +FEAT_COMMAND7SETNOTE equ 1 ;* cca 12 bytes +;* COMMAND7 VOLUMEONLY (i.e. command 7 with parameter == $80) +FEAT_COMMAND7VOLUMEONLY equ 1 ;* cca 74 bytes +;* PORTAMENTO +FEAT_PORTAMENTO equ 1 ;* cca 138 bytes and quicker whole RMT routine +;* FILTER +FEAT_FILTER equ 1 ;* cca 179 bytes and quicker whole RMT routine +FEAT_FILTERG0L equ 1 ;* (cca 38 bytes for each) +FEAT_FILTERG1L equ 1 +FEAT_FILTERG0R equ 1 +FEAT_FILTERG1R equ 1 +;* BASS16B (i.e. distortion value 6) +FEAT_BASS16 equ 1 ;* cca 194 bytes +128bytes freq table and quicker whole RMT routine +FEAT_BASS16G1L equ 1 ;* (cca 47 bytes for each) +FEAT_BASS16G3L equ 1 +FEAT_BASS16G1R equ 1 +FEAT_BASS16G3R equ 1 +;* VOLUME ONLY for particular generators +FEAT_VOLUMEONLYG0L equ 1 ;* (cca 7 bytes for each) +FEAT_VOLUMEONLYG2L equ 1 +FEAT_VOLUMEONLYG3L equ 1 +FEAT_VOLUMEONLYG0R equ 1 +FEAT_VOLUMEONLYG2R equ 1 +FEAT_VOLUMEONLYG3R equ 1 +;* TABLE TYPE (i.e. TABLETYPE=1) +FEAT_TABLETYPE equ 1 ;* cca 53 bytes and quicker whole RMT routine +;* TABLE MODE (i.e. TABLEMODE=1) +FEAT_TABLEMODE equ 1 ;* cca 16 bytes and quicker whole RMT routine +;* TABLE GO (i.e. TGO is nonzero value) +FEAT_TABLEGO equ 1 ;* cca 6 bytes and quicker whole RMT routine +;* AUDCTLMANUALSET (i.e. any MANUAL AUDCTL setting is nonzero value) +FEAT_AUDCTLMANUALSET equ 1 ;* cca 27 bytes and quicker whole RMT routine +;* VOLUME MINIMUM (i.e. VMIN is nonzero value) +FEAT_VOLUMEMIN equ 1 ;* cca 12 bytes and quicker whole RMT routine +;* --------END-------- + +;* +;* RMT ZeroPage addresses + org 203 +p_tis +p_instrstable org *+2 +p_trackslbstable org *+2 +p_trackshbstable org *+2 +p_song org *+2 +ns org *+2 +nr org *+2 +nt org *+2 +reg1 org *+1 +reg2 org *+1 +reg3 org *+1 +tmp org *+1 + IFT FEAT_COMMAND2 +frqaddcmd2 org *+1 + EIF + IFT TRACKS>4 + org PLAYER-$400 + ELS + org PLAYER-$380 + EIF +track_variables +trackn_db org *+TRACKS +trackn_hb org *+TRACKS +trackn_idx org *+TRACKS +trackn_pause org *+TRACKS +trackn_note org *+TRACKS +trackn_volume org *+TRACKS +trackn_distor org *+TRACKS +trackn_shiftfrq org *+TRACKS + IFT FEAT_PORTAMENTO +trackn_portafrqc org *+TRACKS +trackn_portafrqa org *+TRACKS +trackn_portaspeed org *+TRACKS +trackn_portaspeeda org *+TRACKS +trackn_portadepth org *+TRACKS + EIF +trackn_instrx2 org *+TRACKS +trackn_instrdb org *+TRACKS +trackn_instrhb org *+TRACKS +trackn_instridx org *+TRACKS +trackn_instrlen org *+TRACKS +trackn_instrlop org *+TRACKS +trackn_instrreachend org *+TRACKS +trackn_volumeslidedepth org *+TRACKS +trackn_volumeslidevalue org *+TRACKS + IFT FEAT_VOLUMEMIN +trackn_volumemin org *+TRACKS + EIF +trackn_effdelay org *+TRACKS +trackn_effvibratoa org *+TRACKS +trackn_effvibratobeg org *+TRACKS +trackn_effvibratoend org *+TRACKS +trackn_effshift org *+TRACKS +trackn_tabletypespeed org *+TRACKS + IFT FEAT_TABLEMODE +trackn_tablemode org *+TRACKS + EIF +trackn_tablenote org *+TRACKS +trackn_tablea org *+TRACKS +trackn_tableend org *+TRACKS + IFT FEAT_TABLEGO +trackn_tablelop org *+TRACKS + EIF +trackn_tablespeeda org *+TRACKS +trackn_command org *+TRACKS + IFT FEAT_BASS16 +trackn_outnote org *+TRACKS + EIF + IFT FEAT_FILTER +trackn_filter org *+TRACKS + EIF +trackn_audf org *+TRACKS +trackn_audc org *+TRACKS + IFT FEAT_AUDCTLMANUALSET +trackn_audctl org *+TRACKS + EIF + IFT FEAT_CONSTANTSPEED==0 +v_speed org *+1 + EIF +v_aspeed org *+1 + IFT FEAT_INSTRSPEED==0||FEAT_INSTRSPEED>1 +v_ainstrspeed org *+1 + EIF +v_abeat org *+1 +track_endvariables + org PLAYER-$100-$140-$30 +INSTRPAR equ 12 +tabbeganddistor + dta frqtabpure-frqtab,$00 + dta frqtabpure-frqtab,$20 + dta frqtabpure-frqtab,$40 + dta frqtabbass1-frqtab,$c0 + dta frqtabpure-frqtab,$80 + dta frqtabpure-frqtab,$a0 + dta frqtabbass1-frqtab,$c0 + dta frqtabbass2-frqtab,$c0 +vibtabbeg dta 0,vib1-vib0,vib2-vib0,vib3-vib0,vibx-vib0 +vib0 dta 0 +vib1 dta 1,-1,-1,1 +vib2 dta 1,0,-1,-1,0,1 +vib3 dta 1,1,0,-1,-1,-1,-1,0,1,1 +vibx +:PLAYER-$100-$140-* dta 0 +; org PLAYER-$100-$140 + IFT FEAT_BASS16 +frqtabbasslo + dta $F2,$33,$96,$E2,$38,$8C,$00,$6A,$E8,$6A,$EF,$80,$08,$AE,$46,$E6 + dta $95,$41,$F6,$B0,$6E,$30,$F6,$BB,$84,$52,$22,$F4,$C8,$A0,$7A,$55 + dta $34,$14,$F5,$D8,$BD,$A4,$8D,$77,$60,$4E,$38,$27,$15,$06,$F7,$E8 + dta $DB,$CF,$C3,$B8,$AC,$A2,$9A,$90,$88,$7F,$78,$70,$6A,$64,$5E,$00 + EIF + org PLAYER-$100-$100 +frqtab + ERT [255 + ldy #0 + tya +ri0 sta track_variables,y + sta track_endvariables-$100,y + iny + bne ri0 + ELS + ldy #track_endvariables-track_variables + lda #0 +ri0 sta track_variables-1,y + dey + bne ri0 + EIF + ldy #4 + lda (ns),y + sta v_maxtracklen + iny + IFT FEAT_CONSTANTSPEED==0 + lda (ns),y + sta v_speed + EIF + IFT FEAT_INSTRSPEED==0 + iny + lda (ns),y + sta v_instrspeed + sta v_ainstrspeed + ELI FEAT_INSTRSPEED>1 + lda #FEAT_INSTRSPEED + sta v_ainstrspeed + EIF + ldy #8 +ri1 lda (ns),y + sta p_tis-8,y + iny + cpy #8+8 + bne ri1 + pla + pha + IFT TRACKS>4 + asl @ + asl @ + asl @ + clc + adc p_song + sta p_song + pla + php + and #$e0 + asl @ + rol @ + rol @ + rol @ + ELS + asl @ + asl @ + clc + adc p_song + sta p_song + pla + php + and #$c0 + asl @ + rol @ + rol @ + EIF + plp + adc p_song+1 + sta p_song+1 + jsr GetSongLineTrackLineInitOfNewSetInstrumentsOnlyRmtp3 +rmt_silence + IFT STEREOMODE>0 + lda #0 + sta $d208 + sta $d218 + ldy #3 + sty $d20f + sty $d21f + ldy #8 +si1 sta $d200,y + sta $d210,y + dey + bpl si1 + ELS + lda #0 + sta $d208 + ldy #3 + sty $d20f + ldy #8 +si1 sta $d200,y + dey + bpl si1 + EIF + IFT FEAT_INSTRSPEED==0 + lda v_instrspeed + ELS + lda #FEAT_INSTRSPEED + EIF + rts +GetSongLineTrackLineInitOfNewSetInstrumentsOnlyRmtp3 +GetSongLine + ldx #0 + stx v_abeat +nn0 +nn1 txa + tay + lda (p_song),y + cmp #$fe + bcs nn2 + tay + lda (p_trackslbstable),y + sta trackn_db,x + lda (p_trackshbstable),y +nn1a sta trackn_hb,x + lda #0 + sta trackn_idx,x + lda #1 +nn1a2 sta trackn_pause,x + lda #$80 + sta trackn_instrx2,x + inx +xtracks01 cpx #TRACKS + bne nn1 + lda p_song + clc +xtracks02 adc #TRACKS + sta p_song + bcc GetTrackLine + inc p_song+1 +nn1b + jmp GetTrackLine +nn2 + beq nn3 +nn2a + lda #0 + beq nn1a2 +nn3 + ldy #2 + lda (p_song),y + tax + iny + lda (p_song),y + sta p_song+1 + stx p_song + ldx #0 + beq nn0 +GetTrackLine +oo0 +oo0a + IFT FEAT_CONSTANTSPEED==0 + lda v_speed + sta v_bspeed + EIF + ldx #-1 +oo1 + inx + dec trackn_pause,x + bne oo1x +oo1b + lda trackn_db,x + sta ns + lda trackn_hb,x + sta ns+1 +oo1i + ldy trackn_idx,x + inc trackn_idx,x + lda (ns),y + sta reg1 + and #$3f + cmp #61 + beq oo1a + bcs oo2 + sta trackn_note,x + IFT FEAT_BASS16 + sta trackn_outnote,x + EIF + iny + lda (ns),y + lsr @ + and #$3f*2 + sta trackn_instrx2,x +oo1a + lda #1 + sta trackn_pause,x + ldy trackn_idx,x + inc trackn_idx,x + lda (ns),y + lsr @ + ror reg1 + lsr @ + ror reg1 + lda reg1 + and #$f0 + sta trackn_volume,x +oo1x +xtracks03sub1 cpx #TRACKS-1 + bne oo1 + IFT FEAT_CONSTANTSPEED==0 + lda #$ff +v_bspeed equ *-1 + sta v_speed + ELS + lda #FEAT_CONSTANTSPEED + EIF + sta v_aspeed + jmp InitOfNewSetInstrumentsOnly +oo2 + cmp #63 + beq oo63 + lda reg1 + and #$c0 + beq oo62_b + asl @ + rol @ + rol @ + sta trackn_pause,x + jmp oo1x +oo62_b + iny + lda (ns),y + sta trackn_pause,x + inc trackn_idx,x + jmp oo1x +oo63 + lda reg1 + IFT FEAT_CONSTANTSPEED==0 + bmi oo63_1X + iny + lda (ns),y + sta v_bspeed + inc trackn_idx,x + jmp oo1i +oo63_1X + EIF + cmp #255 + beq oo63_11 + iny + lda (ns),y + sta trackn_idx,x + jmp oo1i +oo63_11 + jmp GetSongLine +p2xrmtp3 jmp rmt_p3 +p2x0 dex + bmi p2xrmtp3 +InitOfNewSetInstrumentsOnly +p2x1 ldy trackn_instrx2,x + bmi p2x0 +SetUpInstrumentY2 + lda (p_instrstable),y + sta trackn_instrdb,x + sta nt + iny + lda (p_instrstable),y + sta trackn_instrhb,x + sta nt+1 + IFT FEAT_FILTER + lda #1 + sta trackn_filter,x + EIF + IFT FEAT_TABLEGO + IFT FEAT_FILTER + tay + ELS + ldy #1 + EIF + lda (nt),y + sta trackn_tablelop,x + iny + ELS + ldy #2 + EIF + lda (nt),y + sta trackn_instrlen,x + iny + lda (nt),y + sta trackn_instrlop,x + iny + lda (nt),y + sta trackn_tabletypespeed,x + IFT FEAT_TABLETYPE||FEAT_TABLEMODE + and #$3f + EIF + sta trackn_tablespeeda,x + IFT FEAT_TABLEMODE + lda (nt),y + and #$40 + sta trackn_tablemode,x + EIF + IFT FEAT_AUDCTLMANUALSET + iny + lda (nt),y + sta trackn_audctl,x + iny + ELS + ldy #6 + EIF + lda (nt),y + sta trackn_volumeslidedepth,x + IFT FEAT_VOLUMEMIN + iny + lda (nt),y + sta trackn_volumemin,x + iny + ELS + ldy #8 + EIF + lda (nt),y + sta trackn_effdelay,x + iny + lda (nt),y + tay + lda vibtabbeg,y + sta trackn_effvibratoa,x + sta trackn_effvibratobeg,x + lda vibtabbeg+1,y + sta trackn_effvibratoend,x + ldy #10 + lda (nt),y + sta trackn_effshift,x + lda #128 + sta trackn_volumeslidevalue,x + sta trackn_instrx2,x + asl @ + sta trackn_instrreachend,x + sta trackn_shiftfrq,x + tay + lda (nt),y + sta trackn_tableend,x + adc #0 + sta trackn_instridx,x + lda #INSTRPAR + sta trackn_tablea,x + tay + lda (nt),y + sta trackn_tablenote,x +xata_rtshere + jmp p2x0 +rmt_play +rmt_p0 + jsr SetPokey +rmt_p1 + IFT FEAT_INSTRSPEED==0||FEAT_INSTRSPEED>1 + dec v_ainstrspeed + bne rmt_p3 + EIF + IFT FEAT_INSTRSPEED==0 + lda #$ff +v_instrspeed equ *-1 + sta v_ainstrspeed + ELI FEAT_INSTRSPEED>1 + lda #FEAT_INSTRSPEED + sta v_ainstrspeed + EIF +rmt_p2 + dec v_aspeed + bne rmt_p3 + inc v_abeat + lda v_abeat + cmp #$ff +v_maxtracklen equ *-1 + beq p2o3 + jmp GetTrackLine +p2o3 + jmp GetSongLineTrackLineInitOfNewSetInstrumentsOnlyRmtp3 +go_ppnext jmp ppnext +rmt_p3 + lda #>frqtab + sta nr+1 +xtracks05sub1 ldx #TRACKS-1 +pp1 + lda trackn_instrhb,x + beq go_ppnext + sta ns+1 + lda trackn_instrdb,x + sta ns + ldy trackn_instridx,x + lda (ns),y + sta reg1 + iny + lda (ns),y + sta reg2 + iny + lda (ns),y + sta reg3 + iny + tya + cmp trackn_instrlen,x + bcc pp2 + beq pp2 + lda #$80 + sta trackn_instrreachend,x +pp1b + lda trackn_instrlop,x +pp2 sta trackn_instridx,x + lda reg1 + IFT TRACKS>4 + cpx #4 + bcc pp2s + lsr @ + lsr @ + lsr @ + lsr @ +pp2s + EIF + and #$0f + ora trackn_volume,x + tay + lda volumetab,y + sta tmp + lda reg2 + and #$0e + tay + lda tabbeganddistor,y + sta nr + lda tmp + ora tabbeganddistor+1,y + sta trackn_audc,x +InstrumentsEffects + lda trackn_effdelay,x + beq ei2 + cmp #1 + bne ei1 + lda trackn_shiftfrq,x + clc + adc trackn_effshift,x + clc + ldy trackn_effvibratoa,x + adc vib0,y + sta trackn_shiftfrq,x + iny + tya + cmp trackn_effvibratoend,x + bne ei1a + lda trackn_effvibratobeg,x +ei1a + sta trackn_effvibratoa,x + jmp ei2 +ei1 + dec trackn_effdelay,x +ei2 + ldy trackn_tableend,x + cpy #INSTRPAR+1 + bcc ei3 + lda trackn_tablespeeda,x + bpl ei2f +ei2c + tya + cmp trackn_tablea,x + bne ei2c2 + IFT FEAT_TABLEGO + lda trackn_tablelop,x + ELS + lda #INSTRPAR + EIF + sta trackn_tablea,x + bne ei2a +ei2c2 + inc trackn_tablea,x +ei2a + lda trackn_instrdb,x + sta nt + lda trackn_instrhb,x + sta nt+1 + ldy trackn_tablea,x + lda (nt),y + IFT FEAT_TABLEMODE + ldy trackn_tablemode,x + beq ei2e + clc + adc trackn_tablenote,x +ei2e + EIF + sta trackn_tablenote,x + lda trackn_tabletypespeed,x + IFT FEAT_TABLETYPE||FEAT_TABLEMODE + and #$3f + EIF +ei2f + sec + sbc #1 + sta trackn_tablespeeda,x +ei3 + lda trackn_instrreachend,x + bpl ei4 + lda trackn_volume,x + beq ei4 + IFT FEAT_VOLUMEMIN + cmp trackn_volumemin,x + beq ei4 + bcc ei4 + EIF + tay + lda trackn_volumeslidevalue,x + clc + adc trackn_volumeslidedepth,x + sta trackn_volumeslidevalue,x + bcc ei4 + tya + sbc #16 + sta trackn_volume,x +ei4 + IFT FEAT_COMMAND2 + lda #0 + sta frqaddcmd2 + EIF + lda reg2 + sta trackn_command,x + and #$70 + lsr @ + lsr @ + sta jmx+1 +jmx bcc * + jmp cmd0 + nop + jmp cmd1 + nop + jmp cmd2 + nop + jmp cmd3 + nop + jmp cmd4 + nop + jmp cmd5 + nop + jmp cmd6 + nop + jmp cmd7 +cmd1 + IFT FEAT_COMMAND1 + lda reg3 + jmp cmd0c + EIF +cmd2 + IFT FEAT_COMMAND2 + lda reg3 + sta frqaddcmd2 + lda trackn_note,x + jmp cmd0a + EIF +cmd3 + IFT FEAT_COMMAND3 + lda trackn_note,x + clc + adc reg3 + sta trackn_note,x + jmp cmd0a + EIF +cmd4 + IFT FEAT_COMMAND4 + lda trackn_shiftfrq,x + clc + adc reg3 + sta trackn_shiftfrq,x + lda trackn_note,x + jmp cmd0a + EIF +cmd5 + IFT FEAT_COMMAND5&&FEAT_PORTAMENTO + IFT FEAT_TABLETYPE + lda trackn_tabletypespeed,x + bpl cmd5a1 + ldy trackn_note,x + lda (nr),y + clc + adc trackn_tablenote,x + jmp cmd5ax + EIF +cmd5a1 + lda trackn_note,x + clc + adc trackn_tablenote,x + cmp #61 + bcc cmd5a2 + lda #63 +cmd5a2 + tay + lda (nr),y +cmd5ax + sta trackn_portafrqc,x + ldy reg3 + bne cmd5a + sta trackn_portafrqa,x +cmd5a + tya + lsr @ + lsr @ + lsr @ + lsr @ + sta trackn_portaspeed,x + sta trackn_portaspeeda,x + lda reg3 + and #$0f + sta trackn_portadepth,x + lda trackn_note,x + jmp cmd0a + ELI FEAT_COMMAND5 + jmp pp9 + EIF +cmd6 + IFT FEAT_COMMAND6&&FEAT_FILTER + lda reg3 + clc + adc trackn_filter,x + sta trackn_filter,x + lda trackn_note,x + jmp cmd0a + ELI FEAT_COMMAND6 + jmp pp9 + EIF +cmd7 + IFT FEAT_COMMAND7SETNOTE||FEAT_COMMAND7VOLUMEONLY + IFT FEAT_COMMAND7SETNOTE + lda reg3 + IFT FEAT_COMMAND7VOLUMEONLY + cmp #$80 + beq cmd7a + EIF + sta trackn_note,x + jmp cmd0a + EIF + IFT FEAT_COMMAND7VOLUMEONLY +cmd7a + lda trackn_audc,x + ora #$f0 + sta trackn_audc,x + lda trackn_note,x + jmp cmd0a + EIF + EIF +cmd0 + lda trackn_note,x + clc + adc reg3 +cmd0a + IFT FEAT_TABLETYPE + ldy trackn_tabletypespeed,x + bmi cmd0b + EIF + clc + adc trackn_tablenote,x + cmp #61 + bcc cmd0a1 + lda #0 + sta trackn_audc,x + lda #63 +cmd0a1 + IFT FEAT_BASS16 + sta trackn_outnote,x + EIF + tay + lda (nr),y + clc + adc trackn_shiftfrq,x + IFT FEAT_COMMAND2 + clc + adc frqaddcmd2 + EIF + IFT FEAT_TABLETYPE + jmp cmd0c +cmd0b + cmp #61 + bcc cmd0b1 + lda #0 + sta trackn_audc,x + lda #63 +cmd0b1 + tay + lda trackn_shiftfrq,x + clc + adc trackn_tablenote,x + clc + adc (nr),y + IFT FEAT_COMMAND2 + clc + adc frqaddcmd2 + EIF + EIF +cmd0c + sta trackn_audf,x +pp9 + IFT FEAT_PORTAMENTO + lda trackn_portaspeeda,x + beq pp10 + dec trackn_portaspeeda,x + bne pp10 + lda trackn_portaspeed,x + sta trackn_portaspeeda,x + lda trackn_portafrqa,x + cmp trackn_portafrqc,x + beq pp10 + bcs pps1 + adc trackn_portadepth,x + bcs pps8 + cmp trackn_portafrqc,x + bcs pps8 + jmp pps9 +pps1 + sbc trackn_portadepth,x + bcc pps8 + cmp trackn_portafrqc,x + bcs pps9 +pps8 + lda trackn_portafrqc,x +pps9 + sta trackn_portafrqa,x +pp10 + lda reg2 + and #$01 + beq pp11 + lda trackn_portafrqa,x + clc + adc trackn_shiftfrq,x + sta trackn_audf,x +pp11 + EIF +ppnext + dex + bmi rmt_p4 + jmp pp1 +rmt_p4 + IFT FEAT_AUDCTLMANUALSET + lda trackn_audctl+0 + ora trackn_audctl+1 + ora trackn_audctl+2 + ora trackn_audctl+3 + tax + ELS + ldx #0 + EIF +qq1 + stx v_audctl + IFT FEAT_FILTER + IFT FEAT_FILTERG0L + lda trackn_command+0 + bpl qq2 + lda trackn_audc+0 + and #$0f + beq qq2 + lda trackn_audf+0 + clc + adc trackn_filter+0 + sta trackn_audf+2 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG2L + lda trackn_audc+2 + and #$10 + bne qq1a + EIF + lda #0 + sta trackn_audc+2 +qq1a + txa + ora #4 + tax + EIF +qq2 + IFT FEAT_FILTERG1L + lda trackn_command+1 + bpl qq3 + lda trackn_audc+1 + and #$0f + beq qq3 + lda trackn_audf+1 + clc + adc trackn_filter+1 + sta trackn_audf+3 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG3L + lda trackn_audc+3 + and #$10 + bne qq2a + EIF + lda #0 + sta trackn_audc+3 +qq2a + txa + ora #2 + tax + EIF +qq3 + IFT FEAT_FILTERG0L||FEAT_FILTERG1L + cpx v_audctl + bne qq5 + EIF + EIF + IFT FEAT_BASS16 + IFT FEAT_BASS16G1L + lda trackn_command+1 + and #$0e + cmp #6 + bne qq4 + lda trackn_audc+1 + and #$0f + beq qq4 + ldy trackn_outnote+1 + lda frqtabbasslo,y + sta trackn_audf+0 + lda frqtabbasshi,y + sta trackn_audf+1 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG0L + lda trackn_audc+0 + and #$10 + bne qq3a + EIF + lda #0 + sta trackn_audc+0 +qq3a + txa + ora #$50 + tax + EIF +qq4 + IFT FEAT_BASS16G3L + lda trackn_command+3 + and #$0e + cmp #6 + bne qq5 + lda trackn_audc+3 + and #$0f + beq qq5 + ldy trackn_outnote+3 + lda frqtabbasslo,y + sta trackn_audf+2 + lda frqtabbasshi,y + sta trackn_audf+3 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG2L + lda trackn_audc+2 + and #$10 + bne qq4a + EIF + lda #0 + sta trackn_audc+2 +qq4a + txa + ora #$28 + tax + EIF + EIF +qq5 + stx v_audctl + IFT TRACKS>4 + IFT FEAT_AUDCTLMANUALSET + lda trackn_audctl+4 + ora trackn_audctl+5 + ora trackn_audctl+6 + ora trackn_audctl+7 + tax + ELS + ldx #0 + EIF + stx v_audctl2 + IFT FEAT_FILTER + IFT FEAT_FILTERG0R + lda trackn_command+0+4 + bpl qs2 + lda trackn_audc+0+4 + and #$0f + beq qs2 + lda trackn_audf+0+4 + clc + adc trackn_filter+0+4 + sta trackn_audf+2+4 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG2R + lda trackn_audc+2+4 + and #$10 + bne qs1a + EIF + lda #0 + sta trackn_audc+2+4 +qs1a + txa + ora #4 + tax + EIF +qs2 + IFT FEAT_FILTERG1R + lda trackn_command+1+4 + bpl qs3 + lda trackn_audc+1+4 + and #$0f + beq qs3 + lda trackn_audf+1+4 + clc + adc trackn_filter+1+4 + sta trackn_audf+3+4 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG3R + lda trackn_audc+3+4 + and #$10 + bne qs2a + EIF + lda #0 + sta trackn_audc+3+4 +qs2a + txa + ora #2 + tax + EIF +qs3 + IFT FEAT_FILTERG0R||FEAT_FILTERG1R + cpx v_audctl2 + bne qs5 + EIF + EIF + IFT FEAT_BASS16 + IFT FEAT_BASS16G1R + lda trackn_command+1+4 + and #$0e + cmp #6 + bne qs4 + lda trackn_audc+1+4 + and #$0f + beq qs4 + ldy trackn_outnote+1+4 + lda frqtabbasslo,y + sta trackn_audf+0+4 + lda frqtabbasshi,y + sta trackn_audf+1+4 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG0R + lda trackn_audc+0+4 + and #$10 + bne qs3a + EIF + lda #0 + sta trackn_audc+0+4 +qs3a + txa + ora #$50 + tax + EIF +qs4 + IFT FEAT_BASS16G3R + lda trackn_command+3+4 + and #$0e + cmp #6 + bne qs5 + lda trackn_audc+3+4 + and #$0f + beq qs5 + ldy trackn_outnote+3+4 + lda frqtabbasslo,y + sta trackn_audf+2+4 + lda frqtabbasshi,y + sta trackn_audf+3+4 + IFT FEAT_COMMAND7VOLUMEONLY&&FEAT_VOLUMEONLYG2R + lda trackn_audc+2+4 + and #$10 + bne qs4a + EIF + lda #0 + sta trackn_audc+2+4 +qs4a + txa + ora #$28 + tax + EIF + EIF +qs5 + stx v_audctl2 + EIF +rmt_p5 + IFT FEAT_INSTRSPEED==0||FEAT_INSTRSPEED>1 + lda v_ainstrspeed + ELS + lda #1 + EIF + rts +SetPokey + IFT STEREOMODE==1 ;* L1 L2 L3 L4 R1 R2 R3 R4 + ldy #$ff +v_audctl2 equ *-1 + lda trackn_audf+0+4 + ldx trackn_audf+0 +xstastx01 sta $d210 + stx $d200 + lda trackn_audc+0+4 + ldx trackn_audc+0 +xstastx02 sta $d211 + stx $d201 + lda trackn_audf+1+4 + ldx trackn_audf+1 +xstastx03 sta $d212 + stx $d202 + lda trackn_audc+1+4 + ldx trackn_audc+1 +xstastx04 sta $d213 + stx $d203 + lda trackn_audf+2+4 + ldx trackn_audf+2 +xstastx05 sta $d214 + stx $d204 + lda trackn_audc+2+4 + ldx trackn_audc+2 +xstastx06 sta $d215 + stx $d205 + lda trackn_audf+3+4 + ldx trackn_audf+3 +xstastx07 sta $d216 + stx $d206 + lda trackn_audc+3+4 + ldx trackn_audc+3 +xstastx08 sta $d217 + stx $d207 + lda #$ff +v_audctl equ *-1 +xstysta01 sty $d218 + sta $d208 + ELI STEREOMODE==0 ;* L1 L2 L3 L4 + ldy #$ff +v_audctl equ *-1 + lda trackn_audf+0 + ldx trackn_audc+0 + sta $d200 + stx $d201 + lda trackn_audf+1 + ldx trackn_audc+1 + sta $d200+2 + stx $d201+2 + lda trackn_audf+2 + ldx trackn_audc+2 + sta $d200+4 + stx $d201+4 + lda trackn_audf+3 + ldx trackn_audc+3 + sta $d200+6 + stx $d201+6 + sty $d208 + ELI STEREOMODE==2 ;* L1 R2 R3 L4 + ldy #$ff +v_audctl equ *-1 + lda trackn_audf+0 + ldx trackn_audc+0 + sta $d200 + stx $d201 + sta $d210 + lda trackn_audf+1 + ldx trackn_audc+1 + sta $d210+2 + stx $d211+2 + lda trackn_audf+2 + ldx trackn_audc+2 + sta $d210+4 + stx $d211+4 + sta $d200+4 + lda trackn_audf+3 + ldx trackn_audc+3 + sta $d200+6 + stx $d201+6 + sta $d210+6 + sty $d218 + sty $d208 + ELI STEREOMODE==3 ;* L1 L2 R3 R4 + ldy #$ff +v_audctl equ *-1 + lda trackn_audf+0 + ldx trackn_audc+0 + sta $d200 + stx $d201 + lda trackn_audf+1 + ldx trackn_audc+1 + sta $d200+2 + stx $d201+2 + lda trackn_audf+2 + ldx trackn_audc+2 + sta $d210+4 + stx $d211+4 + sta $d200+4 + lda trackn_audf+3 + ldx trackn_audc+3 + sta $d210+6 + stx $d211+6 + sta $d200+6 + sty $d218 + sty $d208 + EIF + rts +RMTEND Index: apps/plugins/asap/players/rmt4.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\rmt4.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/rmt8.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\rmt8.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/tm2.asx =================================================================== --- apps/plugins/asap/players/tm2.asx (revision 0) +++ apps/plugins/asap/players/tm2.asx (revision 0) @@ -0,0 +1,1551 @@ +;------------------- +; TMC 2.00 Player +;------------------ + +player equ $200 +normal equ 1 ; change to 0 for short version + + org player + +addr equ $fa +byte equ $fc +bajt equ $fd +filter equ $fe +maxvol equ $ff + +; some tables on start (to avoid page breaking) + +voltab dta d' ' + dta d' !!!!!!!!' + dta d' !!!!!!!!""""' + dta d' !!!!!"""""###' + dta d' !!!!""""####$$' + dta d' !!!"""###$$$%%' + dta d' !!"""##$$$%%&&' + dta d' !!""##$$%%&&''''' + dta d' !!""##$$%%&&''''(' + dta d' !!""#$$%%&''''(()' + dta d' !!"##$%%&''''())*' + dta d' !!"#$$%&''''()**+' + dta d' !""#$%&&''()**+,' + dta d' !"##$%&''()**+,-' + dta d' !"#$%&''''()*+,-.' + dta d' !"#$%&''()*+,-./' + +frqtab dta 0,$f1,$e4,$d7 + dta $cb,$c0,$b5,$aa + dta $a1,$98,$8f,$87 + dta $7f,$78,$72,$6b + dta $65,$5f,$5a,$55 + dta $50,$4b,$47,$43 + dta $3f,$3c,$38,$35 + dta $32,$2f,$2c,$2a + dta $27,$25,$23,$21 + dta $1f,$1d,$1c,$1a + dta $18,$17,$16,$14 + dta $13,$12,$11,$10 + dta 15,14,13,12 + dta 11,10,9,8 + dta 7,6,5,4 + dta 3,2,1,0 + + dta 0,$f2,$e9,$da + dta $ce,$bf,$b6,$aa + dta $a1,$98,$8f,$89 + dta $80,$7a,$71,$6b + dta $65,$5f,$5c,$56 + dta $50,$4d,$47,$44 + dta $3e,$3c,$38,$35 + dta $32,$2f,$2d,$2a + dta $28,$25,$23,$21 + dta $1f,$1d,$1c,$1a + dta $18,$17,$16,$14 + dta $13,$12,$11,$10 + dta 15,14,13,12 + dta 11,10,9,8 + dta 7,6,5,4 + dta 3,2,1,0 + + dta 0,$ff,$f1,$e4 + dta $d8,$ca,$c0,$b5 + dta $ab,$a2,$99,$8e + dta $87,$7f,$79,$73 + dta $70,$66,$61,$5a + dta $55,$52,$4b,$48 + dta $43,$3f,$3c,$39 + dta $37,$33,$30,$2d + dta $2a,$28,$25,$24 + dta $21,$1f,$1e,$1c + dta $1b,$19,$17,$16 + dta $15,$13,$12,$11 + dta $10,15,14,13 + dta 12,11,10,9 + dta 8,7,6,5 + dta 4,3,2,1 + + dta 0,$f3,$e6,$d9 + dta $cc,$c1,$b5,$ad + dta $a2,$99,$90,$88 + dta $80,$79,$72,$6c + dta $66,$60,$5b,$55 + dta $51,$4c,$48,$44 + dta $40,$3c,$39,$35 + dta $32,$2f,$2d,$2a + dta $28,$25,$23,$21 + dta $1f,$1d,$1c,$1a + dta $18,$17,$16,$14 + dta $13,$12,$11,$10 + dta 15,14,13,12 + dta 11,10,9,8 + dta 7,6,5,4 + dta 3,2,1,0 + +basslo dta l($be2,$b38,$a8c,$a00) + dta l($96a,$8e8,$86a,$7ef) + dta l($780,$708,$6ae,$646) + dta l($5e6,$595,$541,$4f6) + dta l($4b0,$46e,$430,$3f6) + dta l($3bb,$384,$352,$322) + dta l($2f4,$2c8,$2a0,$27a) + dta l($255,$234,$214,$1f5) + dta l($1d8,$1bd,$1a4,$18d) + dta l($177,$160,$14e,$138) + dta l($127,$115,$106,$0f7) + dta l($0e8,$0db,$0cf,$0c3) + dta l($0b8,$0ac,$0a2,$09a) + dta l($090,$088,$07f,$078) + dta l($070,$06a,$064,$05e) + dta l($057,$052,$032,$00a) + + dta 0,$f2,$33,$96 + dta $e2,$38,$8c,$00 + dta $6a,$e8,$6a,$ef + dta $80,$08,$ae,$46 + dta $e6,$95,$41,$f6 + dta $b0,$6e,$30,$f6 + dta $bb,$84,$52,$22 + dta $f4,$c8,$a0,$7a + dta $55,$34,$14,$f5 + dta $d8,$bd,$a4,$8d + dta $77,$60,$4e,$38 + dta $27,$15,$06,$f7 + dta $e8,$db,$cf,$c3 + dta $b8,$ac,$a2,$9a + dta $90,$88,$7f,$78 + dta $70,$6a,$64,$5e + +basshi dta h($be2,$b38,$a8c,$a00) + dta h($96a,$8e8,$86a,$7ef) + dta h($780,$708,$6ae,$646) + dta h($5e6,$595,$541,$4f6) + dta h($4b0,$46e,$430,$3f6) + dta h($3bb,$384,$352,$322) + dta h($2f4,$2c8,$2a0,$27a) + dta h($255,$234,$214,$1f5) + dta h($1d8,$1bd,$1a4,$18d) + dta h($177,$160,$14e,$138) + dta h($127,$115,$106,$0f7) + dta h($0e8,$0db,$0cf,$0c3) + dta h($0b8,$0ac,$0a2,$09a) + dta h($090,$088,$07f,$078) + dta h($070,$06a,$064,$05e) + dta h($057,$052,$032,$00a) + + dta 0,13,13,12 + dta 11,11,10,10 + dta 9,8,8,7 + dta 7,7,6,6 + dta 5,5,5,4 + dta 4,4,4,3 + dta 3,3,3,3 + dta 2,2,2,2 + dta 2,2,2,1 + dta 1,1,1,1 + dta 1,1,1,1 + dta 1,1,1,0 + dta 0,0,0,0 + dta 0,0,0,0 + dta 0,0,0,0 + dta 0,0,0,0 + +tables_len equ *-player + +; org +$300 + jmp init + jmp play + jmp sound + +; some external controls +quadro dta 1 ; 0=mono, 1-63=stereo, 64-127= RMT stereo, 128-255=quadro +pokeys dta 16 ; which data should go to which pokey (0,1,2 and 3 respectively) + dta 20 ; for stereo config: 16=first 4 tracks, 20=last 4 tracks + dta 0 ; for quadro values should be: + dta 0 ; 0=main volume from tracks 0-3, 4=main volume from tracks 4-5 + ; 8=additional volume from tracks 0-3, 12=additional volume from tracks 4-5 + ; typical: 0,4,12,8 which should sound well on pokeys 0&2 on left channel + ; and pokeys 1&3 on right channel + ; (on stereo atari these settings should also sound well) +silent dta d' ' ; which channel should be silent + +; these values are usable from the outside of player +czygrc dta 0 ; if song should be played +pozsng dta 0 ; position in song + +specialflag dta 0 ; flag triggered in song data +adrsng dta a(0) ; address of song line + +tempo dta 0 ; tempo of song +ltempo dta 0 ; counter of tempo +pozptr dta 0 ; counter of positions in patterns (64 means end of pattern) + + ift normal ; !!! + +aud1 dta 0 ; total AUDCTL of left channel +aud2 dta 0 ; and right + +voltabs equ * ; (24 bytes) + + eif ; !!! + +vol1ch dta d' ' ; volume of main channels + + ift normal ; !!! + +vol2ch dta d' ' ; volume of additional channels +volume dta d' ' ; volume of channels in stereo (taken from vol1ch and vol2ch) + +freqtabs equ * ; (24 bytes) + + eif ; !!! + +frq dta d' ' ; frequency + + ift normal ; !!! + +note dta d' ' ; actual note played on channel (taken from aktwys) +freqen dta d' ' ; frequency of channels in stereo (taken from frq) + + eif ; !!! + +; data for accesing pattern data +adrptl dta d' ' ; address of pattern data +adrpth dta d' ' ; +pozwpt dta d' ' ; index for accesing data in pattern +poddzw dta d' ' ; change of note +delay dta d' ' ; how many spaces in pattern should be skipped + +; data for accesing instrument data +czygrx dta d' ' ; if something is played on channel +adrsnl dta d' ' ; address of instrument data +adrsnh dta d' ' ; +numdzw dta d' ' ; number of instrument +wysdzw dta d' ' ; note to play +aktwys dta d' ' ; actual played note +znksz dta d' ' ; distortion +audctl dta d' ' ; AUDCTL +slupy dta d' ' ; counter for data inside instrument + +; data for specific sound effects +sndlen dta d' ' ; length of instrument +sndlop dta d' ' ; where to loop sound data +actvol dta d' ' ; volume of sounds +actvl1 dta d' ' ; actual control of main volume + + ift normal ; !!! + +actvl2 dta d' ' ; and additional volume + + eif ; !!! + +opad1 dta d' ' ; how soon the sound should fade (main volume) +opad2 dta d' ' ; and additional volume +lopad1 dta d' ' ; counters for fading +lopad2 dta d' ' ; +opadst dta d' ' ; start of fading +typ dta d' ' ; type of effect +param dta d' ' ; parameter for effect +typdat dta d' ' ; data for effect +czekaj dta d' ' ; how soon the effect should start +dtyp dta d' ' ; how often the effect should chanfe +ltyp dta d' ' ; counter for effect change +ilperm dta d' ' ; how many arpeggio sounds +aperm dta d' ' ; actual arpeggio sound +dperm dta d' ' ; how soon the arpeggio should change +lperm dta d' ' ; counter for arpeggio +kolejn dta d' ' ; order of arpeggio +sndfilter dta d' ' ; filter from sound data +mainaudctl dta d' ' ; main audctl +addaudctl dta d' ' ; additional audctl +shiftfrq dta d' ' +shiftnote dta d' ' +shiftfilter dta d' ' + +; some useful tables + + ift normal ; !!! + +przeci dta 4,5,6,7 ; which channel is the opposite (used only in stereo) + dta 0,1,2,3 + + eif ; !!! + +audtb1 dta 4,2,0,0 ; which byte in audctl has to be set to make sound "2 channel synth" + dta 4,2,0,0 +audtb2 dta 0,16,0,8 ; which byte in audctl has to be set to make sound "2 channel bass" + dta 0,16,0,8 +usedaudctl dta 4+129,$50+2+129,129,$28+129 ; bits of AUDCTL used in channel + dta 4+129,$50+2+129,129,$28+129 + +;------------------------- +; start of player program + +player_program equ * + +; new address of song line +p3 dey + lda (addr),y + sta pozsng + mvx #0 byte + asl @ + rol byte + asl @ + rol byte + asl @ + rol byte + asl @ + rol byte + adc pozsng ; clc + scc:inc byte + clc +zm0 adc #0 + sta addr + lda byte +zm1 adc #0 + sta addr+1 + jmp p1 + +; play song (call only one time per frame) +play jsr pokey + lda czygrc + beq rsound + dec ltempo + bmi p4 +rsound jmp sound+3 + +p4 dec pozptr + bne r1 + +; get new patterns from song + ldx #0 + inc pozsng + mwa adrsng addr + +p1 ldy #16 + lda (addr),y + bmi p3 + jeq stop + sta pozptr + dey + +p2 lda (addr),y + dey + sty byte + tay +zm2 lda $ffff,y + sta adrptl,x +zm3 lda $ffff,y + sta adrpth,x + lda #0 + sta delay,x + sta pozwpt,x + ldy byte + lda (addr),y + sta poddzw,x + inx + dey + bpl p2 + lda #17 + add addr + sta adrsng + lda #0 + adc addr+1 + sta adrsng+1 + +; get new data from patterns +r1 mva tempo ltempo + + ldx #7 +r2 dec delay,x + bmi r13 + +r14 dex + bpl r2 + jmp sound+3 + +r13 mva adrptl,x addr + mva adrpth,x addr+1 + + ldy pozwpt,x +r3 lda (addr),y ; get data + bne r4 + + iny ; $00: only new volume + lda (addr),y + sta actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda (addr),y + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + iny + tya + sta pozwpt,x + jmp r14 + +r4 cmp #$40 + bcs r5 + adc poddzw,x ; $01-$3f: new note with sound and maybe volume + sta wysdzw,x + iny + lda (addr),y + bpl r11 + and #$7f + sta byte + iny + lda (addr),y + sta actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda (addr),y + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + iny + tya + sta pozwpt,x + ldy byte + jsr dzwiek + jmp r14 + +r11 tay ; without volume + inc pozwpt,x + inc pozwpt,x + lda actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda actvol,x + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + jsr dzwiek + jmp r14 + +r5 cmp #$80 + bcs r6 + and #$3f ; $41-$7f: new note with volume + add poddzw,x + sta wysdzw,x + iny + lda (addr),y + sta actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda (addr),y + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + iny + tya + sta pozwpt,x + jmp r14 + +r6 bne r7 + iny ; $80: more than 15 spaces + lda (addr),y + sta delay,x + iny + tya + sta pozwpt,x + jmp r14 + +r7 cmp #$c0 + bcs r8 + and #$3f ; $81-$bf: new note + add poddzw,x + sta wysdzw,x + inc pozwpt,x + jmp r14 + +r8 cmp #$d0 + bcs r9 + iny ; $c0-$cf: new tempo + inc pozwpt,x + and #15 + sta tempo + sta ltempo + jmp r3 + +r9 cmp #$e0 ; special code + bcs r15 + mva (addr),y byte + iny + mva (addr),y bajt + iny + tya + sta pozwpt,x + lda byte + jsr specialcode + jmp r14 + +r15 cmp #$f0 ; special code with volume + bcs r12 + mva (addr),y byte + iny + mva (addr),y bajt + lda byte + jsr specialcode + ldy pozwpt,x + iny + iny + lda (addr),y + sta actvol,x + and #$f0 + sta actvl1,x + + ift normal ; !!! + + lda (addr),y + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + iny + tya + sta pozwpt,x + jmp r14 + +r12 cmp #$ff + bcs r10 + sbc #$ef ; $f0-$fe: spaces-$f0 (c is clear here) + sta delay,x + inc pozwpt,x + jmp r14 + +r10 lda #$40 ; $ff: spaces till the end of pattern + sta delay,x + jmp r14 + +; main play sound loop +sound jsr pokey + ldx #7 +p5 lda czygrx,x + beq p6 + jmp graj + +grajreturn equ * + lda silent,x + beq p7 + + lda #0 ; silent channel + sta vol1ch,x + + ift normal ; !!! + + sta vol2ch,x + + eif ; !!! + + dex + bpl p5 + jmp p8 + +p7 ldy bajt + lda frqtab,y + add byte + sta frq,x + tya + sta aktwys,x + + lda audctl,x + and audtb2,x + beq p11 + lda bajt ; 2 channel bass + and #$7f + tay + lda basslo,y + add byte + sta frq-1,x + lda basshi,y + adc #0 + sta frq,x + lda #0 + sta vol1ch-1,x + ldy przeci,x + sta vol2ch-1,y + dex + dex + bpl p5 + jmp p8 + +p11 lda audctl,x + and audtb1,x + beq p6 + lda sndfilter,x ;two channel filter + add bajt + sta aktwys+2,x + tay + lda frqtab,y + add byte + sec + adc filter + sta frq+2,x + +p6 dex + bpl p5 + +; sound postprocessing +p8 inx + stx byte + + ift normal ; !!! + + ldx #3 + lda quadro + beq p9 + and #$40 + bne p12 + + ldx #7 ; standard stereo settings +p9 txa + tay + lda vol1ch,y + bne p10 + ldy przeci,x + lda vol2ch,y + bne p10 + txa + tay + lda #0 +p10 ora znksz,y + sta volume,x + lda frq,y + sta freqen,x + lda aktwys,y + sta note,x + + lda audctl,y + ora byte + sta byte + + cpx #4 + sne:sta aud2 + dex + bpl p9 + sta aud1 + rts + +p12 equ * ; RMT stereo +p13 lda vol1ch,x + ora znksz,x + sta volume,x + lda vol2ch+4,x + ora znksz+4,x + sta volume+4,x + mva frq,x freqen,x + mva frq+4,x freqen+4,x + mva aktwys,x note,x + mva aktwys+4,x note+4,x + dex + bpl p13 + + lda audctl + ora audctl+1 + ora audctl+2 + ora audctl+3 + sta aud1 + lda audctl+4 + ora audctl+5 + ora audctl+6 + ora audctl+7 + sta aud2 + rts + +; set pokey +pokey lda quadro + jeq pokey1 + jpl pokey2 + + lda pokeys+3 ; data for pokey 3 + tax + lsr @ + lsr @ + and #1 + tay + lda aud1,y + sta $d238 + txa + and #4 + tay + lda freqtabs,y + sta $d230 + lda voltabs,x + sta $d231 + lda freqtabs+1,y + sta $d232 + lda voltabs+1,x + sta $d233 + lda freqtabs+2,y + sta $d234 + lda voltabs+2,x + sta $d235 + lda freqtabs+3,y + sta $d236 + lda voltabs+3,x + sta $d237 + + lda pokeys+2 ; data for pokey 2 + tax + lsr @ + lsr @ + and #1 + tay + lda aud1,y + sta $d228 + txa + and #4 + tay + lda freqtabs,y + sta $d220 + lda voltabs,x + sta $d221 + lda freqtabs+1,y + sta $d222 + lda voltabs+1,x + sta $d223 + lda freqtabs+2,y + sta $d224 + lda voltabs+2,x + sta $d225 + lda freqtabs+3,y + sta $d226 + lda voltabs+3,x + sta $d227 + +pokey2 lda pokeys+1 ; data for pokey 1 + tax + lsr @ + lsr @ + and #1 + tay + lda aud1,y + sta $d218 + txa + ldy quadro + spl:and #4 + tay + lda freqtabs,y + sta $d210 + lda voltabs,x + sta $d211 + lda freqtabs+1,y + sta $d212 + lda voltabs+1,x + sta $d213 + lda freqtabs+2,y + sta $d214 + lda voltabs+2,x + sta $d215 + lda freqtabs+3,y + sta $d216 + lda voltabs+3,x + sta $d217 + +pokey1 lda pokeys ; data for pokey 0 + tax + lsr @ + lsr @ + and #1 + tay + lda aud1,y + sta $d208 + txa + ldy quadro + spl:and #4 + tay + lda freqtabs,y + sta $d200 + lda voltabs,x + sta $d201 + lda freqtabs+1,y + sta $d202 + lda voltabs+1,x + sta $d203 + lda freqtabs+2,y + sta $d204 + lda voltabs+2,x + sta $d205 + lda freqtabs+3,y + sta $d206 + lda voltabs+3,x + sta $d207 + rts + + els ; !!! + + rts + +pokey lda audctl+4 + ora audctl+5 + ora audctl+6 + ora audctl+7 + sta $d218 + lda frq+4 + sta $d210 + lda vol1ch+4 + ora znksz+4 + sta $d211 + lda frq+5 + sta $d212 + lda vol1ch+5 + ora znksz+5 + sta $d213 + lda frq+6 + sta $d214 + lda vol1ch+6 + ora znksz+6 + sta $d215 + lda frq+7 + sta $d216 + lda vol1ch+7 + ora znksz+7 + sta $d217 + + lda audctl+0 + ora audctl+1 + ora audctl+2 + ora audctl+3 + sta $d208 + lda frq+0 + sta $d200 + lda vol1ch+0 + ora znksz+0 + sta $d201 + lda frq+1 + sta $d202 + lda vol1ch+1 + ora znksz+1 + sta $d203 + lda frq+2 + sta $d204 + lda vol1ch+2 + ora znksz+2 + sta $d205 + lda frq+3 + sta $d206 + lda vol1ch+3 + ora znksz+3 + sta $d207 + rts + + eif ; !!! + +; sound processing +graj lda adrsnl,x + sta addr + lda adrsnh,x + sta addr+1 + + mva shiftfrq,x byte + mva shiftnote,x bajt + mva shiftfilter,x filter + + lda slupy,x + cmp sndlen,x + bcc n1 + sta opadst,x + lda sndlop,x + sta slupy,x + jmp n0 + +n1 lda opadst,x ; sound fading + beq n6 +n0 lda opad1,x + beq n7 + dec lopad1,x + bne n7 + sta lopad1,x + lda actvl1,x + beq n7 + sub #16 + sta actvl1,x +n7 lda opad2,x + beq n6 + dec lopad2,x + bne n6 + sta lopad2,x + + ift normal ; !!! + + lda actvl2,x + beq n6 + sub #16 + sta actvl2,x + + eif ; !!! + +n6 ldy aperm,x ; arpeggio + lda (addr),y + add wysdzw,x + add:sta bajt + dec lperm,x + bpl m1 + lda dperm,x + sta lperm,x + lda kolejn,x + beq m6 + add aperm,x + sta aperm,x + beq m7 + cmp ilperm,x + bcc m1 + lda #$ff + sta kolejn,x + jmp m1 + +m7 lda #1 + sta kolejn,x + jmp m1 + +m6 inc aperm,x + lda ilperm,x + cmp aperm,x + bcs m1 + lda #0 + sta aperm,x + +m1 lda #19 + add:sta addr + scc:inc addr+1 + + ldy slupy,x + lda (addr),y ; main sound data + and #$f0 + sta znksz,x + lda (addr),y + and #15 + ora actvl1,x + tay + lda voltab,y + ora maxvol + tay + lda voltab,y + sta vol1ch,x + + ift normal ; !!! + + ldy slupy,x + iny + lda (addr),y + and #15 + ora actvl2,x + tay + lda voltab,y + ora maxvol + tay + lda voltab,y + sta vol2ch,x + + eif ; !!! + + lda czekaj,x + bne m2 + lda typ,x + sta m5+1 +m5 bpl * ; jmp + jmp typ0 + nop + jmp typ1 + nop + jmp typ2 + nop + jmp typ3 + nop + jmp typ4 + nop + jmp typ5 + nop + jmp typ6 + nop + jmp typ7 + +m2 dec czekaj,x +m3 ldy slupy,x ; accents + iny + lda (addr),y + and #$70 + lsr @ + lsr @ + lsr @ + sta n5+1 + lda (addr),y + bmi n3 + lda mainaudctl,x + jmp n4 +n3 lda addaudctl,x +n4 and usedaudctl,x + sta audctl,x + iny + iny + tya + sta slupy,x + dey + lda (addr),y +n5 bcc * ; jmp + bcc a0 + bcc a1 + bcc a2 + bcc a3 + bcc a4 + bcc a5 + bcc a6 + bcc a7 + +; accents +a1 adc:sta shiftfrq,x + lda (addr),y +a0 add:sta byte + jmp grajreturn + +a3 adc:sta shiftnote,x + lda (addr),y +a2 add:sta bajt + jmp grajreturn + +a5 adc:sta shiftfilter,x + lda (addr),y +a4 add:sta filter + jmp grajreturn + +a6 sta byte + lda #0 +a7 sta bajt + jmp grajreturn + +; effects +typ1 lda typdat,x + and #3 + lsr @ + bcc t0 + bne t1 + lda param,x + add:sta byte +t0 dec ltyp,x + bpl typ0 + inc typdat,x + mva dtyp,x ltyp,x + jmp m3 + +t1 lda byte + sbc param,x ; sec + sta byte + dec ltyp,x + bpl typ0 + inc typdat,x + mva dtyp,x ltyp,x + jmp m3 + +typ2 ldy typdat,x + lda param,x + bmi t2 + iny + iny +t2 dey + tya + add:sta byte + dec ltyp,x + bpl typ0 + tya + sta typdat,x + cmp param,x + bne t3 + eor #$ff + sta param,x +t3 mva dtyp,x ltyp,x +typ0 jmp m3 + +typ3 ldy typdat,x + lda param,x + bmi t4 + iny + iny +t4 dey + tya + add:sta bajt + dec ltyp,x + bpl typ0 + tya + sta typdat,x + cmp param,x + bne t3 + eor #$ff + sta param,x + mva dtyp,x ltyp,x + jmp m3 + +typ4 lda typdat,x + add:sta byte + dec ltyp,x + bpl typ0 + lda param,x + add:sta typdat,x + mva dtyp,x ltyp,x + jmp m3 + +typ5 lda bajt + sub typdat,x + sta bajt + dec ltyp,x + bpl typ0 + lda param,x + add:sta typdat,x + mva dtyp,x ltyp,x + jmp m3 + +typ6 lda param,x + add:sta byte +typ7 jmp m3 ; placeholder for new type of sound + +;---------------- +; init functions + +; play song, X=number of song +songx ldy #16 +zm4 lda #0 + sta addr +zm5 lda #0 + sta addr+1 + mva #0 pozsng +d5 txa + beq inic + lda (addr),y + seq:bpl d4 + dex +d4 lda #17 + add:sta addr + scc:inc addr+1 + inc pozsng + bne d5 + ldx #0 + +; play song, X=line of song +playx lda #0 + sta byte + txa + sta pozsng + asl @ + rol byte + asl @ + rol byte + asl @ + rol byte + asl @ + rol byte + adc pozsng ; clc + scc:inc byte + clc +zm6 adc #0 + sta addr + lda byte +zm7 adc #0 + sta addr+1 +inic jsr stop + mwa addr adrsng + ldx #7 +i4 mva #$ff actvol,x + lda #$f0 + sta actvl1,x + + ift normal ; !!! + + sta actvl2,x + + eif ; !!! + + dex + bpl i4 + lda #3 + sta $d20f + sta $d21f + + ift normal ; !!! + + sta $d22f + sta $d23f + + eif ; !!! + + dec pozsng + inx + stx ltempo + inx + stx pozptr + stx czygrc + rts + +i1 txa ; change of tempo + and #15 + sta tempo + rts +i2 stx czygrc ; pause, continue + rts + +init cmp #$10 ; A=$00 + jcc songx + cmp #$20 ; A=$10 + bcc playx + cmp #$30 ; A=$20 + jcc d2 + cmp #$40 ; A=$30 + bcc i1 + cmp #$50 ; A=$40 + jcc stop + cmp #$60 ; A=$50 + bcc i2 + cmp #$70 ; A=$60 + jcs i3 + sty bajt + +specialcode and #15 + asl @ + sta sc17+1 + lda bajt +sc17 bcc * ; jmp + bcc sc0 + bcc sc1 + bcc sc2 + bcc sc3 + bcc sc4 + bcc sc5 + bcc sc6 + bcc sc7 + bcc sc8 + bcc sc9 + bcc sc10 + bcc sc11 + bcc sc12 + bcc sc13 + bcc sc14 + bcc sc15 + +sc0 sta specialflag ; code 0: set special flag +sc10 equ * +sc11 equ * +sc12 equ * +sc13 equ * +sc14 equ * +sc15 equ * + rts + +; special codes +sc4 sta sndfilter,x + rts +sc5 sta mainaudctl,x + rts +sc6 sta addaudctl,x + rts +sc7 sta shiftfilter,x + rts +sc8 sta shiftfrq,x + rts +sc9 sta shiftnote,x + rts + +sc1 and #$70 + lsr @ + lsr @ + sta typ,x + and #$30 + sne:sta typdat,x + lda bajt + bmi sc16 + and #15 + sta param,x + rts + +sc16 and #15 + eor #$ff + add #1 + sta param,x + rts + +sc2 and #$3f + sta dtyp,x + sta ltyp,x + rts + +sc3 and #$80 + asl @ + rol @ + sta kolejn,x + lda bajt + and #$70 + lsr @ + lsr @ + lsr @ + lsr @ + sta ilperm,x + sne:sta kolejn,x + lda bajt + and #15 + sta dperm,x + sta lperm,x + lda aperm,x + cmp ilperm,x + bcc sc0 + lda ilperm,x + seq:sbc #1 ; sec + sta aperm,x + rts + +; init of new song +i3 sty addr + stx addr+1 + + ldy #25 + mva (addr),y+ quadro + mva (addr),y+ pokeys + mva (addr),y+ pokeys+1 + mva (addr),y+ pokeys+2 + mva (addr),y+ pokeys+3 + lda (addr),y + sta tempo + + lda addr ; low byte of instruments data + eor #$80 + smi:inx + sta zm8+1 + stx zm8+2 + + eor #$80 ; low byte of pattern data + smi:inx + sta zm2+1 + stx zm2+2 + + inx ; high byte of pattern data + sta zm3+1 + stx zm3+2 + + inx ; high byte of instrument data + sta zm9+1 + stx zm9+2 + + eor #$80 ; track data + smi:inx + sta adrsng + sta zm0+1 + sta zm4+1 + sta zm6+1 + stx adrsng+1 + stx zm1+1 + stx zm5+1 + stx zm7+1 + + mva #$f0 maxvol + lda #0 + sta czygrc + sta specialflag + +; stop playing +stop ldx #7 + lda #0 + sta czygrc +d9 sta czygrx,x + sta audctl,x + sta vol1ch,x + + ift normal ; !!! + + sta vol2ch,x + sta volume,x + sta $d230,x + sta $d220,x + + eif ; !!! + + sta $d210,x + sta $d200,x + dex + bpl d9 + sta $d218 + sta $d208 + + ift normal ; !!! + + sta $d238 + sta $d228 + sta aud1 + sta aud2 + + eif ; !!! + rts + +; procedures for play new instrument +d1 sta vol1ch,x ; if attempt to play empty sound - clear data + + ift normal ; !!! + + sta vol2ch,x + sta volume,x + + eif ; !!! + + sta audctl,x + rts + +d0 tya ; change only volume + sta actvol,x +d3 and #$f0 + sta actvl1,x + lda actvol,x + + ift normal ; !!! + + asl @ + asl @ + asl @ + asl @ + sta actvl2,x + + eif ; !!! + + rts + +d2 and #7 + sta addr + txa + ldx addr + and #$3f + beq d0 + sta wysdzw,x + tya + bmi d2-1 + lda actvol,x + jsr d3 +dzwiek mva #0 czygrx,x +zm9 lda $ffff,y + beq d1 + sta adrsnh,x + sta addr+1 +zm8 lda $ffff,y + sta adrsnl,x + sta addr + tya + sta numdzw,x + + ldy #8 + mva (addr),y+ sndlen,x + mva (addr),y+ sndlop,x + mva (addr),y+ sndfilter,x + mva (addr),y+ mainaudctl,x + mva (addr),y+ addaudctl,x + mva (addr),y+ opad1,x + sta lopad1,x + mva (addr),y+ opad2,x + sta lopad2,x + lda (addr),y + and #$70 + lsr @ + lsr @ + sta typ,x + + lda (addr),y+ + bmi d7 + and #15 + sta param,x + jmp d8 +d7 and #15 + eor #$ff + add #1 + sta param,x + +d8 mva (addr),y+ czekaj,x + lda (addr),y+ + and #$3f + sta dtyp,x + sta ltyp,x + lda (addr),y + and #$80 + asl @ + rol @ + sta kolejn,x + lda (addr),y + and #$70 + lsr @ + lsr @ + lsr @ + lsr @ + sta ilperm,x + bne d6 + sta kolejn,x +d6 lda (addr),y- + and #15 + sta dperm,x + sta lperm,x + lda (addr),y + and #$c0 + ora wysdzw,x + sta wysdzw,x + tay + lda frqtab,y + sta frq,x + + lda #0 + sta slupy,x + sta typdat,x + sta opadst,x + sta aperm,x + sta shiftfrq,x + sta shiftnote,x + sta shiftfilter,x + lda #1 + sta czygrx,x + rts + +endplr end Index: apps/plugins/asap/players/tm2.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\tm2.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/players/tmc.asx =================================================================== --- apps/plugins/asap/players/tmc.asx (revision 0) +++ apps/plugins/asap/players/tmc.asx (revision 0) @@ -0,0 +1,963 @@ +*---------------* +* TMC Player * +*Jaskier/Taquart* +*---------------* + + org $0500 + +byte equ $fa +bajt equ $fb +addr equ $fc +adrsng equ $fe + +player equ * + jmp init + jmp play + jmp sound + +maxvol dta b(15) +volume dta d' ' +freqen dta d' ' +kanal dta d' ' +aktwys dta d' ' +numdzw dta d' ' +audctl dta d' ' +aud1 dta b(0) +aud2 dta b(0) + +voltab dta d' ' + dta d' !!!!!!!!' + dta d' !!!!!!!!""""' + dta d' !!!!!"""""###' + dta d' !!!!""""####$$' + dta d' !!!"""###$$$%%' + dta d' !!"""##$$$%%&&' + dta d' !!""##$$%%&&''''' + dta d' !!""##$$%%&&''''(' + dta d' !!""#$$%%&''''(()' + dta d' !!"##$%%&''''())*' + dta d' !!"#$$%&''''()**+' + dta d' !""#$%&&''()**+,' + dta d' !"##$%&''()**+,-' + dta d' !"#$%&''''()*+,-.' + dta d' !"#$%&''()*+,-./' + +frqtab dta b(0),b($f1),b($e4),b($d7) + dta b($cb),b($c0),b($b5),b($aa) + dta b($a1),b($98),b($8f),b($87) + dta b($7f),b($78),b($72),b($6b) + dta b($65),b($5f),b($5a),b($55) + dta b($50),b($4b),b($47),b($43) + dta b($3f),b($3c),b($38),b($35) + dta b($32),b($2f),b($2c),b($2a) + dta b($27),b($25),b($23),b($21) + dta b($1f),b($1d),b($1c),b($1a) + dta b($18),b($17),b($16),b($14) + dta b($13),b($12),b($11),b($10) + dta b(15),b(14),b(13),b(12) + dta b(11),b(10),b(9),b(8) + dta b(7),b(6),b(5),b(4) + dta b(3),b(2),b(1),b(0) + + dta b(0),b($f2),b($e6),b($da) + dta b($ce),b($bf),b($b6),b($aa) + dta b($a1),b($98),b($8f),b($89) + dta b($80),b($7a),b($71),b($6b) + dta b($65),b($5f),b($5c),b($56) + dta b($50),b($4d),b($47),b($44) + dta b($3e),b($3c),b($38),b($35) + dta b($32),b($2f),b($2d),b($2a) + dta b($28),b($25),b($23),b($21) + dta b($1f),b($1d),b($1c),b($1a) + dta b($18),b($17),b($16),b($14) + dta b($13),b($12),b($11),b($10) + dta b(15),b(14),b(13),b(12) + dta b(11),b(10),b(9),b(8) + dta b(7),b(6),b(5),b(4) + dta b(3),b(2),b(1),b(0) + + dta b(0),b($ff),b($f1),b($e4) + dta b($d8),b($ca),b($c0),b($b5) + dta b($ab),b($a2),b($99),b($8e) + dta b($87),b($7f),b($79),b($73) + dta b($70),b($66),b($61),b($5a) + dta b($55),b($52),b($4b),b($48) + dta b($43),b($3f),b($3c),b($39) + dta b($37),b($33),b($30),b($2d) + dta b($2a),b($28),b($25),b($24) + dta b($21),b($1f),b($1e),b($1c) + dta b($1b),b($19),b($17),b($16) + dta b($15),b($13),b($12),b($11) + dta b($10),b(15),b(14),b(13) + dta b(12),b(11),b(10),b(9) + dta b(8),b(7),b(6),b(5) + dta b(4),b(3),b(2),b(1) + + dta b(0),b($f3),b($e6),b($d9) + dta b($cc),b($c1),b($b5),b($ad) + dta b($a2),b($99),b($90),b($88) + dta b($80),b($79),b($72),b($6c) + dta b($66),b($60),b($5b),b($55) + dta b($51),b($4c),b($48),b($44) + dta b($40),b($3c),b($39),b($35) + dta b($32),b($2f),b($2d),b($2a) + dta b($28),b($25),b($23),b($21) + dta b($1f),b($1d),b($1c),b($1a) + dta b($18),b($17),b($16),b($14) + dta b($13),b($12),b($11),b($10) + dta b(15),b(14),b(13),b(12) + dta b(11),b(10),b(9),b(8) + dta b(7),b(6),b(5),b(4) + dta b(3),b(2),b(1),b(0) + +basslo dta b(0),b($f2),b($33),b($96) + dta b($e2),b($38),b($8c),b($00) + dta b($6a),b($e8),b($6a),b($ef) + dta b($80),b($08),b($ae),b($46) + dta b($e6),b($95),b($41),b($f6) + dta b($b0),b($6e),b($30),b($f6) + dta b($bb),b($84),b($52),b($22) + dta b($f4),b($c8),b($a0),b($7a) + dta b($55),b($34),b($14),b($f5) + dta b($d8),b($bd),b($a4),b($8d) + dta b($77),b($60),b($4e),b($38) + dta b($27),b($15),b($06),b($f7) + dta b($e8),b($db),b($cf),b($c3) + dta b($b8),b($ac),b($a2),b($9a) + dta b($90),b($88),b($7f),b($78) + dta b($70),b($6a),b($64),b($5e) + +basshi dta b(0),b(13),b(13),b(12) + dta b(11),b(11),b(10),b(10) + dta b(9),b(8),b(8),b(7) + dta b(7),b(7),b(6),b(6) + dta b(5),b(5),b(5),b(4) + dta b(4),b(4),b(4),b(3) + dta b(3),b(3),b(3),b(3) + dta b(2),b(2),b(2),b(2) + dta b(2),b(2),b(2),b(1) + dta b(1),b(1),b(1),b(1) + dta b(1),b(1),b(1),b(1) + dta b(1),b(1),b(1),b(0) + dta b(0),b(0),b(0),b(0) + dta b(0),b(0),b(0),b(0) + dta b(0),b(0),b(0),b(0) + dta b(0),b(0),b(0),b(0) + +czygrx dta d' ' +pozwpt dta d' ' +delay dta d' ' +numptr dta d' ' +poddzw dta d' ' +wysdzw dta d' ' +znksz dta d' ' +frq dta d' ' +vol1ch dta d' ' +vol2ch dta d' ' +adcvl1 dta d' ' +adcvl2 dta d' ' +adrsnl dta d' ' +adrsnh dta d' ' +slupy dta d' ' +opad1 dta d' ' +opad2 dta d' ' +lopad1 dta d' ' +lopad2 dta d' ' +typ dta d' ' +param dta d' ' +pomoc1 dta d' ' +pomoc2 dta d' ' +czekaj dta d' ' +dtyp dta d' ' +ltyp dta d' ' +ilperm dta d' ' +aperm dta d' ' +dperm dta d' ' +lperm dta d' ' +kolejn dta d' ' +tempo dta b(0) +ltempo dta b(0) +pozptr dta b(0) +czygrc dta b(0) + +przeci dta b(4),b(5),b(6),b(7) + dta b(0),b(1),b(2),b(3) +audtb1 dta b(4),b(2),b(0),b(0) + dta b(4),b(2),b(0),b(0) +audtb2 dta b(0),b(16),b(0),b(8) + dta b(0),b(16),b(0),b(8) + +play lda czygrc + beq r1-3 + lda pozptr + cmp #64 + bcc r1 + dec ltempo + beq *+5 + jmp sound + + ldx #7 + lda #0 +p1 sta pozwpt,x + sta delay,x + dex + bpl p1 + sta pozptr + tax + ldy #15 +p2 lda (adrsng),y + bpl p3 + dey + lda (adrsng),y + bpl *+5 + jmp stop + stx addr + asl @ + asl @ + rol addr + asl @ + rol addr + asl @ + rol addr +zm0 adc #0 + sta adrsng + lda addr +zm1 adc #0 + sta adrsng+1 + bcc p2-2 +p3 sta numptr,x + dey + lda (adrsng),y + sta poddzw,x + inx + dey + bpl p2 + clc + lda adrsng + adc #16 + sta adrsng + bcc *+4 + inc adrsng+1 + jmp sound + +r1 dec ltempo + bpl r1-3 + inc pozptr + lda tempo + sta ltempo + ldx #7 +r2 dec delay,x + bmi *+5 + jmp r14 + ldy numptr,x +zm2 lda $ffff,y + sta addr +zm3 lda $ffff,y + sta addr+1 + ldy pozwpt,x +r3 lda (addr),y + bne r4 + jsr nparam + jmp r13 +r4 cmp #$40 + bcs r5 + adc poddzw,x + sta wysdzw,x + jsr nparam + ldy numdzw,x + jsr dzwiek + jmp r13 +r5 bne r8 + iny + inc pozwpt,x + lda (addr),y + bpl r6 + sta bajt + jsr nparam + lda bajt +r6 and #$7f + bne r7 + lda #64 + sta pozptr + bne r13 +r7 sta tempo + sta ltempo + bne r13 +r8 cmp #$80 + bcs r11 + and #$3f + adc poddzw,x + sta wysdzw,x + iny + inc pozwpt,x + lda (addr),y + and #127 + bne r9 + lda #64 + sta pozptr + bne r10 +r9 sta tempo + sta ltempo +r10 jsr nparam + ldy numdzw,x + jsr dzwiek + jmp r13 +r11 cmp #$c0 + bcs r12 + and #$3f + sta numdzw,x + iny + inc pozwpt,x + jmp r3 +r12 and #$3f + sta delay,x +r13 inc pozwpt,x +r14 dex + bmi sound + jmp r2 + +sound ldx #7 +p5 lda czygrx,x + beq p6 + jsr graj + lda audctl,x + and audtb1,x + beq p6 + ldy #71 + lda (addr),y + clc + adc aktwys,x + sta aktwys+2,x + tay + lda frqtab,y + sec + adc pomoc1,x + sta frq+2,x +p6 dex + bpl p5 + + asl maxvol + asl maxvol + asl maxvol + asl maxvol + inx + stx addr + stx addr+1 + ldx #7 +p9 txa + tay + lda vol1ch,y + bne p10 + ldy przeci,x + lda vol2ch,y + bne p10 + txa + tay + lda #0 +p10 sta byte + tya + sta kanal,x + lda frq,y + sta freqen,x + lda audctl,y + sta bajt + ora addr+1 + sta addr+1 + lda bajt + and audtb1,x + beq p11 + lda frq+2,y + sta freqen+2,x +p11 lda bajt + and audtb2,x + beq p12 + lda aktwys,y + and #$3f + tay + iny + sty addr + lda basshi-1,y + sta freqen,x + jmp p13 +p12 ldy addr + beq p13 + lda basslo-1,y + sta freqen,x + lda #0 + sta addr +p13 lda byte + ora maxvol + tay + lda voltab,y + ldy kanal,x + ora znksz,y + sta volume,x + cpx #4 + bne p14 + lda addr+1 + sta aud2 + lda #0 + sta addr+1 +p14 dex + bpl p9 + lsr maxvol + lsr maxvol + lsr maxvol + lsr maxvol + lda addr+1 +quit ldx #3 + stx $d21f + stx $d20f + ldx freqen+4 + ldy freqen + stx $d210 + sty $d200 + ldx volume+4 + ldy volume + stx $d211 + sty $d201 + ldx freqen+5 + ldy freqen+1 + stx $d212 + sty $d202 + ldx volume+5 + ldy volume+1 + stx $d213 + sty $d203 + ldx freqen+6 + ldy freqen+2 + stx $d214 + sty $d204 + ldx volume+6 + ldy volume+2 + stx $d215 + sty $d205 + ldx freqen+7 + ldy freqen+3 + stx $d216 + sty $d206 + ldx volume+7 + ldy volume+3 + stx $d217 + sty $d207 + sta aud1 + ldx aud2 + stx $d218 + sta $d208 + rts + +graj lda adrsnl,x + sta addr + lda adrsnh,x + sta addr+1 + ldy slupy,x + cpy #63 + beq n6 + inc slupy,x + inc slupy,x + inc slupy,x + lda (addr),y + and #$f0 + sta znksz,x + lda (addr),y + and #15 + sec + sbc adcvl1,x + bpl n1 + lda #0 +n1 sta vol1ch,x + iny + lda (addr),y + and #15 + sec + sbc adcvl2,x + bpl n2 + lda #0 +n2 sta vol2ch,x + lda (addr),y + and #$f0 + beq n8 + bpl n3 + ldy #73 + lda (addr),y + ldy slupy,x + dey + dey + bpl n4 +n3 lda #0 +n4 sta audctl,x + lda (addr),y + and #$70 + beq n9 + lsr @ + lsr @ + sta n5+1 + lda #0 + sta pomoc1,x + iny + lda (addr),y +n5 bcc * + nop + nop + nop + nop + jmp a1 + nop + jmp a2 + nop + jmp a3 + nop + jmp a4 + nop + jmp a5 + nop + jmp a6 + nop + jmp a7 +n6 lda opad1,x + beq n7 + dec lopad1,x + bne n7 + sta lopad1,x + lda vol1ch,x + and #15 + beq n7 + dec vol1ch,x +n7 lda opad2,x + beq n8 + dec lopad2,x + bne n8 + sta lopad2,x + lda vol2ch,x + and #15 + beq n8 + dec vol2ch,x +n8 ldy #72 + lda (addr),y + sta audctl,x +n9 lda aperm,x + clc + adc #63 + tay + lda (addr),y + adc wysdzw,x + sta aktwys,x + tay + lda frqtab,y + sta frq,x + dec lperm,x + bpl m1 + lda dperm,x + sta lperm,x + lda kolejn,x + beq m6 + clc + adc aperm,x + sta aperm,x + beq m7 + cmp ilperm,x + bne m1 + lda #$fe +m7 clc + adc #1 + sta kolejn,x + bne m1 +m6 inc aperm,x + lda ilperm,x + cmp aperm,x + bcs m1 + lda #0 + sta aperm,x +m1 lda czekaj,x + beq m2 + dec czekaj,x + rts +m2 lda pomoc2,x + sta byte + lda param,x + sta bajt + jsr m4 + dec ltyp,x + bpl m4-1 + lda byte + sta pomoc2,x + lda bajt + sta param,x + lda dtyp,x + sta ltyp,x + rts +m4 lda typ,x + sta m5+1 +m5 bpl * + jmp typ0 + nop + jmp typ1 + nop + jmp typ2 + nop + jmp typ3 + nop + jmp typ4 + nop + jmp typ5 + nop + jmp typ6 + nop + jmp typ7 + +typ1 lda byte + inc byte + and #3 + lsr @ + bcc t2 + bne typ6 + lda bajt +t1 sta pomoc1,x + clc + adc frq,x + sta frq,x +typ0 rts +t2 lda #0 + sta pomoc1,x + rts +typ2 jsr t5 + jmp t1 +typ3 jsr t5 + clc + adc aktwys,x + jmp a5 +typ4 lda byte + sta pomoc1,x + clc + adc frq,x +t3 sta frq,x + lda byte + clc + adc bajt + sta byte + rts +typ5 lda aktwys,x + sec + sbc byte + sta aktwys,x + tay + lda frqtab,y + jmp t3 +typ6 lda frq,x + sec + sbc bajt + sta frq,x + sec + lda #0 + sbc bajt + sta pomoc1,x + rts +typ7 lda ltyp,x + bne typ0 + lda bajt + bpl t4 + lda vol2ch,x + beq typ0 + lda vol1ch,x + cmp #15 + beq typ0 + inc vol1ch,x + rts +t4 lda vol1ch,x + beq typ0 + lda vol2ch,x + cmp #15 + beq typ0 + inc vol2ch,x + rts +t5 ldy byte + lda bajt + bmi t6 + iny + iny +t6 dey + tya + sta byte + cmp bajt + bne t7 + lda bajt + eor #$ff + sta bajt +t7 tya + rts + +a2 adc frq,x +a1 sta frq,x + rts +a3 ldy wysdzw,x + adc frqtab,y + sta frq,x + tya + sta aktwys,x + rts +a4 and $d20a + sta frq,x + rts +a7 adc wysdzw,x +a5 sta aktwys,x + tay + lda frqtab,y + sta frq,x + rts +a6 sta aktwys,x + tay + lda frq,x + adc frqtab,y + sta frq,x + rts + +nparam iny + inc pozwpt,x + lda (addr),y + lsr @ + lsr @ + lsr @ + lsr @ + sta adcvl1,x + lda (addr),y + and #15 + sta adcvl2,x + rts + +songx jsr stop + ldy #15 +zm4 lda #0 + sta adrsng +zm5 lda #0 + sta adrsng+1 +d5 txa + beq inic +d3 lda (adrsng),y + bpl d4 + dex +d4 clc + lda adrsng + adc #16 + sta adrsng + bcc d5 + inc adrsng+1 + bcs d5 + +playx jsr stop + lda #0 + sta addr + txa + asl @ + asl @ + rol addr + asl @ + rol addr + asl @ + rol addr +zm6 adc #0 + sta adrsng + lda addr +zm7 adc #0 + sta adrsng+1 +inic lda #64 + sta pozptr + lda #1 + sta ltempo + sta czygrc + rts + +init cmp #$10 + bcc songx + cmp #$20 + bcc playx + cmp #$30 + bcs *+5 + jmp d2 + cmp #$40 + bcs i1 + txa + and #15 + beq i1-1 + sta tempo + rts +i1 cmp #$50 + bcc stop + cmp #$60 + bcs i2 + lda #0 +i3 sta czygrc + rts +i2 cmp #$70 + bcc i3 + + lda #1 + sta ltempo + lda #64 + sta pozptr + sty addr + stx addr+1 + ldy #30 + lda (addr),y + sta tempo + lda addr + clc + adc #32 + sta zm8+1 + bcc *+3 + inx + stx zm8+2 + clc + adc #$40 + sta zm9+1 + bcc *+3 + inx + stx zm9+2 + clc + adc #$40 + sta zm2+1 + bcc *+3 + inx + stx zm2+2 + clc + adc #$80 + sta zm3+1 + bcc *+3 + inx + stx zm3+2 + clc + adc #$80 + sta adrsng + sta zm0+1 + sta zm4+1 + sta zm6+1 + bcc *+3 + inx + stx adrsng+1 + stx zm1+1 + stx zm5+1 + stx zm7+1 + +stop ldy #7 + lda #0 + sta czygrc +d9 sta $d200,y + sta $d210,y + sta volume,y + sta vol1ch,y + sta vol2ch,y + sta audctl,y + sta czygrx,y + dey + bpl d9 + sta $d208 + sta $d218 + sta aud1 + sta aud2 + rts + +d1 sta vol1ch,x + sta vol2ch,x + sta audctl,x + lda wysdzw,x + sta aktwys,x + rts +d0 tya + eor #$f0 + lsr @ + lsr @ + lsr @ + lsr @ + sta adcvl1,x + tya + and #15 + eor #15 + sta adcvl2,x + rts +d2 and #7 + sta addr + txa + ldx addr + and #$3f + beq d0 + sta wysdzw,x +dzwiek lda #0 + sta czygrx,x +zm8 lda $ffff,y + sta adrsnl,x + sta addr +zm9 lda $ffff,y + sta adrsnh,x + sta addr+1 + ora addr + beq d1 + ldy #74 + lda (addr),y + sta opad1,x + sta lopad1,x + iny + lda (addr),y + sta opad2,x + sta lopad2,x + iny + lda (addr),y + and #$70 + lsr @ + lsr @ + sta typ,x + lda (addr),y + and #15 + sta param,x + lda (addr),y + bpl d7 + lda param,x + eor #$ff + clc + adc #1 + sta param,x +d7 iny + lda (addr),y + sta czekaj,x + iny + lda (addr),y + and #$3f + sta dtyp,x + sta ltyp,x + iny + lda (addr),y + and #$80 + beq d8 + lda #1 +d8 sta kolejn,x + lda (addr),y + and #$70 + lsr @ + lsr @ + lsr @ + lsr @ + sta ilperm,x + bne d6 + sta kolejn,x +d6 lda (addr),y + and #15 + sta dperm,x + sta lperm,x + dey + lda (addr),y + and #$c0 + clc + adc wysdzw,x + sta wysdzw,x + sta aktwys,x + tay + lda frqtab,y + sta frq,x + lda #0 + sta slupy,x + sta pomoc1,x + sta pomoc2,x + sta aperm,x + lda #1 + sta czygrx,x + rts + +endplr end Index: apps/plugins/asap/players/tmc.obx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: apps\plugins\asap\players\tmc.obx ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: apps/plugins/asap/raw2c.pl =================================================================== --- apps/plugins/asap/raw2c.pl (revision 0) +++ apps/plugins/asap/raw2c.pl (revision 0) @@ -0,0 +1,16 @@ +#!/usr/bin/perl -w +# Turns binary files into C source code (static const unsigned char arrays). +use strict; +for (@ARGV) { + open INPUT, $_ and binmode INPUT or die "$_: $!\n"; + s!.*[/\\]!!; + y/0-9A-Za-z/_/c; + print "static const unsigned char ${_}[] = {\n\t"; + my $buf; + print join ', ', map sprintf('0x%02X', $_), unpack 'C*', $buf + if read INPUT, $buf, 16; + print ",\n\t", join ', ', map sprintf('0x%02X', $_), unpack 'C*', $buf + while read INPUT, $buf, 16; + close INPUT; + print "\n};\n" +} Index: apps/plugins/asap/SOURCES =================================================================== --- apps/plugins/asap/SOURCES (revision 0) +++ apps/plugins/asap/SOURCES (revision 0) @@ -0,0 +1,4 @@ +acpu.c +apokeysnd.c +asap.c +asap2wav.c \ No newline at end of file Index: apps/plugins/CATEGORIES =================================================================== --- apps/plugins/CATEGORIES (revision 18007) +++ apps/plugins/CATEGORIES (working copy) @@ -103,3 +103,4 @@ wormlet,games xobox,games zxbox,viewers +asap,viewers \ No newline at end of file Index: apps/plugins/SUBDIRS =================================================================== --- apps/plugins/SUBDIRS (revision 18007) +++ apps/plugins/SUBDIRS (working copy) @@ -2,7 +2,6 @@ /* For all targets */ shortcuts - /* For various targets... */ #if CONFIG_RTC @@ -41,6 +40,7 @@ midi /* beatbox */ mpegplayer +asap #endif #endif /* IRIVER_IFP7XX_SERIES */ Index: apps/plugins/viewers.config =================================================================== --- apps/plugins/viewers.config (revision 18007) +++ apps/plugins/viewers.config (working copy) @@ -43,3 +43,4 @@ link,viewers/shortcuts_view,- *,viewers/shortcuts_append,- *,apps/md5sum,- +sap,viewers/asap,13 \ No newline at end of file