src/mess/formats/rk_cas.c
| r2027 | r2028 | |
| 12 | 12 | #define WAVE_LOW -32768
|
| 13 | 13 | |
| 14 | 14 | #define RK_HEADER_LEN 256
|
| 15 | | #define RKU_SIZE 20
|
| 16 | | #define RK8_SIZE 60
|
| 17 | 15 | |
| 16 | #define RK_SIZE_20 20
|
| 17 | #define RK_SIZE_60 60
|
| 18 | |
| 18 | 19 | static int data_size;
|
| 19 | 20 | |
| 20 | 21 | static INT16 *rk_emit_level(INT16 *p, int count, int level)
|
| r2027 | r2028 | |
| 54 | 55 | }
|
| 55 | 56 | |
| 56 | 57 | |
| 57 | | static int rku_cas_to_wav_size( const UINT8 *casdata, int caslen ) {
|
| 58 | static int rk20_cas_to_wav_size( const UINT8 *casdata, int caslen ) {
|
| 58 | 59 | data_size = caslen;
|
| 59 | | return (RK_HEADER_LEN * 8 * 2 + 8*2 + caslen * 8 * 2) * RKU_SIZE;
|
| 60 | return (RK_HEADER_LEN * 8 * 2 + 8*2 + caslen * 8 * 2) * RK_SIZE_20;
|
| 60 | 61 | }
|
| 61 | 62 | |
| 62 | | static int rk8_cas_to_wav_size( const UINT8 *casdata, int caslen ) {
|
| 63 | static int rk60_cas_to_wav_size( const UINT8 *casdata, int caslen ) {
|
| 63 | 64 | data_size = caslen;
|
| 64 | | return (RK_HEADER_LEN * 8 * 2 + 8*2 + caslen * 8 * 2) * RK8_SIZE;
|
| 65 | return (RK_HEADER_LEN * 8 * 2 + 8*2 + caslen * 8 * 2) * RK_SIZE_60;
|
| 65 | 66 | }
|
| 66 | 67 | |
| 67 | | static int rku_cas_fill_wave( INT16 *buffer, int length, UINT8 *bytes ) {
|
| 68 | static int rk20_cas_fill_wave( INT16 *buffer, int length, UINT8 *bytes ) {
|
| 68 | 69 | int i;
|
| 69 | 70 | INT16 * p = buffer;
|
| 70 | 71 |
|
| 71 | 72 | for (i=0; i<RK_HEADER_LEN; i++) {
|
| 72 | | p = rk_output_byte (p, 0x00, RKU_SIZE );
|
| 73 | p = rk_output_byte (p, 0x00, RK_SIZE_20 );
|
| 73 | 74 | }
|
| 74 | 75 | |
| 75 | | p = rk_output_byte (p, 0xE6, RKU_SIZE);
|
| 76 | p = rk_output_byte (p, 0xE6, RK_SIZE_20);
|
| 76 | 77 |
|
| 77 | 78 | for (i=0; i<data_size; i++)
|
| 78 | | p = rk_output_byte (p, bytes[i], RKU_SIZE);
|
| 79 | p = rk_output_byte (p, bytes[i], RK_SIZE_20);
|
| 79 | 80 | |
| 80 | 81 | return p - buffer;
|
| 81 | 82 | }
|
| 82 | 83 | |
| 83 | | static int rk8_cas_fill_wave( INT16 *buffer, int length, UINT8 *bytes ) {
|
| 84 | static int rk60_cas_fill_wave( INT16 *buffer, int length, UINT8 *bytes ) {
|
| 84 | 85 | int i;
|
| 85 | 86 | INT16 * p = buffer;
|
| 86 | 87 |
|
| 87 | 88 | for (i=0; i<RK_HEADER_LEN; i++) {
|
| 88 | | p = rk_output_byte (p, 0x00, RK8_SIZE );
|
| 89 | p = rk_output_byte (p, 0x00, RK_SIZE_60 );
|
| 89 | 90 | }
|
| 90 | 91 | |
| 91 | | p = rk_output_byte (p, 0xE6, RK8_SIZE);
|
| 92 | p = rk_output_byte (p, 0xE6, RK_SIZE_60);
|
| 92 | 93 |
|
| 93 | 94 | for (i=0; i<data_size; i++)
|
| 94 | | p = rk_output_byte (p, bytes[i], RK8_SIZE);
|
| 95 | p = rk_output_byte (p, bytes[i], RK_SIZE_60);
|
| 95 | 96 | |
| 96 | 97 | return p - buffer;
|
| 97 | 98 | }
|
| 98 | 99 | |
| 99 | 100 | |
| 100 | 101 | |
| 101 | | static const struct CassetteLegacyWaveFiller rku_legacy_fill_wave = {
|
| 102 | | rku_cas_fill_wave, /* fill_wave */
|
| 102 | static const struct CassetteLegacyWaveFiller rk20_legacy_fill_wave = {
|
| 103 | rk20_cas_fill_wave, /* fill_wave */
|
| 103 | 104 | -1, /* chunk_size */
|
| 104 | 105 | 0, /* chunk_samples */
|
| 105 | | rku_cas_to_wav_size, /* chunk_sample_calc */
|
| 106 | rk20_cas_to_wav_size, /* chunk_sample_calc */
|
| 106 | 107 | RK_WAV_FREQUENCY, /* sample_frequency */
|
| 107 | 108 | 0, /* header_samples */
|
| 108 | 109 | 0 /* trailer_samples */
|
| r2027 | r2028 | |
| 110 | 111 | |
| 111 | 112 | |
| 112 | 113 | |
| 113 | | static casserr_t rku_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) {
|
| 114 | | return cassette_legacy_identify( cassette, opts, &rku_legacy_fill_wave );
|
| 114 | static casserr_t rk20_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) {
|
| 115 | return cassette_legacy_identify( cassette, opts, &rk20_legacy_fill_wave );
|
| 115 | 116 | }
|
| 116 | 117 | |
| 117 | 118 | |
| 118 | 119 | |
| 119 | | static casserr_t rku_cassette_load( cassette_image *cassette ) {
|
| 120 | | return cassette_legacy_construct( cassette, &rku_legacy_fill_wave );
|
| 120 | static casserr_t rk20_cassette_load( cassette_image *cassette ) {
|
| 121 | return cassette_legacy_construct( cassette, &rk20_legacy_fill_wave );
|
| 121 | 122 | }
|
| 122 | 123 | |
| 123 | | static const struct CassetteLegacyWaveFiller rk8_legacy_fill_wave = {
|
| 124 | | rk8_cas_fill_wave, /* fill_wave */
|
| 124 | static const struct CassetteLegacyWaveFiller rk60_legacy_fill_wave = {
|
| 125 | rk60_cas_fill_wave, /* fill_wave */
|
| 125 | 126 | -1, /* chunk_size */
|
| 126 | 127 | 0, /* chunk_samples */
|
| 127 | | rk8_cas_to_wav_size, /* chunk_sample_calc */
|
| 128 | rk60_cas_to_wav_size, /* chunk_sample_calc */
|
| 128 | 129 | RK_WAV_FREQUENCY, /* sample_frequency */
|
| 129 | 130 | 0, /* header_samples */
|
| 130 | 131 | 0 /* trailer_samples */
|
| 131 | 132 | };
|
| 132 | 133 | |
| 133 | 134 | |
| 134 | | static casserr_t rk8_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) {
|
| 135 | | return cassette_legacy_identify( cassette, opts, &rk8_legacy_fill_wave );
|
| 135 | static casserr_t rk60_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) {
|
| 136 | return cassette_legacy_identify( cassette, opts, &rk60_legacy_fill_wave );
|
| 136 | 137 | }
|
| 137 | 138 | |
| 138 | 139 | |
| 139 | 140 | |
| 140 | | static casserr_t rk8_cassette_load( cassette_image *cassette ) {
|
| 141 | | return cassette_legacy_construct( cassette, &rk8_legacy_fill_wave );
|
| 141 | static casserr_t rk60_cassette_load( cassette_image *cassette ) {
|
| 142 | return cassette_legacy_construct( cassette, &rk60_legacy_fill_wave );
|
| 142 | 143 | }
|
| 143 | 144 | |
| 144 | 145 | |
| 145 | | |
| 146 | 146 | static const struct CassetteFormat rku_cassette_format = {
|
| 147 | 147 | "rku",
|
| 148 | | rku_cassette_identify,
|
| 149 | | rku_cassette_load,
|
| 148 | rk20_cassette_identify,
|
| 149 | rk20_cassette_load,
|
| 150 | 150 | NULL
|
| 151 | 151 | };
|
| 152 | 152 | |
| 153 | 153 | static const struct CassetteFormat rk8_cassette_format = {
|
| 154 | 154 | "rk8",
|
| 155 | | rk8_cassette_identify,
|
| 156 | | rk8_cassette_load,
|
| 155 | rk60_cassette_identify,
|
| 156 | rk60_cassette_load,
|
| 157 | 157 | NULL
|
| 158 | 158 | };
|
| 159 | 159 | |
| 160 | static const struct CassetteFormat rks_cassette_format = {
|
| 161 | "rks",
|
| 162 | rk20_cassette_identify,
|
| 163 | rk20_cassette_load,
|
| 164 | NULL
|
| 165 | };
|
| 160 | 166 | |
| 167 | |
| 161 | 168 | CASSETTE_FORMATLIST_START(rku_cassette_formats)
|
| 162 | 169 | CASSETTE_FORMAT(rku_cassette_format)
|
| 163 | 170 | CASSETTE_FORMATLIST_END
|
| r2027 | r2028 | |
| 166 | 173 | CASSETTE_FORMAT(rk8_cassette_format)
|
| 167 | 174 | CASSETTE_FORMATLIST_END
|
| 168 | 175 | |
| 176 | CASSETTE_FORMATLIST_START(rks_cassette_formats)
|
| 177 | CASSETTE_FORMAT(rks_cassette_format)
|
| 178 | CASSETTE_FORMATLIST_END
|
src/mess/drivers/special.c
| r2027 | r2028 | |
| 2 | 2 | |
| 3 | 3 | Specialist driver by Miodrag Milanovic
|
| 4 | 4 | |
| 5 | 20/03/2008 Cassette support
|
| 5 | 6 | 15/03/2008 Preliminary driver.
|
| 6 | 7 |
|
| 7 | 8 | ****************************************************************************/
|
| r2027 | r2028 | |
| 11 | 12 | #include "cpu/i8085/i8085.h"
|
| 12 | 13 | #include "includes/special.h"
|
| 13 | 14 | #include "machine/8255ppi.h"
|
| 14 | | |
| 15 | #include "devices/cassette.h"
|
| 16 | #include "formats/rk_cas.h"
|
| 17 | |
| 15 | 18 | /* Address maps */
|
| 16 | 19 | static ADDRESS_MAP_START(specialist_mem, ADDRESS_SPACE_PROGRAM, 8)
|
| 17 | 20 | AM_RANGE( 0x0000, 0x8fff ) AM_RAM // RAM
|
| r2027 | r2028 | |
| 183 | 186 | ROMX_LOAD( "lik2.rom", 0xc000, 0x3000, CRC(71820E43) , ROM_BIOS(2))
|
| 184 | 187 | ROM_END
|
| 185 | 188 | |
| 189 | static void special_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info)
|
| 190 | {
|
| 191 | /* cassette */
|
| 192 | switch(state)
|
| 193 | {
|
| 194 | /* --- the following bits of info are returned as 64-bit signed integers --- */
|
| 195 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break;
|
| 196 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break;
|
| 197 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rks_cassette_formats; break;
|
| 198 | |
| 199 | default: cassette_device_getinfo(devclass, state, info); break;
|
| 200 | }
|
| 201 | }
|
| 202 | |
| 203 | SYSTEM_CONFIG_START(special)
|
| 204 | CONFIG_DEVICE(special_cassette_getinfo)
|
| 205 | SYSTEM_CONFIG_END
|
| 206 |
|
| 186 | 207 | /* Driver */
|
| 187 | 208 |
|
| 188 | 209 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */
|
| 189 | | COMP( 1985, special, 0, 0, special, special, special, NULL, "", "Special", 0)
|
| 190 | | COMP( 1985, lik, special, 0, special, special, special, NULL, "", "Lik", 0)
|
| 210 | COMP( 1985, special, 0, 0, special, special, special, special, "", "Special", 0)
|
| 211 | COMP( 1985, lik, special, 0, special, special, special, special, "", "Lik", 0)
|