src/mess/formats/rk_cas.c
| r0 | r1979 | |
| 1 | /*
|
| 2 |
|
| 3 | Tape support for RK format
|
| 4 | |
| 5 | */
|
| 6 | #include "driver.h"
|
| 7 | #include "formats/rk_cas.h"
|
| 8 | |
| 9 | |
| 10 | #define RK_WAV_FREQUENCY 44100
|
| 11 | #define WAVE_HIGH 32767
|
| 12 | #define WAVE_LOW -32768
|
| 13 | |
| 14 | #define RK_HEADER_LEN 256
|
| 15 | #define RKU_SIZE 20
|
| 16 | #define RK8_SIZE 60
|
| 17 | |
| 18 | static int data_size;
|
| 19 | |
| 20 | static INT16 *rk_emit_level(INT16 *p, int count, int level)
|
| 21 | {
|
| 22 | int i;
|
| 23 | |
| 24 | for (i=0; i<count; i++)
|
| 25 | {
|
| 26 | *(p++) = level;
|
| 27 | }
|
| 28 | return p;
|
| 29 | }
|
| 30 | |
| 31 | static INT16* rk_output_bit(INT16 *p, UINT8 b,int bitsize)
|
| 32 | {
|
| 33 | if (b)
|
| 34 | {
|
| 35 | p = rk_emit_level (p, bitsize, WAVE_HIGH);
|
| 36 | p = rk_emit_level (p, bitsize, WAVE_LOW); |
| 37 | }
|
| 38 | else
|
| 39 | {
|
| 40 | p = rk_emit_level (p, bitsize, WAVE_LOW);
|
| 41 | p = rk_emit_level (p, bitsize, WAVE_HIGH); |
| 42 |
|
| 43 | }
|
| 44 | return p;
|
| 45 | }
|
| 46 | |
| 47 | static INT16* rk_output_byte(INT16 *p, UINT8 byte,int bitsize)
|
| 48 | {
|
| 49 | int i;
|
| 50 | for (i=7; i>=0; i--)
|
| 51 | p = rk_output_bit(p,(byte>>i) & 0x01, bitsize);
|
| 52 | |
| 53 | return p;
|
| 54 | }
|
| 55 | |
| 56 | |
| 57 | static int rku_cas_to_wav_size( const UINT8 *casdata, int caslen ) {
|
| 58 | data_size = caslen;
|
| 59 | return (RK_HEADER_LEN * 8 * 2 + 8*2 + caslen * 8 * 2) * RKU_SIZE;
|
| 60 | }
|
| 61 | |
| 62 | static int rk8_cas_to_wav_size( const UINT8 *casdata, int caslen ) {
|
| 63 | data_size = caslen;
|
| 64 | return (RK_HEADER_LEN * 8 * 2 + 8*2 + caslen * 8 * 2) * RK8_SIZE;
|
| 65 | }
|
| 66 | |
| 67 | static int rku_cas_fill_wave( INT16 *buffer, int length, UINT8 *bytes ) {
|
| 68 | int i;
|
| 69 | INT16 * p = buffer;
|
| 70 |
|
| 71 | for (i=0; i<RK_HEADER_LEN; i++) {
|
| 72 | p = rk_output_byte (p, 0x00, RKU_SIZE );
|
| 73 | }
|
| 74 | |
| 75 | p = rk_output_byte (p, 0xE6, RKU_SIZE);
|
| 76 |
|
| 77 | for (i=0; i<data_size; i++)
|
| 78 | p = rk_output_byte (p, bytes[i], RKU_SIZE);
|
| 79 | |
| 80 | return p - buffer;
|
| 81 | }
|
| 82 | |
| 83 | static int rk8_cas_fill_wave( INT16 *buffer, int length, UINT8 *bytes ) {
|
| 84 | int i;
|
| 85 | INT16 * p = buffer;
|
| 86 |
|
| 87 | for (i=0; i<RK_HEADER_LEN; i++) {
|
| 88 | p = rk_output_byte (p, 0x00, RK8_SIZE );
|
| 89 | }
|
| 90 | |
| 91 | p = rk_output_byte (p, 0xE6, RK8_SIZE);
|
| 92 |
|
| 93 | for (i=0; i<data_size; i++)
|
| 94 | p = rk_output_byte (p, bytes[i], RK8_SIZE);
|
| 95 | |
| 96 | return p - buffer;
|
| 97 | }
|
| 98 | |
| 99 | |
| 100 | |
| 101 | static const struct CassetteLegacyWaveFiller rku_legacy_fill_wave = {
|
| 102 | rku_cas_fill_wave, /* fill_wave */
|
| 103 | -1, /* chunk_size */
|
| 104 | 0, /* chunk_samples */
|
| 105 | rku_cas_to_wav_size, /* chunk_sample_calc */
|
| 106 | RK_WAV_FREQUENCY, /* sample_frequency */
|
| 107 | 0, /* header_samples */
|
| 108 | 0 /* trailer_samples */
|
| 109 | };
|
| 110 | |
| 111 | |
| 112 | |
| 113 | static casserr_t rku_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) {
|
| 114 | return cassette_legacy_identify( cassette, opts, &rku_legacy_fill_wave );
|
| 115 | }
|
| 116 | |
| 117 | |
| 118 | |
| 119 | static casserr_t rku_cassette_load( cassette_image *cassette ) {
|
| 120 | return cassette_legacy_construct( cassette, &rku_legacy_fill_wave );
|
| 121 | }
|
| 122 | |
| 123 | static const struct CassetteLegacyWaveFiller rk8_legacy_fill_wave = {
|
| 124 | rk8_cas_fill_wave, /* fill_wave */
|
| 125 | -1, /* chunk_size */
|
| 126 | 0, /* chunk_samples */
|
| 127 | rk8_cas_to_wav_size, /* chunk_sample_calc */
|
| 128 | RK_WAV_FREQUENCY, /* sample_frequency */
|
| 129 | 0, /* header_samples */
|
| 130 | 0 /* trailer_samples */
|
| 131 | };
|
| 132 | |
| 133 | |
| 134 | static casserr_t rk8_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) {
|
| 135 | return cassette_legacy_identify( cassette, opts, &rk8_legacy_fill_wave );
|
| 136 | }
|
| 137 | |
| 138 | |
| 139 | |
| 140 | static casserr_t rk8_cassette_load( cassette_image *cassette ) {
|
| 141 | return cassette_legacy_construct( cassette, &rk8_legacy_fill_wave );
|
| 142 | }
|
| 143 | |
| 144 | |
| 145 | |
| 146 | static const struct CassetteFormat rku_cassette_format = {
|
| 147 | "rku",
|
| 148 | rku_cassette_identify,
|
| 149 | rku_cassette_load,
|
| 150 | NULL
|
| 151 | };
|
| 152 | |
| 153 | static const struct CassetteFormat rk8_cassette_format = {
|
| 154 | "rk8",
|
| 155 | rk8_cassette_identify,
|
| 156 | rk8_cassette_load,
|
| 157 | NULL
|
| 158 | };
|
| 159 | |
| 160 | |
| 161 | CASSETTE_FORMATLIST_START(rku_cassette_formats)
|
| 162 | CASSETTE_FORMAT(rku_cassette_format)
|
| 163 | CASSETTE_FORMATLIST_END
|
| 164 | |
| 165 | CASSETTE_FORMATLIST_START(rk8_cassette_formats)
|
| 166 | CASSETTE_FORMAT(rk8_cassette_format)
|
| 167 | CASSETTE_FORMATLIST_END
|
| 168 | |
src/mess/drivers/mikro80.c
| r1978 | r1979 | |
| 10 | 10 | #include "driver.h"
|
| 11 | 11 | #include "cpu/i8085/i8085.h"
|
| 12 | 12 | #include "includes/mikro80.h"
|
| 13 | #include "devices/cassette.h"
|
| 14 | #include "formats/rk_cas.h"
|
| 13 | 15 | |
| 14 | 16 | |
| 15 | 17 | GFXDECODE_START( mikro80 )
|
| r1978 | r1979 | |
| 23 | 25 | ADDRESS_MAP_END
|
| 24 | 26 | |
| 25 | 27 | static ADDRESS_MAP_START( mikro80_io , ADDRESS_SPACE_IO, 8)
|
| 28 | AM_RANGE( 0x01, 0x01) AM_READWRITE ( mikro80_tape_r, mikro80_tape_w )
|
| 26 | 29 | AM_RANGE( 0x04, 0x07) AM_READWRITE ( mikro80_keyboard_r, mikro80_keyboard_w )
|
| 27 | 30 | ADDRESS_MAP_END
|
| 28 | 31 | |
| r1978 | r1979 | |
| 134 | 137 | MDRV_GFXDECODE( mikro80 )
|
| 135 | 138 | |
| 136 | 139 | MDRV_VIDEO_START(mikro80)
|
| 137 | | MDRV_VIDEO_UPDATE(mikro80)
|
| 140 | MDRV_VIDEO_UPDATE(mikro80) |
| 141 | |
| 142 | MDRV_SPEAKER_STANDARD_MONO("mono")
|
| 143 | MDRV_SOUND_ADD(WAVE, 0)
|
| 144 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 145 | |
| 138 | 146 | MACHINE_DRIVER_END
|
| 139 | 147 |
|
| 148 | static void mikro80_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info)
|
| 149 | {
|
| 150 | /* cassette */
|
| 151 | switch(state)
|
| 152 | {
|
| 153 | /* --- the following bits of info are returned as 64-bit signed integers --- */
|
| 154 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break;
|
| 155 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break;
|
| 156 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rk8_cassette_formats; break;
|
| 157 | |
| 158 | default: cassette_device_getinfo(devclass, state, info); break;
|
| 159 | }
|
| 160 | }
|
| 161 | |
| 162 | SYSTEM_CONFIG_START(mikro80)
|
| 163 | CONFIG_DEVICE(mikro80_cassette_getinfo)
|
| 164 | SYSTEM_CONFIG_END
|
| 165 |
|
| 140 | 166 | /* ROM definition */
|
| 141 | 167 | |
| 142 | 168 | ROM_START( mikro80 )
|
| r1978 | r1979 | |
| 149 | 175 | /* Driver */
|
| 150 | 176 |
|
| 151 | 177 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */
|
| 152 | | COMP( 1983, mikro80, 0, 0, mikro80, mikro80, mikro80, NULL, "", "Mikro-80", 0)
|
| 178 | COMP( 1983, mikro80, 0, 0, mikro80, mikro80, mikro80, mikro80, "", "Mikro-80", 0)
|
src/mess/drivers/ut88.c
| r1978 | r1979 | |
| 12 | 12 | #include "cpu/i8085/i8085.h"
|
| 13 | 13 | #include "includes/ut88.h"
|
| 14 | 14 | #include "sound/dac.h"
|
| 15 | | |
| 15 | #include "devices/cassette.h"
|
| 16 | #include "formats/rk_cas.h"
|
| 16 | 17 | |
| 17 | 18 | GFXDECODE_START( ut88 )
|
| 18 | 19 | GFXDECODE_ENTRY( REGION_GFX1, 0x0000, ut88_charlayout, 0, 1 )
|
| r1978 | r1979 | |
| 26 | 27 | |
| 27 | 28 | static ADDRESS_MAP_START( ut88_io , ADDRESS_SPACE_IO, 8)
|
| 28 | 29 | AM_RANGE( 0x04, 0x07) AM_READWRITE ( ut88_keyboard_r, ut88_keyboard_w )
|
| 29 | | AM_RANGE( 0xA1, 0xA1) AM_WRITE (ut88_sound_w)
|
| 30 | AM_RANGE( 0xA1, 0xA1) AM_READWRITE ( ut88_tape_r, ut88_sound_w )
|
| 30 | 31 | ADDRESS_MAP_END
|
| 31 | 32 | |
| 32 | 33 | /* Input ports */
|
| r1978 | r1979 | |
| 130 | 131 | MDRV_SCREEN_REFRESH_RATE(50)
|
| 131 | 132 | MDRV_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
|
| 132 | 133 | MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
|
| 133 | | MDRV_SCREEN_SIZE(48*8, 16*8)
|
| 134 | | MDRV_SCREEN_VISIBLE_AREA(0, 48*8-1, 0, 16*8-1)
|
| 134 | MDRV_SCREEN_SIZE(48*8, 28*8)
|
| 135 | MDRV_SCREEN_VISIBLE_AREA(0, 48*8-1, 0, 28*8-1)
|
| 135 | 136 | MDRV_PALETTE_LENGTH(2)
|
| 136 | 137 | MDRV_PALETTE_INIT(black_and_white)
|
| 137 | 138 | MDRV_GFXDECODE( ut88 )
|
| r1978 | r1979 | |
| 143 | 144 | MDRV_SPEAKER_STANDARD_MONO("mono")
|
| 144 | 145 | MDRV_SOUND_ADD(DAC, 0)
|
| 145 | 146 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
|
| 146 | | |
| 147 | MDRV_SOUND_ADD(WAVE, 0)
|
| 148 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 147 | 149 | MACHINE_DRIVER_END
|
| 150 | |
| 151 | static void ut88_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info)
|
| 152 | {
|
| 153 | /* cassette */
|
| 154 | switch(state)
|
| 155 | {
|
| 156 | /* --- the following bits of info are returned as 64-bit signed integers --- */
|
| 157 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break;
|
| 158 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break;
|
| 159 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rku_cassette_formats; break;
|
| 160 | |
| 161 | default: cassette_device_getinfo(devclass, state, info); break;
|
| 162 | }
|
| 163 | }
|
| 164 | |
| 165 | SYSTEM_CONFIG_START(ut88)
|
| 166 | CONFIG_DEVICE(ut88_cassette_getinfo)
|
| 167 | SYSTEM_CONFIG_END
|
| 148 | 168 |
|
| 149 | 169 | /* ROM definition */
|
| 150 | 170 | ROM_START( ut88 )
|
| r1978 | r1979 | |
| 156 | 176 | |
| 157 | 177 | /* Driver */
|
| 158 | 178 |
|
| 159 | | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */
|
| 160 | | COMP( 1989, ut88, 0, 0, ut88, ut88, ut88, NULL, "", "UT-88", 0)
|
| 179 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */
|
| 180 | COMP( 1989, ut88, 0, 0, ut88, ut88, ut88, ut88, "", "UT-88", 0)
|