void cassette_seek(device_t *device, double time, int origin)
{
dev_cassette_t *cassette = get_safe_token( device );
double length;
cassette_update(device);
length = cassette_get_length(device);
switch(origin) {
case SEEK_SET:
break;
case SEEK_END:
time += length;
break;
case SEEK_CUR:
time += cassette_get_position(device);
break;
}
/* clip position into legal bounds */
if (time < 0)
time = 0;
else
if (time > length)
time = length;
cassette->position = time;
}
void cassette_output(mess_image *cassette, double value)
{
struct mess_cassetteimg *tag;
tag = get_cassimg(cassette);
if (((tag->state & CASSETTE_MASK_UISTATE) == CASSETTE_RECORD) && (tag->value != value))
{
cassette_update(cassette);
value = MIN(value, 1.0);
value = MAX(value, -1.0);
tag->value = (INT32) (value * 0x7FFFFFFF);
}
}
void cassette_output(device_t *device, double value)
{
dev_cassette_t *cassette = get_safe_token( device );
if (((cassette->state & CASSETTE_MASK_UISTATE) == CASSETTE_RECORD) && (cassette->value != value))
{
cassette_update(device);
value = MIN(value, 1.0);
value = MAX(value, -1.0);
cassette->value = (INT32) (value * 0x7FFFFFFF);
}
}
double cassette_input(device_t *device)
{
dev_cassette_t *cassette = get_safe_token( device );
INT32 sample;
double double_value;
cassette_update(device);
sample = cassette->value;
double_value = sample / ((double) 0x7FFFFFFF);
LOG(("cassette_input(): time_index=%g value=%g\n", cassette->position, double_value));
return double_value;
}
void cassette_change_state(device_t *device, cassette_state state, cassette_state mask)
{
dev_cassette_t *cassette = get_safe_token( device );
cassette_state new_state;
new_state = cassette->state;
new_state = (cassette_state)(new_state & ~mask);
new_state = (cassette_state)(new_state | (state & mask));
if (new_state != cassette->state)
{
cassette_update(device);
cassette->state = new_state;
}
}
void cassette_change_state(mess_image *cassette, cassette_state state, cassette_state mask)
{
struct mess_cassetteimg *tag;
cassette_state new_state;
tag = get_cassimg(cassette);
new_state = tag->state;
new_state &= ~mask;
new_state |= (state & mask);
if (new_state != tag->state)
{
cassette_update(cassette);
tag->state = new_state;
}
}
static DEVICE_IMAGE_UNLOAD( cassette )
{
device_t *device = &image.device();
dev_cassette_t *cassette = get_safe_token( device );
/* if we are recording, write the value to the image */
if ((cassette->state & CASSETTE_MASK_UISTATE) == CASSETTE_RECORD)
cassette_update(device);
/* close out the cassette */
cassette_close(cassette->cassette);
cassette->cassette = NULL;
/* set to default state, but only change the UI state */
cassette_change_state(device, CASSETTE_STOPPED, CASSETTE_MASK_UISTATE);
}
static void device_unload_cassette(mess_image *image)
{
struct mess_cassetteimg *tag;
tag = get_cassimg(image);
/* if we are recording, write the value to the image */
if ((tag->state & CASSETTE_MASK_UISTATE) == CASSETTE_RECORD)
cassette_update(image);
/* close out the cassette */
cassette_close(tag->cassette);
tag->cassette = NULL;
/* set to default state, but only change the UI state */
cassette_change_state(image, CASSETTE_STOPPED, CASSETTE_MASK_UISTATE);
}
double cassette_input(mess_image *cassette)
{
INT32 sample;
double double_value;
struct mess_cassetteimg *tag;
cassette_update(cassette);
tag = get_cassimg(cassette);
sample = tag->value;
double_value = sample / ((double) 0x7FFFFFFF);
#if VERBOSE
logerror("cassette_input(): time_index=%g value=%g\n", tag->position, double_value);
#endif
return double_value;
}
void cassette_seek(mess_image *cassette, double time, int origin)
{
struct mess_cassetteimg *tag;
cassette_update(cassette);
switch(origin) {
case SEEK_SET:
break;
case SEEK_END:
time += cassette_get_length(cassette);
break;
case SEEK_CUR:
time += cassette_get_position(cassette);
break;
}
/* clip position into legal bounds */
tag = get_cassimg(cassette);
tag->position = time;
}
