rzx.c

/* rzx.c: .rzx files
   Copyright (c) 2002-2016 Philip Kendall
   Copyright (c) 2014 Sergio Baldoví
   Copyright (c) 2015 Stuart Brady

   This program 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.

   This program 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 this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

   Author contact information:

   E-mail: philip-fuse@shadowmagic.org.uk

*/

#include <config.h>

#include <math.h>
#include <stdlib.h>
#include <string.h>

#include "debugger/debugger.h"
#include "event.h"
#include "fuse.h"
#include "infrastructure/startup_manager.h"
#include "machine.h"
#include "movie.h"
#include "peripherals/ula.h"
#include "rzx.h"
#include "settings.h"
#include "snapshot.h"
#include "timer/timer.h"
#include "ui/ui.h"
#include "utils.h"
#include "z80/z80.h"
#include "z80/z80_macros.h"

#define RZX_SENTINEL_TIME (ULA_CONTENTION_SIZE - 1000)
#define RZX_SENTINEL_TIME_REDUCE 8000

/* The offset used to get the count of instructions from the R register;
   (instruction count) = R + rzx_instructions_offset */
int rzx_instructions_offset;

// The number of bytes read via IN during the current frame
size_t rzx_in_count;

// The number of frames we've recorded in this RZX file
static size_t autosave_frame_count;

// And the values of those bytes
libspectrum_byte *rzx_in_bytes;

// How big is the above array?
size_t rzx_in_allocated;

// Are we currently recording a .rzx file?
int rzx_recording;

// Is the .rzx file being recorded in competition mode?
int rzx_competition_mode;

// The filename we'll save this recording into
static char *rzx_filename;

// Are we currently playing back a .rzx file?
int rzx_playback;

int sentinel_warning;

// The number of instructions in the current .rzx playback frame
size_t rzx_instruction_count;

// The current RZX data
libspectrum_rzx *rzx;

// Fuse's DSA key
libspectrum_rzx_dsa_key rzx_key = {
    "A9E3BD74E136A9ABD41E614383BB1B01EB24B2CD7B920ED6A62F786A879AC8B00F2FF318BF96F81654214B1A064889FF6D8078858ED00CF61"
    "D2047B2AAB7888949F35D166A2BBAAE23A331BD4728A736E76901D74B195B68C4A2BBFB9F005E3655BDE8256C279A626E00C7087A2D575F78"
    "D7DC5CA6E392A535FFE47A816BA503", // p

    "FE8D540EED2CAE1983690E2886259F8956FB5A19", // q
    "9680ABFFB98EF2021945ADDF86C21D6EE3F7C8777FB0A0220AB59E9DFA3A3338611B32CFD1F22F8F26547858754ED93BFBDD87DC13C09F42B"
    "42A36B2024467D98EB754DEB2847FCA7FC60C81A99CF95133847EA38AD9D037AFE9DD189E9F0EE47624848CEE840D7E3724A39681E71B97EC"
    "F777383DC52A48C0A2C93BADA93F4C", // g

    "46605F0514D56BC0B4207A350367A5038DBDD4DD62B7C997D26D0ADC5BE42D01F852C199E34553BCBCE5955FF80E3B402B55316606D7E39C0"
    "F500AE5EE41A7B7A4DCE78EC19072C21FCC7BA48DFDC830C17B72BCAA2B2D70D9DFC0AAD9B7E73F7AEB6241E54D55C33E41AB749CAAFBE7AB"
    "00F2D74C500E5F5DD63BD299C65778", // y

    "948744AA7A1D1BE9EE65150B0A95A678B4181F0E" // x
};

/* By how much is the speed allowed to deviate from 100% whilst recording
   a competition mode RZX file */
static const float SPEED_TOLERANCE = 5;

// How often will we create an autosave file
static const size_t AUTOSAVE_INTERVAL = 5 * 50;

// Debugger events
static const char * const event_type_string = "rzx";
static const char * const end_event_detail_string = "end";

int end_event;

static int start_playback(libspectrum_rzx *from_rzx);
static void start_recording(libspectrum_rzx *to_rzx, int competition_mode);
static int recording_frame(void);
static int playback_frame(void);
static int counter_reset(void);
static void rzx_sentinel(libspectrum_dword ts, int type, void *user_data);

static int sentinel_event;

typedef struct prune_info_t {
    libspectrum_rzx_iterator it;
    size_t frames;
} prune_info_t;


static int rzx_init(void *context)
{
    rzx_recording = rzx_playback = 0;

    rzx_in_bytes = NULL;
    rzx_in_allocated = 0;

    sentinel_warning = 0;
    sentinel_event = event_register(rzx_sentinel, "RZX sentinel");

    end_event = debugger_event_register(event_type_string, end_event_detail_string);

    return 0;
}


static int rzx_add_snap(libspectrum_rzx *to_rzx, int automatic)
{
    int error;
    libspectrum_snap *snap = libspectrum_snap_alloc();

    error = snapshot_copy_to(snap);
    if (error) {
        libspectrum_snap_free(snap);
        return error;
    }

    error = libspectrum_rzx_add_snap(to_rzx, snap, automatic);
    if (error) {
        libspectrum_snap_free(snap);
        return error;
    }
    return 0;
}


int rzx_start_recording(const char *filename, int embed_snapshot)
{
    int error;

    if (rzx_playback) {
        return 1;
    }

    rzx = libspectrum_rzx_alloc();

    // Store the filename
    rzx_filename = utils_safe_strdup(filename);

    // If we're embedding a snapshot, create it now
    if (embed_snapshot) {
        error = rzx_add_snap(rzx, 0);

        if (error) {
            libspectrum_free(rzx_filename);
            libspectrum_rzx_free(rzx);
            return error;
        }
    }

    start_recording(rzx, settings_current.competition_mode);

    return 0;
}


int rzx_stop_recording(void)
{
    libspectrum_byte *buffer; size_t length;
    libspectrum_error libspec_error;
    int error;

    if (!rzx_recording) {
        return 0;
    }

    // Stop recording data
    rzx_recording = 0;
    if (settings_current.movie_stop_after_rzx) {
        movie_stop();
    }

    // Embed final snapshot
    if (!rzx_competition_mode) {
        rzx_add_snap(rzx, 0);
    }

    libspectrum_free(rzx_in_bytes);
    rzx_in_bytes = NULL;
    rzx_in_allocated = 0;

    ui_menu_activate(UI_MENU_ITEM_RECORDING, 0);
    ui_menu_activate(UI_MENU_ITEM_RECORDING_ROLLBACK, 0);

    libspectrum_creator_set_competition_code(fuse_creator, settings_current.competition_code);

    length = 0;
    buffer = NULL;
    libspec_error = libspectrum_rzx_write(&buffer,
                                          &length,
                                          rzx,
                                          LIBSPECTRUM_ID_SNAPSHOT_SZX,
                                          fuse_creator,
                                          settings_current.rzx_compression,
                                          rzx_competition_mode ? &rzx_key : NULL);
    if (libspec_error != LIBSPECTRUM_ERROR_NONE) {
        libspectrum_free(rzx_filename);
        libspectrum_rzx_free(rzx);
        return libspec_error;
    }

    error = utils_write_file(rzx_filename, buffer, length);
    libspectrum_free(rzx_filename);
    if (error) {
        libspectrum_free(buffer);
        libspectrum_rzx_free(rzx);
        return error;
    }

    libspectrum_free(buffer);

    libspec_error = libspectrum_rzx_free(rzx);
    if (libspec_error != LIBSPECTRUM_ERROR_NONE) {
        return libspec_error;
    }
    return 0;
}


static libspectrum_snap* rzx_get_initial_snapshot(void)
{
    libspectrum_rzx_iterator it;

    for (it = libspectrum_rzx_iterator_begin(rzx); it; it = libspectrum_rzx_iterator_next(it)) {

        libspectrum_rzx_block_id id = libspectrum_rzx_iterator_get_type(it);

        switch (id) {

            case LIBSPECTRUM_RZX_INPUT_BLOCK:
                // If we get this then there can't have been an initial snap to start from
                return NULL;

            case LIBSPECTRUM_RZX_SNAPSHOT_BLOCK:
                // Got initial snap
                return libspectrum_rzx_iterator_get_snap(it);

            default:
                continue;
        }
    }
    return NULL;
}


int rzx_start_playback(const char *filename, int check_snapshot)
{
    utils_file file;
    libspectrum_error libspec_error;
    int error;
    libspectrum_snap* snap;

    if (rzx_recording) {
        return 1;
    }

    rzx = libspectrum_rzx_alloc();

    error = utils_read_file(filename, &file);
    if (error) {
        return error;
    }

    libspec_error = libspectrum_rzx_read(rzx, file.buffer, file.length);
    if (libspec_error != LIBSPECTRUM_ERROR_NONE) {
        utils_close_file(&file);
        return libspec_error;
    }

    utils_close_file(&file);

    snap = rzx_get_initial_snapshot();
    if (!snap && check_snapshot) {
        // We need to load an external snapshot. Could be skipped if the snapshot is preloaded from command line
        error = utils_open_snap();
        if (error) {
            return error;
        }
    }

    error = start_playback(rzx);
    if (error) {
        libspectrum_rzx_free(rzx);
        return error;
    }
    return 0;
}


int rzx_start_playback_from_buffer(const unsigned char *buffer, size_t length)
{
    int error;
    libspectrum_snap* snap;

    if (rzx_recording) {
        return 0;
    }

    rzx = libspectrum_rzx_alloc();

    error = libspectrum_rzx_read(rzx, buffer, length);
    if (error) {
        return error;
    }

    snap = rzx_get_initial_snapshot();
    if (!snap) {
        error = utils_open_snap();
        if (error) {
            libspectrum_rzx_free(rzx);
            return error;
        }
    }

    error = start_playback(rzx);
    if (error) {
        libspectrum_rzx_free(rzx);
        return error;
    }
    return 0;
}


static int start_playback(libspectrum_rzx *from_rzx)
{
    int error;
    libspectrum_snap *snap;

    error = libspectrum_rzx_start_playback(from_rzx, 0, &snap);
    if (error) {
        return error;
    }

    if (snap) {
        error = snapshot_copy_from(snap);
        if (error) {
            return error;
        }
    }

    // End of frame will now be generated by the RZX code
    event_remove_type(spectrum_frame_event);

    // Add a sentinel event to prevent tstates overrun (bug #25)
    event_add(RZX_SENTINEL_TIME, sentinel_event);

    sentinel_warning = 0;
    tstates = libspectrum_rzx_tstates(from_rzx);
    rzx_instruction_count = libspectrum_rzx_instructions(from_rzx);
    rzx_playback = 1;
    counter_reset();

    ui_menu_activate(UI_MENU_ITEM_RECORDING, 1);
    ui_menu_activate(UI_MENU_ITEM_RECORDING_ROLLBACK, 0);

    return 0;
}


int rzx_stop_playback(int add_interrupt)
{
    libspectrum_error libspec_error;

    if (!rzx_playback) {
        return 0;
    }

    rzx_playback = 0;
    if (settings_current.movie_stop_after_rzx) movie_stop();

    ui_menu_activate(UI_MENU_ITEM_RECORDING, 0);
    ui_menu_activate(UI_MENU_ITEM_RECORDING_ROLLBACK, 0);

    event_remove_type(sentinel_event);

    /* We've now finished with the RZX file, so add an end of frame event if we've been requested to do so;
       we don't if we just run out of frames, as this occurs just before a normal end of frame
       and everything works normally as rzx_playback is now zero again */
    if (add_interrupt) {
        event_add(machine_current->timings.tstates_per_frame, spectrum_frame_event);

        // We're no longer doing RZX playback, so tstates now be <= the normal frame count
        if (tstates > machine_current->timings.tstates_per_frame) {
            tstates = machine_current->timings.tstates_per_frame;
        }
    } else {
        // Ensure that tstates will be zero after it is reduced in spectrum_frame()
        tstates = machine_current->timings.tstates_per_frame;
    }
    libspec_error = libspectrum_rzx_free(rzx);
    if (libspec_error != LIBSPECTRUM_ERROR_NONE) {
        return libspec_error;
    }
    debugger_event(end_event);
    return 0;
}


static void start_recording(libspectrum_rzx *to_rzx, int competition_mode)
{
    libspectrum_rzx_start_input(to_rzx, tstates);

    counter_reset();
    rzx_in_count = 0;
    autosave_frame_count = 0;

    rzx_recording = 1;

    ui_menu_activate(UI_MENU_ITEM_RECORDING, 1);

    if (competition_mode) {

        if (!libspectrum_gcrypt_version())
            ui_error(UI_ERROR_WARNING, "gcrypt not available: recording will NOT be signed");

            settings_current.emulation_speed = 100;
            rzx_competition_mode = 1;

    } else {

        ui_menu_activate(UI_MENU_ITEM_RECORDING_ROLLBACK, 1);
        rzx_competition_mode = 0;

    }
}


int rzx_continue_recording(const char *filename)
{
    utils_file file;
    libspectrum_error libspec_error;
    int error;
    libspectrum_snap* snap = NULL;
    libspectrum_rzx_iterator last_it = NULL;

    if (rzx_recording || rzx_playback) {
        return 1;
    }

    // Store the filename
    rzx_filename = utils_safe_strdup(filename);

    error = utils_read_file(filename, &file);
    if (error) {
        return error;
    }

    rzx = libspectrum_rzx_alloc();

    libspec_error = libspectrum_rzx_read(rzx, file.buffer, file.length);
    if (libspec_error != LIBSPECTRUM_ERROR_NONE) {
        utils_close_file(&file);
        return libspec_error;
    }

    utils_close_file(&file);

    // Get final snapshot
    last_it = libspectrum_rzx_iterator_last(rzx);
    if (last_it) {
        snap = libspectrum_rzx_iterator_get_snap(last_it);
    }

    if (snap) {
        error = snapshot_copy_from(snap);
        if (error) {
            return error;
        }
    } else {
        libspectrum_free(rzx_filename);
        libspectrum_rzx_free(rzx);
        return 1;
    }
    start_recording(rzx, 0);
    return 0;
}


int rzx_finalise_recording(const char *filename)
{
    libspectrum_byte *buffer; size_t length;
    libspectrum_error libspec_error;
    int error;
    utils_file file;

    if (rzx_recording || rzx_playback) {
        return 1;
    }

    error = utils_read_file(filename, &file);
    if (error) {
        return error;
    }

    rzx = libspectrum_rzx_alloc();

    libspec_error = libspectrum_rzx_read(rzx, file.buffer, file.length);
    if (libspec_error != LIBSPECTRUM_ERROR_NONE) {
        utils_close_file(&file);
        libspectrum_rzx_free(rzx);
        return libspec_error;
    }

    utils_close_file(&file);

    libspec_error = libspectrum_rzx_finalise(rzx);
    if (libspec_error != LIBSPECTRUM_ERROR_NONE) {
        libspectrum_rzx_free(rzx);
        return libspec_error;
    }

    // Write the file
    length = 0;
    buffer = NULL;
    libspec_error = libspectrum_rzx_write(&buffer,
                                          &length,
                                          rzx,
                                          LIBSPECTRUM_ID_SNAPSHOT_SZX,
                                          fuse_creator,
                                          settings_current.rzx_compression,
                                          rzx_competition_mode ? &rzx_key : NULL);
    if (libspec_error != LIBSPECTRUM_ERROR_NONE) {
        libspectrum_rzx_free(rzx);
        return libspec_error;
    }

    error = utils_write_file(filename, buffer, length);
    if (error) {
        libspectrum_free(buffer);
        libspectrum_rzx_free(rzx);
        return error;
    }

    libspectrum_free(buffer);
    libspectrum_rzx_free(rzx);

    return 0;
}


int rzx_frame(void)
{
    if (rzx_recording) {
        return recording_frame();
    }
    if (rzx_playback) {
        return playback_frame();
    }
    return 0;
}


static void autosave_prune(void)
{
    GArray *autosaves = g_array_new(FALSE, FALSE, sizeof(prune_info_t));
    libspectrum_rzx_iterator it;
    size_t i, frames = 0;

    for (it = libspectrum_rzx_iterator_begin(rzx); it; it = libspectrum_rzx_iterator_next(it)) {

        libspectrum_rzx_block_id id = libspectrum_rzx_iterator_get_type(it);

        switch (id) {

            case LIBSPECTRUM_RZX_INPUT_BLOCK:
                frames += libspectrum_rzx_iterator_get_frames(it);
                break;

            case LIBSPECTRUM_RZX_SNAPSHOT_BLOCK:
                if (libspectrum_rzx_iterator_snap_is_automatic(it)) {
                    prune_info_t info = {it, frames};
                    g_array_append_val(autosaves, info);
                }
                break;

            default:
                break;
        }
    }

    // Convert 'time from start' into 'time before now'
    for (i = 0; i < autosaves->len; i++) {
        prune_info_t *info = &(g_array_index(autosaves, prune_info_t, i));
        info->frames = frames - info->frames;
    }

    for (i = autosaves->len - 1; i > 0; i--) {
        prune_info_t save1 = g_array_index(autosaves, prune_info_t, i),
        save2 = g_array_index(autosaves, prune_info_t, i - 1);

        if (((save1.frames == (15 * 50)) || (save1.frames == (60 * 50)) ||
             (save1.frames == (300 * 50))) && (save2.frames < (2 * save1.frames)))
            // FIXME: could possibly merge adjacent IRBs here
            libspectrum_rzx_iterator_delete(rzx, save1.it);
    }

    g_array_free(autosaves, TRUE);
}


static void autosave_frame(void)
{
    if (++autosave_frame_count % AUTOSAVE_INTERVAL) {
        return;
    }

    rzx_add_snap(rzx, 1);

    libspectrum_rzx_start_input(rzx, tstates);

    autosave_prune();
}


static void autosave_reset(void)
{
    libspectrum_rzx_iterator it;
    size_t frames = 0;

    for (it = libspectrum_rzx_iterator_begin(rzx); it; it = libspectrum_rzx_iterator_next(it)) {

        libspectrum_rzx_block_id id = libspectrum_rzx_iterator_get_type(it);

        switch (id) {

            case LIBSPECTRUM_RZX_INPUT_BLOCK:
                frames += libspectrum_rzx_iterator_get_frames(it);
                break;

            case LIBSPECTRUM_RZX_SNAPSHOT_BLOCK:
                if (libspectrum_rzx_iterator_snap_is_automatic(it)) {
                    frames = 0;
                }
                break;

            default:
                break;
        }
    }
    // Reset the frame count. Allow to prune previous points after rolling back
    autosave_frame_count = frames % AUTOSAVE_INTERVAL;
}


static int recording_frame(void)
{
    libspectrum_error error;

    error = libspectrum_rzx_store_frame(rzx, (R + rzx_instructions_offset), rzx_in_count, rzx_in_bytes);
    if (error) {
        rzx_stop_recording();
        return error;
    }

    // Reset the instruction counter
    rzx_in_count = 0;
    counter_reset();

    // If we're in competition mode, check we're running at close to 100% speed
    if (rzx_competition_mode && (fabs(current_speed - 100.0) > SPEED_TOLERANCE)) {

        rzx_stop_recording();

        ui_error(UI_ERROR_INFO, "emulator speed is %d%%: stopping competition mode RZX recording", (int)(current_speed));
    }

    if (!rzx_competition_mode && settings_current.rzx_autosaves) {
        autosave_frame();
    }
    return 0;
}


static int playback_frame(void)
{
    int error, finished;
    libspectrum_snap *snap;

    error = libspectrum_rzx_playback_frame(rzx, &finished, &snap);
    if (error) {
        return rzx_stop_playback(0);
    }

    if (finished) {
        ui_error(UI_ERROR_INFO, "Finished RZX playback");
        return rzx_stop_playback(0);
    }

    // Move the RZX sentinel back out to 79000 tstates;
    // the addition of the frame length is because everything is reduced by that in event_frame()
    event_remove_type(sentinel_event);
    event_add(RZX_SENTINEL_TIME + tstates, sentinel_event);

    if (snap) {
        error = snapshot_copy_from(snap);
        if (error) {
            return rzx_stop_playback(0);
        }
    }

    // If we've got another frame to do, fetch the new instruction count and continue
    rzx_instruction_count = libspectrum_rzx_instructions(rzx);
    counter_reset();

    return 0;
}


// Reset the RZX counter; also, take this opportunity to normalise the R register
static int counter_reset(void)
{
    R &= 0x7f; // Clear all but the 7 lowest bits of the R register
    rzx_instructions_offset = -R; // Gives us a zero count

    return 0;
}


int rzx_store_byte(libspectrum_byte value)
{
    // Get more space if we need it; allocate twice as much as we currently have, with a minimum of 50
    if (rzx_in_count == rzx_in_allocated) {

        libspectrum_byte *ptr;
        size_t new_allocated;

        new_allocated = (rzx_in_allocated >= 25) ? (2 * rzx_in_allocated) : 50;
        ptr = libspectrum_renew(libspectrum_byte, rzx_in_bytes, new_allocated);

        rzx_in_bytes = ptr;
        rzx_in_allocated = new_allocated;
    }

    rzx_in_bytes[rzx_in_count++] = value;

    return 0;
}


static void rzx_end(void)
{
    if (rzx_recording) {
        rzx_stop_recording();
    }
    if (rzx_playback) {
        rzx_stop_playback(0);
    }
}


void rzx_register_startup(void)
{
    startup_manager_module dependencies[] = {
        STARTUP_MANAGER_MODULE_DEBUGGER,
        STARTUP_MANAGER_MODULE_EVENT,
        STARTUP_MANAGER_MODULE_MACHINE,
        STARTUP_MANAGER_MODULE_SETUID
    };
    startup_manager_register(STARTUP_MANAGER_MODULE_RZX,
                             dependencies,
                             ARRAY_SIZE(dependencies),
                             rzx_init,
                             NULL,
                             rzx_end);
}


static GSList* get_rollback_list(libspectrum_rzx *from_rzx)
{
    libspectrum_rzx_iterator it;
    GSList *rollback_points;
    size_t frames;

    it = libspectrum_rzx_iterator_begin(from_rzx);
    rollback_points = NULL;
    frames = 0;

    while (it) {
        libspectrum_rzx_block_id id = libspectrum_rzx_iterator_get_type(it);

        switch (id) {

            case LIBSPECTRUM_RZX_INPUT_BLOCK:
                frames += libspectrum_rzx_iterator_get_frames(it);
                break;

            case LIBSPECTRUM_RZX_SNAPSHOT_BLOCK:
                rollback_points = g_slist_append(rollback_points, GINT_TO_POINTER(frames));
                break;

            default:
                break;
        }

        it = libspectrum_rzx_iterator_next(it);
    }

    // Add the final IRB in, if any
    if (frames) {
        rollback_points = g_slist_append(rollback_points, GINT_TO_POINTER(frames));
    }
    return rollback_points;
}


static int start_after_rollback(libspectrum_snap *snap)
{
    int error;

    error = snapshot_copy_from(snap);
    if (error) {
        return error;
    }

    libspectrum_rzx_start_input(rzx, tstates);

    error = counter_reset();
    if (error) {
        return error;
    }

    if (settings_current.rzx_autosaves) {
        autosave_reset();
    }

    return 0;
}


int rzx_rollback(void)
{
    libspectrum_snap *snap;
    int error;

    error = libspectrum_rzx_rollback(rzx, &snap);
    if (error) {
        return error;
    }

    error = start_after_rollback(snap);
    if (error) {
        return error;
    }

    return 0;
}


int rzx_rollback_to(void)
{
    GSList *rollback_points;
    libspectrum_snap *snap;
    int which, error;

    rollback_points = get_rollback_list(rzx);

    which = ui_get_rollback_point(rollback_points);

    if (which == -1) {
        return 1;
    }

    error = libspectrum_rzx_rollback_to(rzx, &snap, which);
    if (error) {
        return error;
    }

    error = start_after_rollback(snap);
    if (error) {
        return error;
    }

    return 0;
}


static void rzx_sentinel(libspectrum_dword ts GCC_UNUSED, int type GCC_UNUSED, void *user_data GCC_UNUSED)
{
    if (!sentinel_warning) {
        // This message could pop up very often. Limited to once per playback
        ui_error(UI_ERROR_WARNING, "RZX frame is longer than %u tstates", RZX_SENTINEL_TIME);
        sentinel_warning = 1;
    }

    tstates -= RZX_SENTINEL_TIME_REDUCE;
    z80.interrupts_enabled_at -= RZX_SENTINEL_TIME_REDUCE;

    // Add another sentinel event in case this frame continues a lot more after this
    event_add(RZX_SENTINEL_TIME, sentinel_event);
}