diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 94dc6a61a..aac413aae 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -23,8 +23,6 @@ endif()
 add_executable(86Box
     86box.c
     config.c
-    log.c
-    random.c
     timer.c
     io.c
     acpi.c
@@ -41,15 +39,11 @@ add_executable(86Box
     pci.c
     mca.c
     usb.c
-    fifo.c
-    fifo8.c
     device.c
     nvr.c
     nvr_at.c
     nvr_ps2.c
     machine_status.c
-    ini.c
-    cJSON.c
 )
 
 if(CMAKE_SYSTEM_NAME MATCHES "Linux")
@@ -106,7 +100,7 @@ if(INSTRUMENT)
 endif()
 
 target_link_libraries(86Box cpu chipset mch dev mem fdd game cdrom zip mo hdd
-    net print scsi sio snd vid voodoo plat ui)
+    net print scsi sio snd utils vid voodoo plat ui)
 
 if(HAIKU)
     target_link_libraries(86Box be)
@@ -256,7 +250,9 @@ add_subdirectory(printer)
 add_subdirectory(sio)
 add_subdirectory(scsi)
 add_subdirectory(sound)
+add_subdirectory(utils)
 add_subdirectory(video)
+
 if (APPLE)
     add_subdirectory(mac)
 endif()
diff --git a/src/cdrom/cdrom.c b/src/cdrom/cdrom.c
index c20e18db8..b30d93812 100644
--- a/src/cdrom/cdrom.c
+++ b/src/cdrom/cdrom.c
@@ -90,8 +90,10 @@ static char *               cdrom_modes[4]        = { "Mode 1", "Mode 2", "CD-I/
 static uint8_t              cdrom_mode_masks[14]  = { 0x0f, 0x00, 0x01, 0x02, 0x04, 0x08, 0x00, 0x00,
                                                       0x05, 0x05, 0x04, 0x04, 0x0c, 0x0c };
 
-static uint8_t              status_codes[2][8]    = { { 0x13, 0x15, 0x15, 0x15, 0x12, 0x11, 0x13, 0x13 },
-                                                      { 0x00, 0x00, 0x00, 0x00, 0x15, 0x11, 0x00, 0x00 } };
+static uint8_t              status_codes[2][16]   = { { 0x13, 0x15, 0x15, 0x15, 0x12, 0x11, 0x13, 0x13,
+                                                        0x12, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15 },
+                                                      { 0x00, 0x00, 0x00, 0x00, 0x15, 0x11, 0x00, 0x00,
+                                                        0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };
 static int                  mult                  = 1;
 static int                  part                  = 0;
 static int                  ecc_diff              = 288;
@@ -123,7 +125,7 @@ static const struct {
 static void
 cdrom_generate_name(const int type, char *name, const int internal)
 {
-    char  elements[3][2048] = { 0 };
+    char  elements[3][512] = { 0 };
 
     memcpy(elements[0], cdrom_drive_types[type].vendor,
            strlen(cdrom_drive_types[type].vendor) + 1);
@@ -287,32 +289,39 @@ msf_to_bcd(int *m, int *s, int *f)
 static int
 read_data(cdrom_t *dev, const uint32_t lba)
 {
-    return dev->ops->read_sector(dev->local, dev->raw_buffer, lba);
+    int ret = 1;
+
+    if (dev->cached_sector != lba) {
+        dev->cached_sector = lba;
+
+        ret = dev->ops->read_sector(dev->local,
+                                    dev->raw_buffer[dev->cur_buf ^ 1], lba);
+
+        if (ret <= 0) {
+            memset(dev->raw_buffer[dev->cur_buf ^ 1], 0x00, 2448);
+            dev->cached_sector = -1;
+        }
+
+        dev->cur_buf ^= 1;
+    }
+
+    return ret;
 }
 
 static void
 cdrom_get_subchannel(cdrom_t *dev, const uint32_t lba,
                      subchannel_t *subc, const int cooked)
 {
-    const uint8_t  *scb;
-    uint32_t        scb_offs = 0;
     uint8_t         q[16]    = { 0 };
+    if (lba != dev->cached_sector)
+        dev->cached_sector = -1;
 
-    if ((lba == dev->seek_pos) &&
-        ((dev->cd_status == CD_STATUS_PLAYING) || (dev->cd_status == CD_STATUS_PAUSED)))
-        scb      = dev->subch_buffer;
-    else {
-        scb      = (const uint8_t *) dev->raw_buffer;
-        scb_offs = 2352;
-
-        memset(dev->raw_buffer, 0, 2448);
-
-        (void) read_data(dev, lba);
-    }
+    (void) read_data(dev, lba);
 
     for (int i = 0; i < 12; i++)
         for (int j = 0; j < 8; j++)
-             q[i] |= ((scb[scb_offs + (i << 3) + j] >> 6) & 0x01) << (7 - j);
+             q[i] |= ((dev->raw_buffer[dev->cur_buf][RAW_SECTOR_SIZE +
+                                       (i << 3) + j] >> 6) & 0x01) << (7 - j);
 
     if (cooked) {
         uint8_t temp = (q[0] >> 4) | ((q[0] & 0xf) << 4);
@@ -407,7 +416,7 @@ find_specific_track(const raw_track_info_t *trti, const int num, const int track
 
 static int
 read_toc_normal(const cdrom_t *dev, unsigned char *b,
-                const unsigned char start_track, const int msf,
+                unsigned char start_track, const int msf,
                 const int sony)
 {
     uint8_t                 rti[65536]  = { 0 };
@@ -418,7 +427,10 @@ read_toc_normal(const cdrom_t *dev, unsigned char *b,
     int                     len         = 4;
     int                     t           = -1;
 
-    cdrom_log(dev->log, "read_toc_normal(%016" PRIXPTR ", %016" PRIXPTR ", %02X, %i)\n",
+    if ((dev->is_bcd || dev->is_chinon) && (start_track < 0xa0))
+        start_track = bcd2bin(start_track);
+
+    cdrom_log(dev->log, "read_toc_normal(%016" PRIXPTR ", %016" PRIXPTR ", %02X, %i, %i)\n",
               (uintptr_t) dev, (uintptr_t) b, start_track, msf, sony);
 
     dev->ops->get_raw_track_info(dev->local, &num, rti);
@@ -459,7 +471,11 @@ read_toc_normal(const cdrom_t *dev, unsigned char *b,
             if (!sony)
                 b[len++] = 0;                /* Reserved */
             b[len++] = tprti[i].adr_ctl; /* ADR/CTL */
-            b[len++] = tprti[i].point;   /* Track number */
+            if ((dev->is_bcd || dev->is_chinon) && (tprti[i].point >= 1) &&
+                (tprti[i].point <= 99))
+                b[len++] = bin2bcd(tprti[i].point);   /* Track number */
+            else
+                b[len++] = tprti[i].point;   /* Track number */
             if (!sony)
                 b[len++] = 0;                /* Reserved */
 
@@ -467,7 +483,7 @@ read_toc_normal(const cdrom_t *dev, unsigned char *b,
                 b[len++] = 0;
 
                 /* NEC CDR-260 speaks BCD. */
-                if (dev->is_early) {
+                if (dev->is_bcd) {
                     int m = tprti[i].pm;
                     int s = tprti[i].ps;
                     int f = tprti[i].pf;
@@ -528,14 +544,18 @@ read_toc_session(const cdrom_t *dev, unsigned char *b, const int msf)
         if (first != NULL) {
             b[len++] = 0x00;
             b[len++] = first->adr_ctl;
-            b[len++] = first->point;
+            if ((dev->is_bcd || dev->is_chinon) && (first->point >= 1) &&
+                (first->point <= 99))
+                b[len++] = bin2bcd(first->point);
+            else
+                b[len++] = first->point;
             b[len++] = 0x00;
 
             if (msf) {
                 b[len++] = 0x00;
 
                 /* NEC CDR-260 speaks BCD. */
-                if (dev->is_early) {
+                if (dev->is_bcd) {
                     int m = first->pm;
                     int s = first->ps;
                     int f = first->pf;
@@ -587,6 +607,16 @@ read_toc_raw(const cdrom_t *dev, unsigned char *b, const unsigned char start_tra
     if (num != 0)  for (int i = 0; i < num; i++)
         if (t[i].session >= start_track) {
             memcpy(&(b[len]), &(t[i]), 11);
+
+            if ((dev->is_bcd || dev->is_chinon) && (b[3] >= 1) && (b[3] <= 99))
+                b[3] = bin2bcd(b[3]);
+
+            for (int j = 0; j < 3; j++)
+                if (dev->is_bcd) {
+                    b[4 + j] = bin2bcd(b[4 + j]);
+                    b[8 + j] = bin2bcd(b[8 + j]);
+                }
+
             len += 11;
         }
 
@@ -643,9 +673,9 @@ track_type_is_valid(UNUSED(const cdrom_t *dev), const int type, const int flags,
 static int
 read_audio(cdrom_t *dev, const uint32_t lba, uint8_t *b)
 {
-    const int ret = dev->ops->read_sector(dev->local, dev->raw_buffer, lba);
+    const int ret = read_data(dev, lba);
 
-    memcpy(b, dev->raw_buffer, 2352);
+    memcpy(b, dev->raw_buffer[dev->cur_buf], 2352);
 
     dev->cdrom_sector_size = 2352;
 
@@ -661,7 +691,7 @@ process_mode1(cdrom_t *dev, const int cdrom_sector_flags, uint8_t *b)
     if (cdrom_sector_flags & 0x80) {
         /* Sync */
         cdrom_log(dev->log, "[Mode 1] Sync\n");
-        memcpy(b, dev->raw_buffer, 12);
+        memcpy(b, dev->raw_buffer[dev->cur_buf], 12);
         dev->cdrom_sector_size += 12;
         b += 12;
     }
@@ -669,7 +699,7 @@ process_mode1(cdrom_t *dev, const int cdrom_sector_flags, uint8_t *b)
     if (cdrom_sector_flags & 0x20) {
         /* Header */
         cdrom_log(dev->log, "[Mode 1] Header\n");
-        memcpy(b, dev->raw_buffer + 12, 4);
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 12, 4);
         dev->cdrom_sector_size += 4;
         b += 4;
     }
@@ -679,7 +709,7 @@ process_mode1(cdrom_t *dev, const int cdrom_sector_flags, uint8_t *b)
         if (!(cdrom_sector_flags & 0x10)) {
             /* No user data */
             cdrom_log(dev->log, "[Mode 1] Sub-header\n");
-            memcpy(b, dev->raw_buffer + 16, 8);
+            memcpy(b, dev->raw_buffer[dev->cur_buf] + 16, 8);
             dev->cdrom_sector_size += 8;
             b += 8;
         }
@@ -689,12 +719,12 @@ process_mode1(cdrom_t *dev, const int cdrom_sector_flags, uint8_t *b)
         /* User data */
         cdrom_log(dev->log, "[Mode 1] User data\n");
         if (mult > 1) {
-            memcpy(b, dev->raw_buffer + 16 + (part * dev->sector_size),
-                   dev->sector_size);
+            memcpy(b, dev->raw_buffer[dev->cur_buf] + 16 +
+                   (part * dev->sector_size), dev->sector_size);
             dev->cdrom_sector_size += dev->sector_size;
             b += dev->sector_size;
         } else {
-            memcpy(b, dev->raw_buffer + 16, 2048);
+            memcpy(b, dev->raw_buffer[dev->cur_buf] + 16, 2048);
             dev->cdrom_sector_size += 2048;
             b += 2048;
         }
@@ -703,7 +733,7 @@ process_mode1(cdrom_t *dev, const int cdrom_sector_flags, uint8_t *b)
     if (cdrom_sector_flags & 0x08) {
         /* EDC/ECC */
         cdrom_log(dev->log, "[Mode 1] EDC/ECC\n");
-        memcpy(b, dev->raw_buffer + 2064, (288 - ecc_diff));
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 2064, (288 - ecc_diff));
         dev->cdrom_sector_size += (288 - ecc_diff);
     }
 }
@@ -717,7 +747,7 @@ process_mode2_non_xa(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x80) {
         /* Sync */
         cdrom_log(dev->log, "[Mode 2 Formless] Sync\n");
-        memcpy(b, dev->raw_buffer, 12);
+        memcpy(b, dev->raw_buffer[dev->cur_buf], 12);
         dev->cdrom_sector_size += 12;
         b += 12;
     }
@@ -725,7 +755,7 @@ process_mode2_non_xa(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x20) {
         /* Header */
         cdrom_log(dev->log, "[Mode 2 Formless] Header\n");
-        memcpy(b, dev->raw_buffer + 12, 4);
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 12, 4);
         dev->cdrom_sector_size += 4;
         b += 4;
     }
@@ -734,7 +764,7 @@ process_mode2_non_xa(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x40) {
         /* Sub-header */
         cdrom_log(dev->log, "[Mode 2 Formless] Sub-header\n");
-        memcpy(b, dev->raw_buffer + 16, 8);
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 16, 8);
         dev->cdrom_sector_size += 8;
         b += 8;
     }
@@ -742,7 +772,7 @@ process_mode2_non_xa(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x10) {
         /* User data */
         cdrom_log(dev->log, "[Mode 2 Formless] User data\n");
-        memcpy(b, dev->raw_buffer + 24, (2336 - ecc_diff));
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 24, (2336 - ecc_diff));
         dev->cdrom_sector_size += (2336 - ecc_diff);
     }
 }
@@ -756,7 +786,7 @@ process_mode2_xa_form1(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x80) {
         /* Sync */
         cdrom_log(dev->log, "[XA Mode 2 Form 1] Sync\n");
-        memcpy(b, dev->raw_buffer, 12);
+        memcpy(b, dev->raw_buffer[dev->cur_buf], 12);
         dev->cdrom_sector_size += 12;
         b += 12;
     }
@@ -764,7 +794,7 @@ process_mode2_xa_form1(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x20) {
         /* Header */
         cdrom_log(dev->log, "[XA Mode 2 Form 1] Header\n");
-        memcpy(b, dev->raw_buffer + 12, 4);
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 12, 4);
         dev->cdrom_sector_size += 4;
         b += 4;
     }
@@ -772,7 +802,7 @@ process_mode2_xa_form1(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x40) {
         /* Sub-header */
         cdrom_log(dev->log, "[XA Mode 2 Form 1] Sub-header\n");
-        memcpy(b, dev->raw_buffer + 16, 8);
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 16, 8);
         dev->cdrom_sector_size += 8;
         b += 8;
     }
@@ -781,12 +811,12 @@ process_mode2_xa_form1(cdrom_t *dev, const int cdrom_sector_flags,
         /* User data */
         cdrom_log(dev->log, "[XA Mode 2 Form 1] User data\n");
         if (mult > 1) {
-            memcpy(b, dev->raw_buffer + 24 + (part * dev->sector_size),
-                   dev->sector_size);
+            memcpy(b, dev->raw_buffer[dev->cur_buf] + 24 +
+                   (part * dev->sector_size), dev->sector_size);
             dev->cdrom_sector_size += dev->sector_size;
             b += dev->sector_size;
         } else {
-            memcpy(b, dev->raw_buffer + 24, 2048);
+            memcpy(b, dev->raw_buffer[dev->cur_buf] + 24, 2048);
             dev->cdrom_sector_size += 2048;
             b += 2048;
         }
@@ -795,7 +825,7 @@ process_mode2_xa_form1(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x08) {
         /* EDC/ECC */
         cdrom_log(dev->log, "[XA Mode 2 Form 1] EDC/ECC\n");
-        memcpy(b, dev->raw_buffer + 2072, (280 - ecc_diff));
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 2072, (280 - ecc_diff));
         dev->cdrom_sector_size += (280 - ecc_diff);
     }
 }
@@ -809,7 +839,7 @@ process_mode2_xa_form2(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x80) {
         /* Sync */
         cdrom_log(dev->log, "[XA Mode 2 Form 2] Sync\n");
-        memcpy(b, dev->raw_buffer, 12);
+        memcpy(b, dev->raw_buffer[dev->cur_buf], 12);
         dev->cdrom_sector_size += 12;
         b += 12;
     }
@@ -817,7 +847,7 @@ process_mode2_xa_form2(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x20) {
         /* Header */
         cdrom_log(dev->log, "[XA Mode 2 Form 2] Header\n");
-        memcpy(b, dev->raw_buffer + 12, 4);
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 12, 4);
         dev->cdrom_sector_size += 4;
         b += 4;
     }
@@ -825,7 +855,7 @@ process_mode2_xa_form2(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x40) {
         /* Sub-header */
         cdrom_log(dev->log, "[XA Mode 2 Form 2] Sub-header\n");
-        memcpy(b, dev->raw_buffer + 16, 8);
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 16, 8);
         dev->cdrom_sector_size += 8;
         b += 8;
     }
@@ -833,14 +863,14 @@ process_mode2_xa_form2(cdrom_t *dev, const int cdrom_sector_flags,
     if (cdrom_sector_flags & 0x10) {
         /* User data */
         cdrom_log(dev->log, "[XA Mode 2 Form 2] User data\n");
-        memcpy(b, dev->raw_buffer + 24, (2328 - ecc_diff));
+        memcpy(b, dev->raw_buffer[dev->cur_buf] + 24,
+               (2328 - ecc_diff));
         dev->cdrom_sector_size += (2328 - ecc_diff);
     }
 }
 
 static void
-process_ecc_and_subch(cdrom_t *dev, const int cdrom_sector_flags,
-                      uint8_t *b)
+process_c2(cdrom_t *dev, const int cdrom_sector_flags, uint8_t *b)
 {
     if ((cdrom_sector_flags & 0x06) == 0x02) {
         /* Add error flags. */
@@ -852,31 +882,65 @@ process_ecc_and_subch(cdrom_t *dev, const int cdrom_sector_flags,
         cdrom_log(dev->log, "Full error flags\n");
         memcpy(b + dev->cdrom_sector_size, dev->extra_buffer, 296);
         dev->cdrom_sector_size += 296;
-     }
+    }
+}
+
+static void
+cdrom_deinterleave_subch(uint8_t *d, const uint8_t *s)
+{
+    for (int i = 0; i < 8 * 12; i++) {
+        int dmask = 0x80;
+        int smask = 1 << (7 - (i / 12));
+
+        (*d) = 0;
+
+        for (int j = 0; j < 8; j++) {
+            (*d) |= (s[(i % 12) * 8 + j] & smask) ? dmask : 0;
+            dmask >>= 1;
+        }
+
+        d++;
+    }
+}
+
+static void
+process_c2_and_subch(cdrom_t *dev, const int cdrom_sector_flags,
+                      uint8_t *b)
+{
+     if (dev->c2_first)
+         process_c2(dev, cdrom_sector_flags, b);
 
      if ((cdrom_sector_flags & 0x700) == 0x100) {
          cdrom_log(dev->log, "Raw subchannel data\n");
-         memcpy(b + dev->cdrom_sector_size, dev->raw_buffer + 2352, 96);
+         memcpy(b + dev->cdrom_sector_size, dev->raw_buffer[dev->cur_buf] +
+                2352, 96);
          dev->cdrom_sector_size += 96;
      } else if ((cdrom_sector_flags & 0x700) == 0x200) {
          cdrom_log(dev->log, "Q subchannel data\n");
-         memcpy(b + dev->cdrom_sector_size, dev->raw_buffer + 2352, 16);
+         memcpy(b + dev->cdrom_sector_size, dev->raw_buffer[dev->cur_buf] +
+                2352, 16);
          dev->cdrom_sector_size += 16;
      } else if ((cdrom_sector_flags & 0x700) == 0x400) {
          cdrom_log(dev->log, "R/W subchannel data\n");
-         memcpy(b + dev->cdrom_sector_size, dev->raw_buffer + 2352, 96);
+         cdrom_deinterleave_subch(b + dev->cdrom_sector_size,
+                                  dev->raw_buffer[dev->cur_buf] + 2352);
          dev->cdrom_sector_size += 96;
      }
+
+     if (!dev->c2_first)
+         process_c2(dev, cdrom_sector_flags, b);
 }
 
 static void
 cdrom_drive_reset(cdrom_t *dev)
 {
-    dev->priv        = NULL;
-    dev->insert      = NULL;
-    dev->close       = NULL;
-    dev->get_volume  = NULL;
-    dev->get_channel = NULL;
+    dev->priv          = NULL;
+    dev->insert        = NULL;
+    dev->close         = NULL;
+    dev->get_volume    = NULL;
+    dev->get_channel   = NULL;
+
+    dev->cached_sector = -1;
 
     if (cdrom_drive_types[dev->type].speed == -1)
         dev->real_speed  = dev->speed;
@@ -891,7 +955,8 @@ cdrom_unload(cdrom_t *dev)
         cdrom_log(dev->log, "CDROM: cdrom_unload(%s)\n", dev->image_path);
     }
 
-    dev->cd_status = CD_STATUS_EMPTY;
+    dev->cd_status     = CD_STATUS_EMPTY;
+    dev->cached_sector = -1;
 
     if (dev->local != NULL) {
         dev->ops->close(dev->local);
@@ -901,6 +966,39 @@ cdrom_unload(cdrom_t *dev)
     dev->ops = NULL;
 }
 
+#ifdef ENABLE_CDROM_LOG
+static void
+cdrom_toc_dump(cdrom_t *dev)
+{
+    uint8_t     b[65536] = { 0 };
+    int         len      = cdrom_read_toc(dev, b, CD_TOC_RAW, 0, 0, 65536);
+    const char *fn2      = "d:\\86boxnew\\toc_cue.dmp";
+    FILE *      f        = fopen(fn2, "wb");
+    fwrite(b, 1, len, f);
+    fflush(f);
+    fclose(f);
+    cdrom_log(dev->log, "Written TOC of %i bytes to %s\n", len, fn2);
+
+    memset(b, 0x00, 65536);
+    len      = cdrom_read_toc(dev, b, CD_TOC_NORMAL, 0, 0, 65536);
+    fn2      = "d:\\86boxnew\\toc_cue_cooked.dmp";
+    f        = fopen(fn2, "wb");
+    fwrite(b, 1, len, f);
+    fflush(f);
+    fclose(f);
+    cdrom_log(dev->log, "Written cooked TOC of %i bytes to %s\n", len, fn2);
+
+    memset(b, 0x00, 65536);
+    len      = cdrom_read_toc(dev, b, CD_TOC_SESSION, 0, 0, 65536);
+    fn2      = "d:\\86boxnew\\toc_cue_session.dmp";
+    f        = fopen(fn2, "wb");
+    fwrite(b, 1, len, f);
+    fflush(f);
+    fclose(f);
+    cdrom_log(dev->log, "Written session TOC of %i bytes to %s\n", len, fn2);
+}
+#endif
+
 /* Reset the CD-ROM Interface, whichever one that is. */
 void
 cdrom_interface_reset(void)
@@ -1002,24 +1100,6 @@ cdrom_is_generic(const int type)
     return (cdrom_drive_types[type].speed == -1);
 }
 
-int
-cdrom_has_date(const int type)
-{
-    /* This will do for now. */
-    return !strcmp(cdrom_drive_types[type].vendor, "PIONEER");
-}
-
-int
-cdrom_is_sony(const int type)
-{
-    /* This will do for now. */
-    return (cdrom_drive_types[type].bus_type == BUS_TYPE_SCSI) &&
-           (!strcmp(cdrom_drive_types[type].vendor, "DEC") ||
-            !strcmp(cdrom_drive_types[type].vendor, "ShinaKen") ||
-            !strcmp(cdrom_drive_types[type].vendor, "SONY") ||
-            !strcmp(cdrom_drive_types[type].vendor, "TEXEL"));
-}
-
 int
 cdrom_is_caddy(const int type)
 {
@@ -1068,7 +1148,7 @@ cdrom_get_type_count(void)
 void
 cdrom_get_identify_model(const int type, char *name, const int id)
 {
-    char  elements[2][2048] = { 0 };
+    char  elements[2][512] = { 0 };
 
     memcpy(elements[0], cdrom_drive_types[type].vendor,
            strlen(cdrom_drive_types[type].vendor) + 1);
@@ -1198,6 +1278,24 @@ cdrom_lba_to_msf_accurate(const int lba)
     return ((m << 16) | (s << 8) | f);
 }
 
+void
+cdrom_interleave_subch(uint8_t *d, const uint8_t *s)
+{
+    memset(d, 0x00, 96);
+
+    for (int i = 0; i < 8 * 12; i++) {
+        int smask = 0x80;
+        int dmask = 1 << (7 - (i / 12));
+
+        for (int j = 0; j < 8; j++) {
+            d[(i % 12) * 8 + j] |= ((*s) & smask) ? dmask : 0;
+            smask >>= 1;
+        }
+
+        s++;
+    }
+}
+
 double
 cdrom_seek_time(const cdrom_t *dev)
 {
@@ -1262,40 +1360,58 @@ cdrom_is_pre(const cdrom_t *dev, const uint32_t lba)
     return 0;
 }
 
+#include <86box/filters.h>
+
+static void
+cdrom_audio_deemphasize(int16_t *buffer)
+{
+    for (int i = 0; i < 588; i++)
+        for (int j = 0; j < 2; j++)
+            buffer[(i * 2) + j] = deemph_iir(j, buffer[(i * 2) + j]);
+}
+
 int
 cdrom_audio_callback(cdrom_t *dev, int16_t *output, const int len)
 {
     int ret = 1;
 
-    if (!dev->sound_on || (dev->cd_status != CD_STATUS_PLAYING) || dev->audio_muted_soft) {
-        // cdrom_log(dev->log, "Audio callback while not playing\n");
-        if (dev->cd_status == CD_STATUS_PLAYING)
-            dev->seek_pos += (len >> 11);
-        memset(output, 0, len * 2);
-        return 0;
-    }
-
     while (dev->cd_buflen < len) {
         if (dev->seek_pos < dev->cd_end) {
-            if (dev->ops->read_sector(dev->local,
-                (uint8_t *) &(dev->cd_buffer[dev->cd_buflen]), dev->seek_pos)) {
+            ret = dev->ops->read_sector(dev->local,
+                                        dev->raw_buffer[dev->cur_buf ^ 1],
+                                        dev->seek_pos);
+            if (!dev->sound_on)
+                memset(dev->raw_buffer[dev->cur_buf ^ 1], 0x00, 2352);
+            dev->cur_buf ^= 1;
+            if (ret) {
                 cdrom_log(dev->log, "Read LBA %08X successful\n", dev->seek_pos);
-                memcpy(dev->subch_buffer,
-                       ((uint8_t *) &(dev->cd_buffer[dev->cd_buflen])) + 2352, 96);
+                dev->cached_sector = dev->seek_pos;
+                /* Q subchannel data in bit 6: 4-5-6-7-0-1-2-3. */
+                if ((dev->raw_buffer[dev->cur_buf][2353] >> 6) & 0x01)
+                    /* Data sector, copy silence into buffer. */
+                    memset((uint8_t *) &(dev->cd_buffer[dev->cd_buflen]),
+                           0x00, RAW_SECTOR_SIZE);
+                else {
+                    memcpy((uint8_t *) &(dev->cd_buffer[dev->cd_buflen]),
+                           dev->raw_buffer[dev->cur_buf], RAW_SECTOR_SIZE);
+                    if ((dev->raw_buffer[dev->cur_buf][2355] >> 6) & 0x01)
+                        /* De-emphasize pre-emphasized audio. */
+                        cdrom_audio_deemphasize(&(dev->cd_buffer[dev->cd_buflen]));
+                }
                 dev->seek_pos++;
                 dev->cd_buflen += (RAW_SECTOR_SIZE / 2);
                 ret = 1;
             } else {
                 cdrom_log(dev->log, "Read LBA %08X failed\n", dev->seek_pos);
                 memset(&(dev->cd_buffer[dev->cd_buflen]), 0x00,
-                       (BUF_SIZE - dev->cd_buflen) * 2);
+                       (CD_BUF_SIZE - dev->cd_buflen) * 2);
                 dev->cd_status    = CD_STATUS_STOPPED;
                 dev->cd_buflen    = len;
                 ret               = 0;
             }
         } else {
             cdrom_log(dev->log, "Playing completed\n");
-            memset(&dev->cd_buffer[dev->cd_buflen], 0x00, (BUF_SIZE - dev->cd_buflen) * 2);
+            memset(&dev->cd_buffer[dev->cd_buflen], 0x00, (CD_BUF_SIZE - dev->cd_buflen) * 2);
             dev->cd_status    = CD_STATUS_PLAYING_COMPLETED;
             dev->cd_buflen    = len;
             ret               = 0;
@@ -1303,9 +1419,12 @@ cdrom_audio_callback(cdrom_t *dev, int16_t *output, const int len)
     }
 
     memcpy(output, dev->cd_buffer, len * 2);
-    memmove(dev->cd_buffer, &dev->cd_buffer[len], (BUF_SIZE - len) * 2);
+    memmove(dev->cd_buffer, &dev->cd_buffer[len], (CD_BUF_SIZE - len) * 2);
     dev->cd_buflen -= len;
 
+    if (!dev->sound_on)
+        ret               = 0;
+
     cdrom_log(dev->log, "Audio callback returning %i\n", ret);
     return ret;
 }
@@ -1314,15 +1433,18 @@ uint8_t
 cdrom_audio_play(cdrom_t *dev, const uint32_t pos, const uint32_t len, const int ismsf)
 {
     track_info_t ti;
-    uint32_t     pos2 = pos;
-    uint32_t     len2 = len;
-    int          ret  = 0;
+    uint32_t      pos2      = pos;
+    uint32_t      len2      = len;
+    int           ret       = 0;
 
     if (dev->cd_status & CD_STATUS_HAS_AUDIO) {
         cdrom_log(dev->log, "Play audio - %08X %08X %i\n", pos2, len, ismsf);
 
         if (ismsf & 0x100) {
             /* Track-relative audio play. */
+            pos2 = ismsf & 0xff;
+            if ((dev->is_bcd || dev->is_chinon) && (pos2 < 0xa0))
+                pos2 = bcd2bin(pos2);
             ret = dev->ops->get_track_info(dev->local, ismsf & 0xff, 0, &ti);
             if (ret)
                pos2 += MSFtoLBA(ti.m, ti.s, ti.f) - 150;
@@ -1332,13 +1454,17 @@ cdrom_audio_play(cdrom_t *dev, const uint32_t pos, const uint32_t len, const int
                 cdrom_stop(dev);
             }
         } else if ((ismsf == 2) || (ismsf == 3)) {
+            if ((dev->is_bcd || dev->is_chinon) && (pos2 < 0xa0))
+                pos2 = bcd2bin(pos2);
             ret = dev->ops->get_track_info(dev->local, pos2, 0, &ti);
             if (ret) {
                 pos2 = MSFtoLBA(ti.m, ti.s, ti.f) - 150;
                 if (ismsf == 2) {
                     /* We have to end at the *end* of the specified track,
                        not at the beginning. */
-                    ret = dev->ops->get_track_info(dev->local, len, 1, &ti);
+                    if ((dev->is_bcd || dev->is_chinon) && (len2 < 0xa0))
+                        len2 = bcd2bin(len2);
+                    ret = dev->ops->get_track_info(dev->local, len2, 1, &ti);
                     if (ret)
                         len2 = MSFtoLBA(ti.m, ti.s, ti.f) - 150;
                     else {
@@ -1358,7 +1484,7 @@ cdrom_audio_play(cdrom_t *dev, const uint32_t pos, const uint32_t len, const int
             int f = pos & 0xff;
 
             /* NEC CDR-260 speaks BCD. */
-            if (dev->is_early)
+            if (dev->is_bcd)
                 msf_from_bcd(&m, &s, &f);
 
             if (pos == 0xffffff) {
@@ -1372,7 +1498,7 @@ cdrom_audio_play(cdrom_t *dev, const uint32_t pos, const uint32_t len, const int
             f = len & 0xff;
 
             /* NEC CDR-260 speaks BCD. */
-            if (dev->is_early)
+            if (dev->is_bcd)
                 msf_from_bcd(&m, &s, &f);
 
             len2 = MSFtoLBA(m, s, f) - 150;
@@ -1392,8 +1518,6 @@ cdrom_audio_play(cdrom_t *dev, const uint32_t pos, const uint32_t len, const int
     }
 
     if (ret) {
-        dev->audio_muted_soft = 0;
-
         /*
            Do this at this point, since it's at this point that we know the
            actual LBA position to start playing from.
@@ -1401,10 +1525,11 @@ cdrom_audio_play(cdrom_t *dev, const uint32_t pos, const uint32_t len, const int
         ret = (dev->ops->get_track_type(dev->local, pos2) == CD_TRACK_AUDIO);
 
         if (ret) {
-            dev->seek_pos  = pos2;
-            dev->cd_end    = len2;
-            dev->cd_status = CD_STATUS_PLAYING;
-            dev->cd_buflen = 0;
+            dev->seek_diff     = ABS(dev->seek_pos - pos2);
+            dev->seek_pos      = pos2;
+            dev->cd_end        = len2;
+            dev->cd_status     = CD_STATUS_PLAYING;
+            dev->cd_buflen     = 0;
         } else {
             cdrom_log(dev->log, "LBA %08X not on an audio track\n", pos);
             cdrom_stop(dev);
@@ -1425,6 +1550,8 @@ cdrom_audio_track_search(cdrom_t *dev, const uint32_t pos,
         cdrom_log(dev->log, "Audio Track Search: MSF = %06x, type = %02x, "
                   "playbit = %02x\n", pos, type, playbit);
 
+        ret = 1;
+
         switch (type) {
             case 0x00:
                 if (pos == 0xffffffff) {
@@ -1445,40 +1572,38 @@ cdrom_audio_track_search(cdrom_t *dev, const uint32_t pos,
 
                 dev->seek_pos = pos2;
                 break;
-            } case 0x80:
-                if (pos == 0xffffffff) {
-                    cdrom_log(dev->log, "(Type 2) Search from current position\n");
-                    pos2 = dev->seek_pos;
+            } case 0x80: {
+                track_info_t ti;
+
+                pos2 = (pos2 >> 24) & 0xff;
+                if (pos2 < 0xa0)
+                    pos2 = bcd2bin(pos2);
+                ret = dev->ops->get_track_info(dev->local, pos2, 1, &ti);
+                if (ret)
+                    dev->seek_pos = MSFtoLBA(ti.m, ti.s, ti.f) - 150;
+                else {
+                    cdrom_log(dev->log, "Unable to get the starting position for "
+                              "track %08X\n", ismsf & 0xff);
+                    cdrom_stop(dev);
                 }
-                dev->seek_pos = (pos2 >> 24) & 0xff;
                 break;
-            default:
+            } default:
                 break;
         }
 
-        if (pos2 != 0x00000000)
-            pos2--;
+        if (ret) {
+            if (pos2 != 0x00000000)
+                pos2--;
 
-        /*
-           Do this at this point, since it's at this point that we know the
-           actual LBA position to start playing from.
-         */
-        if (dev->ops->get_track_type(dev->local, pos2) & CD_TRACK_AUDIO)
-            dev->audio_muted_soft = 0;
-        else {
-            cdrom_log(dev->log, "Track Search: LBA %08X not on an audio track\n", pos);
-            dev->audio_muted_soft = 1;
-            if (dev->ops->get_track_type(dev->local, pos) & CD_TRACK_AUDIO)
-                dev->audio_muted_soft = 0;
+            cdrom_log(dev->log, "Track Search Toshiba: LBA=%08X.\n", pos);
+
+            dev->cd_end    = dev->cdrom_capacity;
+            dev->cd_buflen = 0;
+
+            dev->cd_status = playbit ? CD_STATUS_PLAYING : CD_STATUS_HOLD;
+
+            ret            = 1;
         }
-
-        cdrom_log(dev->log, "Track Search Toshiba: Muted?=%d, LBA=%08X.\n",
-                  dev->audio_muted_soft, pos);
-        dev->cd_buflen = 0;
-
-        dev->cd_status = playbit ? CD_STATUS_PLAYING : CD_STATUS_PAUSED;
-
-        ret            = 1;
     }
 
     return ret;
@@ -1502,15 +1627,15 @@ cdrom_audio_track_search_pioneer(cdrom_t *dev, const uint32_t pos, const uint8_t
 
         dev->seek_pos = pos2;
 
-        dev->audio_muted_soft = 0;
-
         /*
            Do this at this point, since it's at this point that we know the
            actual LBA position to start playing from.
          */
         if (dev->ops->get_track_type(dev->local, pos2) & CD_TRACK_AUDIO) {
+            dev->cd_end    = dev->cdrom_capacity;
             dev->cd_buflen = 0;
-            dev->cd_status = playbit ? CD_STATUS_PLAYING : CD_STATUS_PAUSED;
+
+            dev->cd_status = playbit ? CD_STATUS_PLAYING : CD_STATUS_HOLD;
 
             ret = 1;
         } else {
@@ -1534,7 +1659,6 @@ cdrom_audio_play_pioneer(cdrom_t *dev, const uint32_t pos)
         uint32_t  pos2 = MSFtoLBA(m, s, f) - 150;
         dev->cd_end = pos2;
 
-        dev->audio_muted_soft = 0;
         dev->cd_buflen = 0;
 
         dev->cd_status = CD_STATUS_PLAYING;
@@ -1553,6 +1677,8 @@ cdrom_audio_play_toshiba(cdrom_t *dev, const uint32_t pos, const int type)
 
     if (dev->cd_status & CD_STATUS_HAS_AUDIO) {
         /* Preliminary support, revert if too incomplete. */
+        ret = 1;
+
         switch (type) {
             case 0x00:
                 dev->cd_end = pos2;
@@ -1564,10 +1690,22 @@ cdrom_audio_play_toshiba(cdrom_t *dev, const uint32_t pos, const int type)
                 pos2 = MSFtoLBA(m, s, f) - 150;
                 dev->cd_end = pos2;
                 break;
-            } case 0x80:
-                dev->cd_end = (pos2 >> 24) & 0xff;
+            } case 0x80: {
+                track_info_t ti;
+
+                pos2 = (pos2 >> 24) & 0xff;
+                if (pos2 < 0xa0)
+                    pos2 = bcd2bin(pos2);
+                ret = dev->ops->get_track_info(dev->local, pos2, 1, &ti);
+                if (ret)
+                    dev->cd_end = MSFtoLBA(ti.m, ti.s, ti.f) - 150;
+                else {
+                    cdrom_log(dev->log, "Unable to get the starting position for "
+                              "track %08X\n", ismsf & 0xff);
+                    cdrom_stop(dev);
+                }
                 break;
-            case 0xc0:
+            } case 0xc0:
                 if (pos == 0xffffffff) {
                     cdrom_log(dev->log, "Playing from current position\n");
                     pos2 = dev->cd_end;
@@ -1578,55 +1716,32 @@ cdrom_audio_play_toshiba(cdrom_t *dev, const uint32_t pos, const int type)
                 break;
         }
 
-        cdrom_log(dev->log, "Toshiba Play Audio: Muted?=%d, LBA=%08X.\n",
-                  dev->audio_muted_soft, pos2);
-        dev->cd_buflen = 0;
+        if (ret) {
+            cdrom_log(dev->log, "Toshiba Play Audio: LBA=%08X.\n", pos2);
 
-        dev->cd_status = CD_STATUS_PLAYING;
-
-        ret = 1;
+            dev->cd_status = CD_STATUS_PLAYING;
+            dev->cd_buflen = 0;
+        }
     }
 
     return ret;
 }
 
 uint8_t
-cdrom_audio_scan(cdrom_t *dev, const uint32_t pos, const int type)
+cdrom_audio_scan(cdrom_t *dev, const uint32_t pos)
 {
-    uint32_t pos2 = pos;
-    uint8_t  ret  = 0;
+    uint32_t      pos2      = pos;
+    uint8_t       ret       = 0;
 
     if (dev->cd_status & CD_STATUS_HAS_AUDIO) {
         cdrom_log(dev->log, "Audio Scan: MSF = %06x, type = %02x\n", pos, type);
 
-        switch (type) {
-            case 0x00:
-                if (pos == 0xffffffff) {
-                    cdrom_log(dev->log, "(Type 0) Search from current position\n");
-                    pos2 = dev->seek_pos;
-                }
-                dev->seek_pos = pos2;
-                break;
-            case 0x40: {
-                const int m   = bcd2bin((pos >> 24) & 0xff);
-                const int s   = bcd2bin((pos >> 16) & 0xff);
-                const int f   = bcd2bin((pos >> 8) & 0xff);
-                if (pos == 0xffffffff) {
-                    cdrom_log(dev->log, "(Type 1) Search from current position\n");
-                    pos2 = dev->seek_pos;
-                } else
-                    pos2 = MSFtoLBA(m, s, f) - 150;
-
-                dev->seek_pos = pos2;
-                break;
-            } case 0x80:
-                dev->seek_pos = (pos >> 24) & 0xff;
-                break;
-            default:
-                break;
+        if (pos == 0xffffffff) {
+            cdrom_log(dev->log, "(Type 0) Search from current position\n");
+            pos2 = dev->seek_pos;
         }
+        dev->seek_pos = pos2;
 
-        dev->audio_muted_soft = 0;
         /* Do this at this point, since it's at this point that we know the
            actual LBA position to start playing from. */
         if (dev->ops->get_track_type(dev->local, pos) & CD_TRACK_AUDIO) {
@@ -1651,8 +1766,8 @@ cdrom_audio_pause_resume(cdrom_t *dev, const uint8_t resume)
 uint8_t
 cdrom_get_current_status(const cdrom_t *dev)
 {
-    const uint8_t is_chinon = !strcmp(cdrom_drive_types[dev->type].vendor, "CHINON");
-    const uint8_t ret       = status_codes[is_chinon][dev->cd_status & CD_STATUS_MASK];
+    const uint8_t ret = status_codes[dev->is_chinon]
+                                    [dev->cd_status & CD_STATUS_MASK];
 
     return ret;
 }
@@ -1660,9 +1775,14 @@ cdrom_get_current_status(const cdrom_t *dev)
 void
 cdrom_get_current_subchannel(cdrom_t *dev, uint8_t *b, const int msf)
 {
-    subchannel_t subc;
+    subchannel_t  subc;
+    int           base      = 0;
+    int           diff      = 4;
 
-    cdrom_get_subchannel(dev, dev->seek_pos, &subc, 1);
+    if (dev->cached_sector == -1)
+        cdrom_get_subchannel(dev, dev->seek_pos, &subc, 1);
+    else
+        cdrom_get_subchannel(dev, dev->cached_sector, &subc, 1);
 
     cdrom_log(dev->log, "Returned subchannel absolute at %02i:%02i.%02i, "
               "relative at %02i:%02i.%02i, seek pos = %08x, cd_end = %08x.\n",
@@ -1675,17 +1795,26 @@ cdrom_get_current_subchannel(cdrom_t *dev, uint8_t *b, const int msf)
            Mode 0 = Q subchannel mode, first 16 bytes are indentical to mode 1 (current
                     position), the rest are stuff like ISRC etc., which can be all zeroes.
          */
+        case 0x00:
+            if (dev->bus_type == CDROM_BUS_ATAPI)
+                break;
+            diff = 0;
+            fallthrough;
         case 0x01:
             /* Current position. */
             b[1] = subc.attr;
-            b[2] = subc.track;
+            if ((dev->is_bcd || dev->is_chinon) &&
+                (subc.track >= 1) && (subc.track <= 99))
+                b[2] = bin2bcd(subc.track);
+            else
+                b[2] = subc.track;
             b[3] = subc.index;
 
             if (msf) {
                 b[4] = b[8] = 0x00;
 
                 /* NEC CDR-260 speaks BCD. */
-                if (dev->is_early) {
+                if (dev->is_bcd) {
                     b[5]  = bin2bcd(subc.abs_m);
                     b[6]  = bin2bcd(subc.abs_s);
                     b[7]  = bin2bcd(subc.abs_f);
@@ -1715,26 +1844,34 @@ cdrom_get_current_subchannel(cdrom_t *dev, uint8_t *b, const int msf)
                 b[10] = (dat >> 8) & 0xff;
                 b[11] = dat & 0xff;
             }
-            break;
+            if (b[0] != 0x00)
+                break;
+            base += 12;
+            fallthrough;
         case 0x02:
             /* UPC  - TODO: Finding and reporting the actual UPC data. */
-            memset(&(b[1]), 0x00, 19);
-            memset(&(b[5]), 0x30, 13);
+            memset(&(b[base]), 0x00, 20 - diff);
+            base += diff;
+            memset(&(b[base + 1]), 0x30, 13);
             /* NEC CDR-260 speaks BCD. */
-            if (dev->is_early)
-                b[19] = bin2bcd(subc.abs_f);
+            if (dev->is_bcd)
+                b[base + 15] = bin2bcd(subc.abs_f);
             else
-                b[19] = subc.abs_f;
-            break;
+                b[base + 15] = subc.abs_f;
+            if (b[0] != 0x00)
+                break;
+            base += 16;
+            fallthrough;
         case 0x03:
             /* ISRC - TODO: Finding and reporting the actual ISRC data. */
-            memset(&(b[1]), 0x00, 19);
-            memset(&(b[5]), 0x30, 12);
+            memset(&(b[base]), 0x00, 20 - diff);
+            base += diff;
+            memset(&(b[base]), 0x30, 12);
             /* NEC CDR-260 speaks BCD. */
-            if (dev->is_early)
-                b[18] = bin2bcd(subc.abs_f);
+            if (dev->is_bcd)
+                b[base + 14] = bin2bcd(subc.abs_f);
             else
-                b[18] = subc.abs_f;
+                b[base + 14] = subc.abs_f;
             break;
         default:
             cdrom_log(dev->log, "b[0] = %02X\n", b[0]);
@@ -1843,7 +1980,7 @@ cdrom_get_current_subcodeq(cdrom_t *dev, uint8_t *b)
 
     cdrom_get_subchannel(dev, dev->seek_pos, &subc, 0);
 
-    b[0] = subc.attr;
+    b[0] = (subc.attr >> 4) | ((subc.attr & 0xf) << 4);
     b[1] = subc.track;
     b[2] = subc.index;
     b[3] = subc.rel_m;
@@ -1852,6 +1989,10 @@ cdrom_get_current_subcodeq(cdrom_t *dev, uint8_t *b)
     b[6] = subc.abs_m;
     b[7] = subc.abs_s;
     b[8] = subc.abs_f;
+
+    cdrom_log(dev->log, "SubCodeQ: %02X %02X %02X %02X %02X %02X %02X %02X "
+              "%02X\n",
+              b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8]);
 }
 
 uint8_t
@@ -1861,20 +2002,25 @@ cdrom_get_current_subcodeq_playstatus(cdrom_t *dev, uint8_t *b)
 
     cdrom_get_current_subcodeq(dev, b);
 
-    if ((dev->cd_status == CD_STATUS_DATA_ONLY) ||
-        (dev->cd_status == CD_STATUS_DVD) ||
-        (dev->cd_status == CD_STATUS_PLAYING_COMPLETED) ||
-        (dev->cd_status == CD_STATUS_STOPPED))
-        ret = 0x03;
-    else
-        ret = (dev->cd_status == CD_STATUS_PLAYING) ? 0x00 : dev->audio_op;
+    switch (dev->cd_status) {
+        default:                  case CD_STATUS_EMPTY:
+        case CD_STATUS_DATA_ONLY: case CD_STATUS_DVD:
+        case CD_STATUS_STOPPED:   case CD_STATUS_PLAYING_COMPLETED:
+            ret = 0x03;
+            break;
+        case CD_STATUS_HOLD:
+            ret = 0x02;
+            break;
+        case CD_STATUS_PAUSED:
+            ret = 0x01;
+            break;
+        case CD_STATUS_PLAYING:
+            ret = 0x00;
+            break;
+    }
 
-    /*If a valid audio track is detected with audio on, unmute it.*/
-    if (dev->ops->get_track_type(dev->local, dev->seek_pos) & CD_TRACK_AUDIO)
-        dev->audio_muted_soft = 0;
-
-    cdrom_log(dev->log, "SubCodeQ: Play Status: Seek LBA=%08x, CDEND=%08x, mute=%d.\n",
-              dev->seek_pos, dev->cd_end, dev->audio_muted_soft);
+    cdrom_log(dev->log, "SubCodeQ: Play Status: Seek LBA=%08x, CDEND=%08x.\n",
+              dev->seek_pos, dev->cd_end);
     return ret;
 }
 
@@ -2042,14 +2188,11 @@ cdrom_read_disc_info_toc(cdrom_t *dev, uint8_t *b,
     switch (type) {
         case 0:
             if (num > 0) {
-                first = find_track(trti, num, 1);
-                const int last = find_track(trti, num, 0);
-
-                if ((first == -1) || (last == -1))
+                if (num < 4)
                     ret = 0;
                 else {
-                    b[0] = bin2bcd(first);
-                    b[1] = bin2bcd(last);
+                    b[0] = bin2bcd(trti[0].pm);
+                    b[1] = bin2bcd(trti[1].pm);
                     b[2] = 0x00;
                     b[3] = 0x00;
 
@@ -2109,7 +2252,7 @@ cdrom_read_disc_info_toc(cdrom_t *dev, uint8_t *b,
                     b[0x12] = temp;
                 }
             } else {
-                b[0] = 0x00;    /* Audio or CDROM disc. */
+                b[0] = trti[0].ps;    /* Disc type. */
 
                 if (num > 0)
                     first = find_track(trti, num, 1);
@@ -2196,7 +2339,6 @@ cdrom_readsector_raw(cdrom_t *dev, uint8_t *buffer, const int sector, const int
         if (dm != CD_TRACK_NORMAL)
             mode2 = 1;
 
-        memset(dev->raw_buffer, 0, 2448);
         memset(dev->extra_buffer, 0, 296);
 
         if ((cdrom_sector_flags & 0xf8) == 0x08) {
@@ -2229,28 +2371,29 @@ cdrom_readsector_raw(cdrom_t *dev, uint8_t *buffer, const int sector, const int
                 if (ret > 0) {
                     int form = 0;
 
-                    if ((dev->raw_buffer[0x000f] == 0x00) ||
-                        (dev->raw_buffer[0x000f] > 0x02)) {
+                    if ((dev->raw_buffer[dev->cur_buf][0x000f] == 0x00) ||
+                        (dev->raw_buffer[dev->cur_buf][0x000f] > 0x02)) {
                         cdrom_log(dev->log, "[%s] Unknown mode: %02X\n",
                                   cdrom_req_modes[cdrom_sector_type],
-                                  dev->raw_buffer[0x000f]);
+                                  dev->raw_buffer[dev->cur_buf][0x000f]);
                         ret = 0;
                     } else if (mode2) {
-                        if (dev->raw_buffer[0x000f] == 0x01)
+                        if (dev->raw_buffer[dev->cur_buf][0x000f] == 0x01)
                             /*
                                Use Mode 1, since evidently specification-violating
                                discs exist.
                              */
                             mode2 = 0;
-                        else if (dev->raw_buffer[0x0012] !=
-                                 dev->raw_buffer[0x0016]) {
+                        else if (dev->raw_buffer[dev->cur_buf][0x0012] !=
+                                 dev->raw_buffer[dev->cur_buf][0x0016]) {
                             cdrom_log(dev->log, "[%s] XA Mode 2 sector with "
                                       "malformed sub-header\n",
                                       cdrom_req_modes[cdrom_sector_type]);
                             ret = 0;
                         } else
-                            form = ((dev->raw_buffer[0x0012] & 0x20) >> 5) + 1;
-                    } else if (dev->raw_buffer[0x000f] == 0x02)
+                            form = ((dev->raw_buffer[dev->cur_buf][0x0012] &
+                                    0x20) >> 5) + 1;
+                    } else if (dev->raw_buffer[dev->cur_buf][0x000f] == 0x02)
                         mode2 = 1;
 
                     if (ret > 0) {
@@ -2282,7 +2425,7 @@ cdrom_readsector_raw(cdrom_t *dev, uint8_t *buffer, const int sector, const int
             }
 
             if (ret > 0) {
-                process_ecc_and_subch(dev, cdrom_sector_flags, b);
+                process_c2_and_subch(dev, cdrom_sector_flags, b);
                 *len = dev->cdrom_sector_size;
             }
         }
@@ -2618,7 +2761,7 @@ cdrom_read_track_information(cdrom_t *dev, const uint8_t *cdb, uint8_t *buffer)
 
              if (track->adr_ctl & 0x04) {
                  ret  = read_data(dev, start);
-                 mode = dev->raw_buffer[3];
+                 mode = dev->raw_buffer[dev->cur_buf][3];
              }
          } else if (track->point != 0xa2)
              start = 0x00000000;
@@ -2642,57 +2785,22 @@ cdrom_read_track_information(cdrom_t *dev, const uint8_t *cdb, uint8_t *buffer)
     return ret;
 }
 
-int
-cdrom_is_empty(const uint8_t id)
+uint8_t
+cdrom_get_current_mode(cdrom_t *dev)
 {
-    const cdrom_t *dev = &cdrom[id];
-    int            ret = 0;
+    if (dev->cached_sector == -1)
+        (void) read_data(dev, dev->seek_pos);
+    else
+        (void) read_data(dev, dev->cached_sector);
 
-    /* This entire block should be in cdrom.c/cdrom_eject(dev*) ... */
-    if (strlen(dev->image_path) == 0)
-        /* Switch from empty to empty. Do nothing. */
-        ret = 1;
-
-    return ret;
+    return dev->raw_buffer[dev->cur_buf][3];
 }
 
-#ifdef ENABLE_CDROM_LOG
-static void
-cdrom_toc_dump(cdrom_t *dev)
-{
-    uint8_t     b[65536] = { 0 };
-    int         len      = cdrom_read_toc(dev, b, CD_TOC_RAW, 0, 0, 65536);
-    const char *fn2      = "d:\\86boxnew\\toc_cue.dmp";
-    FILE *      f        = fopen(fn2, "wb");
-    fwrite(b, 1, len, f);
-    fflush(f);
-    fclose(f);
-    cdrom_log(dev->log, "Written TOC of %i bytes to %s\n", len, fn2);
-
-    memset(b, 0x00, 65536);
-    len      = cdrom_read_toc(dev, b, CD_TOC_NORMAL, 0, 0, 65536);
-    fn2      = "d:\\86boxnew\\toc_cue_cooked.dmp";
-    f        = fopen(fn2, "wb");
-    fwrite(b, 1, len, f);
-    fflush(f);
-    fclose(f);
-    cdrom_log(dev->log, "Written cooked TOC of %i bytes to %s\n", len, fn2);
-
-    memset(b, 0x00, 65536);
-    len      = cdrom_read_toc(dev, b, CD_TOC_SESSION, 0, 0, 65536);
-    fn2      = "d:\\86boxnew\\toc_cue_session.dmp";
-    f        = fopen(fn2, "wb");
-    fwrite(b, 1, len, f);
-    fflush(f);
-    fclose(f);
-    cdrom_log(dev->log, "Written session TOC of %i bytes to %s\n", len, fn2);
-}
-#endif
-
 void
 cdrom_set_empty(cdrom_t *dev)
 {
     dev->cd_status      = CD_STATUS_EMPTY;
+    dev->cached_sector  = -1;
 }
 
 void
@@ -2707,14 +2815,13 @@ cdrom_update_status(cdrom_t *dev)
     dev->seek_pos       = 0;
     dev->cd_buflen      = 0;
 
-    if ((dev->ops->is_empty != NULL) && dev->ops->is_empty(dev->local))
-        dev->cd_status      = CD_STATUS_EMPTY;
-    else if (dev->ops->is_dvd(dev->local))
+    if (dev->ops->is_dvd(dev->local))
         dev->cd_status      = CD_STATUS_DVD;
     else
         dev->cd_status      = dev->ops->has_audio(dev->local) ? CD_STATUS_STOPPED :
                                                                 CD_STATUS_DATA_ONLY;
 
+    dev->cached_sector  = -1;
     dev->cdrom_capacity = dev->ops->get_last_block(dev->local);
 
     if (dev->cd_status != CD_STATUS_EMPTY) {
@@ -2745,6 +2852,8 @@ cdrom_load(cdrom_t *dev, const char *fn, const int skip_insert)
     else
         dev->local = image_open(dev, dev->image_path);
 
+    dev->cached_sector  = -1;
+
     if (dev->local == NULL) {
         dev->ops           = NULL;
         dev->image_path[0] = 0;
@@ -2757,7 +2866,7 @@ cdrom_load(cdrom_t *dev, const char *fn, const int skip_insert)
 
         if ((dev->ops->is_empty != NULL) && dev->ops->is_empty(dev->local))
             dev->cd_status      = CD_STATUS_EMPTY;
-        if (dev->ops->is_dvd(dev->local))
+        else if (dev->ops->is_dvd(dev->local))
             dev->cd_status      = CD_STATUS_DVD;
         else
             dev->cd_status      = dev->ops->has_audio(dev->local) ? CD_STATUS_STOPPED :
@@ -2791,6 +2900,9 @@ cdrom_global_init(void)
 {
     /* Clear the global data. */
     memset(cdrom, 0x00, sizeof(cdrom));
+
+    for (uint8_t i = 0; i < CDROM_NUM; i++)
+        cdrom[i].cached_sector = -1;
 }
 
 void
@@ -2802,11 +2914,26 @@ cdrom_hard_reset(void)
         cdrom_t *dev = &cdrom[i];
 
         if (dev->bus_type) {
-             dev->id       = i;
+            dev->id       = i;
 
-            dev->is_early = cdrom_is_early(dev->type);
-            dev->is_nec   = (dev->bus_type == CDROM_BUS_SCSI) &&
-                            !strcmp(cdrom_drive_types[dev->type].vendor, "NEC");
+            const char *vendor = cdrom_drive_types[dev->type].vendor;
+
+            dev->is_early   = cdrom_is_early(dev->type);
+            dev->is_bcd     = !strcmp(vendor, "NEC");
+            dev->is_nec     = (dev->bus_type == CDROM_BUS_SCSI) &&
+                              !strcmp(vendor, "NEC");
+            dev->is_chinon  = !strcmp(vendor, "CHINON");
+            dev->is_pioneer = !strcmp(vendor, "PIONEER");
+            dev->is_plextor = !strcmp(vendor, "PLEXTOR");
+            dev->is_sony    = (dev->bus_type == CDROM_BUS_SCSI) &&
+                              (!strcmp(vendor, "DEC") ||
+                               !strcmp(vendor, "ShinaKen") ||
+                               !strcmp(vendor, "SONY") ||
+                               !strcmp(vendor, "TEXEL"));
+            dev->is_toshiba = !strcmp(vendor, "TOSHIBA");
+
+            dev->c2_first   = !strcmp(vendor, "NEC") ||
+                              !strcmp(vendor, "PLEXTOR");
 
             cdrom_drive_reset(dev);
 
@@ -2827,9 +2954,11 @@ cdrom_hard_reset(void)
                     break;
             }
 
-            dev->cd_status = CD_STATUS_EMPTY;
+            dev->cd_status     = CD_STATUS_EMPTY;
             dev->host_letter = 0xff;
 
+            dev->cached_sector = -1;
+
             if (strlen(dev->image_path) > 0) {
 #ifdef _WIN32
                 if ((strlen(dev->image_path) >= 1) && (dev->image_path[strlen(dev->image_path) - 1] == '/'))
@@ -2893,6 +3022,8 @@ cdrom_exit(const uint8_t id)
 
     strcpy(dev->prev_image_path, dev->image_path);
 
+    dev->cached_sector = -1;
+
     if (dev->ops) {
         cdrom_unload(dev);
 
@@ -2905,6 +3036,20 @@ cdrom_exit(const uint8_t id)
     cdrom_insert(id);
 }
 
+int
+cdrom_is_empty(const uint8_t id)
+{
+    const cdrom_t *dev = &cdrom[id];
+    int            ret = 0;
+
+    /* This entire block should be in cdrom.c/cdrom_eject(dev*) ... */
+    if ((strlen(dev->image_path) == 0) || (dev->cd_status == CD_STATUS_EMPTY))
+        /* Switch from empty to empty. Do nothing. */
+        ret = 1;
+
+    return ret;
+}
+
 /* The mechanics of ejecting a CD-ROM from a drive. */
 void
 cdrom_eject(const uint8_t id)
@@ -2926,7 +3071,9 @@ cdrom_reload(const uint8_t id)
 {
     cdrom_t   *dev       = &cdrom[id];
 
-    if ((strcmp(dev->image_path, dev->prev_image_path) == 0) || (strlen(dev->prev_image_path) == 0) || (strlen(dev->image_path) > 0)) {
+    if ((strcmp(dev->image_path, dev->prev_image_path) == 0) ||
+        (strlen(dev->prev_image_path) == 0) ||
+        (strlen(dev->image_path) > 0)) {
         /* Switch from empty to empty. Do nothing. */
         return;
     }
diff --git a/src/cdrom/cdrom_image.c b/src/cdrom/cdrom_image.c
index 271a290cb..519afaa4c 100644
--- a/src/cdrom/cdrom_image.c
+++ b/src/cdrom/cdrom_image.c
@@ -409,7 +409,7 @@ image_get_track_and_index(const cd_image_t *img, const uint32_t sector,
 
     for (int i = 0; i < img->tracks_num; i++) {
         track_t *ct = &(img->tracks[i]);
-        for (int j = 0; j < 3; j++) {
+        if ((ct->point >= 1) && (ct->point <= 99))  for (int j = 0; j < 3; j++) {
             track_index_t *ci = &(ct->idx[j]);
             if ((ci->type >= INDEX_ZERO) && (ci->length != 0ULL) &&
                 ((sector + 150) >= ci->start) && ((sector + 150) <= (ci->start + ci->length - 1))) {
diff --git a/src/disk/hdc_ide.c b/src/disk/hdc_ide.c
index 125cd806d..61211228a 100644
--- a/src/disk/hdc_ide.c
+++ b/src/disk/hdc_ide.c
@@ -1028,9 +1028,8 @@ ide_atapi_command_bus(ide_t *ide)
 static void
 ide_atapi_callback(ide_t *ide)
 {
-    int out;
-    int ret = 0;
-    ide_bm_t *bm = ide_boards[ide->board]->bm;
+    static int  ret = 0;
+    ide_bm_t   *bm  = ide_boards[ide->board]->bm;
 #ifdef ENABLE_IDE_LOG
     char *phases[7] = { "Idle", "Command", "Data in", "Data out", "Data in DMA", "Data out DMA",
                      "Complete" };
@@ -1056,14 +1055,17 @@ ide_atapi_callback(ide_t *ide)
 
     switch (ide->sc->packet_status) {
         default:
+            ret              = 0;
             break;
 
         case PHASE_IDLE:
+            ret              = 0;
             ide->tf->pos     = 0;
             ide->tf->phase   = 1;
             ide->tf->atastat = READY_STAT | DRQ_STAT | (ide->tf->atastat & ERR_STAT);
             break;
         case PHASE_COMMAND:
+            ret              = 1;
             ide->tf->atastat = BUSY_STAT | (ide->tf->atastat & ERR_STAT);
             if (ide->packet_command) {
                 ide->packet_command(ide->sc, ide->sc->atapi_cdb);
@@ -1073,6 +1075,7 @@ ide_atapi_callback(ide_t *ide)
             break;
         case PHASE_COMPLETE:
         case PHASE_ERROR:
+            ret              = 0;
             ide->tf->atastat = READY_STAT;
             if (ide->sc->packet_status == PHASE_ERROR)
                 ide->tf->atastat       |= ERR_STAT;
@@ -1082,19 +1085,34 @@ ide_atapi_callback(ide_t *ide)
             break;
         case PHASE_DATA_IN:
         case PHASE_DATA_OUT:
+            ret              = 0;
             ide->tf->atastat = READY_STAT | DRQ_STAT | (ide->tf->atastat & ERR_STAT);
             ide->tf->phase   = !(ide->sc->packet_status & 0x01) << 1;
             ide_irq_raise(ide);
             break;
         case PHASE_DATA_IN_DMA:
-        case PHASE_DATA_OUT_DMA:
-            out = (ide->sc->packet_status & 0x01);
-
             if (!IDE_ATAPI_IS_EARLY && !ide_boards[ide->board]->force_ata3 &&
                 (bm != NULL) && bm->dma) {
-                ret = bm->dma(ide->sc->temp_buffer, ide->sc->packet_len, out, bm->priv);
-            }
-            /* Else, DMA command without a bus master, ret = 0 (default). */
+                if (ide->sc->block_len == 0) {
+                    ret = bm->dma(ide->sc->temp_buffer, ide->sc->packet_len, 0, bm->priv);
+
+                    /* Underrun. */
+                    if (ret == 1)
+                        ret = 3;
+                } else {
+                    ret = bm->dma(ide->sc->temp_buffer + ide->sc->buffer_pos -
+                                  ide->sc->block_len, ide->sc->block_len,
+                                  0, bm->priv);
+
+                    if (ret == 1) {
+                        if (ide->sc->sector_len == 0)
+                            ret = 3;
+                        else if (ide->read != NULL)
+                            ide->read(ide->sc);
+                    }
+                }
+            } else
+                ret = 0;
 
             switch (ret) {
                 default:
@@ -1103,18 +1121,73 @@ ide_atapi_callback(ide_t *ide)
                     if (ide->bus_master_error)
                         ide->bus_master_error(ide->sc);
                     break;
-                case 1:
-                    if (out && ide->phase_data_out)
-                        (void) ide->phase_data_out(ide->sc);
-                    else if (!out && ide->command_stop)
-                        ide->command_stop(ide->sc);
+                case 2:
+                    ide_atapi_command_bus(ide);
+                    break;
+                case 3:
+                    /* Reached EOT - terminate the command as there's nothing
+                       more to transfer. */
+                    ide->sc->packet_status = PHASE_COMPLETE;
+                    ide->sc->callback      = 0.0;
 
-                    if ((ide->sc->packet_status == PHASE_COMPLETE) && (ide->sc->callback == 0.0))
+                    if (ide->command_stop != NULL)
+                        ide->command_stop(ide->sc);
+                    fallthrough;
+                case 1:
+                    if ((ide->sc->packet_status == PHASE_COMPLETE) &&
+                        (ide->sc->callback == 0.0))
                         ide_atapi_callback(ide);
                     break;
+            }
+            break;
+        case PHASE_DATA_OUT_DMA:
+            if (!IDE_ATAPI_IS_EARLY && !ide_boards[ide->board]->force_ata3 &&
+                (bm != NULL) && bm->dma) {
+                if (ide->sc->block_len == 0) {
+                    ret = bm->dma(ide->sc->temp_buffer, ide->sc->packet_len, 1, bm->priv);
+
+                    /* Underrun. */
+                    if (ret == 1)
+                        ret = 3;
+                } else {
+                    ret = bm->dma(ide->sc->temp_buffer + ide->sc->buffer_pos,
+                                  ide->sc->block_len, 1, bm->priv);
+
+                    if (ret & 1) {
+                        if (ide->write != NULL)
+                            ide->write(ide->sc);
+
+                        if ((ret == 1) && (ide->sc->sector_len == 0))
+                            ret = 3;
+                    }
+                }
+            } else
+                ret = 0;
+
+            switch (ret) {
+                default:
+                    break;
+                case 0:
+                    if (ide->bus_master_error)
+                        ide->bus_master_error(ide->sc);
+                    break;
                 case 2:
                     ide_atapi_command_bus(ide);
                     break;
+                case 3:
+                    /* Reached EOT - terminate the command as there's nothing
+                       more to transfer. */
+                    ide->sc->packet_status = PHASE_COMPLETE;
+                    ide->sc->callback      = 0.0;
+
+                    if (ide->phase_data_out != NULL)
+                        (void) ide->phase_data_out(ide->sc);
+                    fallthrough;
+                case 1:
+                    if ((ide->sc->packet_status == PHASE_COMPLETE) &&
+                        (ide->sc->callback == 0.0))
+                        ide_atapi_callback(ide);
+                    break;
             }
             break;
     }
@@ -1128,28 +1201,36 @@ ide_atapi_pio_request(ide_t *ide, uint8_t out)
 
     ide_irq_lower(ide);
 
-    ide->tf->atastat = BSY_STAT;
+    ide->tf->atastat   = BSY_STAT;
 
     if (ide->tf->pos >= dev->packet_len) {
         ide_log("%i bytes %s, command done\n", ide->tf->pos, out ? "written" : "read");
 
         ide->tf->pos = dev->request_pos = 0;
-        if (out && ide->phase_data_out)
-            ide->phase_data_out(dev);
-        else if (!out && ide->command_stop)
-            ide->command_stop(dev);
 
-        if ((ide->sc->packet_status == PHASE_COMPLETE) && (ide->sc->callback == 0.0))
-            ide_atapi_callback(ide);
+        if (dev->block_len == 0) {
+            if (out && (ide->phase_data_out != NULL))
+                ide->phase_data_out(dev);
+            else if (!out && (ide->command_stop != NULL))
+                ide->command_stop(dev);
+
+            if ((ide->sc->packet_status == PHASE_COMPLETE) && (ide->sc->callback == 0.0))
+                ide_atapi_callback(ide);
+        }
     } else {
         ide_log("%i bytes %s, %i bytes are still left\n", ide->tf->pos,
                 out ? "written" : "read", dev->packet_len - ide->tf->pos);
 
-        /* If less than (packet length) bytes are remaining, update packet length
-           accordingly. */
+        /*
+           If less than (packet length) bytes are remaining, update packet length
+           accordingly.
+         */
         if ((dev->packet_len - ide->tf->pos) < (dev->max_transfer_len)) {
             dev->max_transfer_len = dev->packet_len - ide->tf->pos;
-            /* Also update the request length so the host knows how many bytes to transfer. */
+            /*
+               Also update the request length so the host knows how many bytes to
+               transfer.
+             */
             ide->tf->request_length = dev->max_transfer_len;
         }
         ide_log("CD-ROM %i: Packet length %i, request length %i\n", dev->id, dev->packet_len,
@@ -1157,12 +1238,40 @@ ide_atapi_pio_request(ide_t *ide, uint8_t out)
 
         dev->packet_status = PHASE_DATA_IN | out;
 
-        ide->tf->atastat = BSY_STAT;
-        ide->tf->phase  = 1;
-        ide_atapi_callback(ide);
-        ide_set_callback(ide, 0.0);
+        if (dev->block_len == 0) {
+            ide_atapi_callback(ide);
+            ide_set_callback(ide, 0.0);
+        }
 
-        dev->request_pos = 0;
+        dev->request_pos  = 0;
+    }
+
+    if (dev->block_len != 0) {
+        if (out) {
+            if (ide->write != NULL)
+                ide->write(dev);
+
+            if (dev->sector_len == 0) {
+                ide->sc->packet_status = PHASE_COMPLETE;
+                ide->sc->callback      = 0.0;
+
+                if (ide->phase_data_out != NULL)
+                    (void) ide->phase_data_out(dev);
+
+                ide_atapi_callback(ide);
+            }
+        } else {
+            if (dev->sector_len == 0) {
+                if (ide->command_stop != NULL)
+                    ide->command_stop(dev);
+
+                ide->sc->packet_status = PHASE_COMPLETE;
+                ide->sc->callback      = 0.0;
+
+                ide_atapi_callback(ide);
+            } else if (ide->read != NULL)
+                ide->read(dev);
+        }
     }
 }
 
@@ -1179,16 +1288,19 @@ ide_atapi_packet_read(ide_t *ide)
 
         bufferw = (uint16_t *) dev->temp_buffer;
 
-        /* Make sure we return a 0 and don't attempt to read from the buffer if
+        /*
+           Make sure we return a 0 and don't attempt to read from the buffer if
            we're transferring bytes beyond it, which can happen when issuing media
            access commands with an allocated length below minimum request length
-           (which is 1 sector = 2048 bytes). */
+           (which is 1 sector = 2048 bytes).
+         */
         ret = (ide->tf->pos < dev->packet_len) ? bufferw[ide->tf->pos >> 1] : 0;
         ide->tf->pos += 2;
 
         dev->request_pos += 2;
 
-        if ((dev->request_pos >= dev->max_transfer_len) || (ide->tf->pos >= dev->packet_len)) {
+        if ((dev->request_pos >= dev->max_transfer_len) ||
+            (ide->tf->pos >= dev->packet_len)) {
             /* Time for a DRQ. */
             ide_atapi_pio_request(ide, 0);
         }
@@ -1221,7 +1333,8 @@ ide_atapi_packet_write(ide_t *ide, const uint16_t val)
         dev->request_pos += 2;
 
         if (dev->packet_status == PHASE_DATA_OUT) {
-            if ((dev->request_pos >= dev->max_transfer_len) || (ide->tf->pos >= dev->packet_len)) {
+            if ((dev->request_pos >= dev->max_transfer_len) ||
+                (ide->tf->pos >= dev->packet_len)) {
                 /* Time for a DRQ. */
                 ide_atapi_pio_request(ide, 1);
             }
@@ -1287,7 +1400,7 @@ ide_writew(uint16_t addr, uint16_t val, void *priv)
     ide = ide_drives[ch];
 
 #if defined(ENABLE_IDE_LOG) && (ENABLE_IDE_LOG == 2)
-    ide_log("ide_writew(%04X, %04X, %08X)\n", addr, val, priv);
+    ide_log("[%04X:%08X] ide_writew(%04X, %04X, %08X)\n", CS, cpu_state.pc, addr, val, priv);
 #endif
 
     addr &= 0x7;
@@ -1321,7 +1434,7 @@ ide_writel(uint16_t addr, uint32_t val, void *priv)
     ide = ide_drives[ch];
 
 #if defined(ENABLE_IDE_LOG) && (ENABLE_IDE_LOG == 2)
-    ide_log("ide_writel(%04X, %08X, %08X)\n", addr, val, priv);
+    ide_log("[%04X:%08X] ide_writel(%04X, %08X, %08X)\n", CS, cpu_state.pc, addr, val, priv);
 #endif
 
     addr &= 0x7;
@@ -1371,9 +1484,9 @@ ide_write_devctl(UNUSED(uint16_t addr), uint8_t val, void *priv)
     ide       = ide_drives[ch];
     ide_other = ide_drives[ch ^ 1];
 
-    ide_log("ide_write_devctl(%04X, %02X, %08X)\n", addr, val, priv);
+    ide_log("[%04X:%08X] ide_write_devctl(%04X, %02X, %08X)\n", CS, cpu_state.pc, addr, val, priv);
 
-    if ((ide->type == IDE_NONE) && (ide_other->type == IDE_NONE))
+    if ((addr & 0x0001) || ((ide->type == IDE_NONE) && (ide_other->type == IDE_NONE)))
         return;
 
     dev->diag = 0;
@@ -1481,7 +1594,7 @@ ide_writeb(uint16_t addr, uint8_t val, void *priv)
     ide       = ide_drives[ch];
     ide_other = ide_drives[ch ^ 1];
 
-    ide_log("ide_writeb(%04X, %02X, %08X)\n", addr, val, priv);
+    ide_log("[%04X:%08X] ide_writeb(%04X, %02X, %08X)\n", CS, cpu_state.pc, addr, val, priv);
 
     addr &= 0x7;
 
@@ -1831,7 +1944,7 @@ ide_read_data(ide_t *ide)
     const uint16_t *idebufferw = ide->buffer;
     uint16_t ret = 0x0000;
 
-#if defined(ENABLE_IDE_LOG) && (ENABLE_IDE_LOG == 2)
+#if defined(ENABLE_IDE_LOG) && (ENABLE_IDE_LOG == 3)
     ide_log("ide_read_data(): ch = %i, board = %i, type = %i\n", ide->channel,
             ide->board, ide->type);
 #endif
@@ -2010,7 +2123,7 @@ ide_readb(uint16_t addr, void *priv)
             break;
     }
 
-    ide_log("ide_readb(%04X, %08X) = %02X\n", addr, priv, ret);
+    ide_log("[%04X:%08X] ide_readb(%04X, %08X) = %02X\n", CS, cpu_state.pc, addr, priv, ret);
 
     return ret;
 }
@@ -2022,12 +2135,14 @@ ide_read_alt_status(UNUSED(const uint16_t addr), void *priv)
 
     const int     ch  = dev->cur_dev;
     ide_t *       ide = ide_drives[ch];
+    uint8_t       ret = 0xff;
 
     /* Per the Seagate ATA-3 specification:
        Reading the alternate status does *NOT* clear the IRQ. */
-    const uint8_t ret = ide_status(ide, ide_drives[ch ^ 1], ch);
+    if (!(addr & 0x0001))
+        ret = ide_status(ide, ide_drives[ch ^ 1], ch);
 
-    ide_log("ide_read_alt_status(%04X, %08X) = %02X\n", addr, priv, ret);
+    ide_log("[%04X:%08X] ide_read_alt_status(%04X, %08X) = %02X\n", CS, cpu_state.pc, addr, priv, ret);
 
     return ret;
 }
@@ -2053,7 +2168,7 @@ ide_readw(uint16_t addr, void *priv)
     }
 
 #if defined(ENABLE_IDE_LOG) && (ENABLE_IDE_LOG == 2)
-    ide_log("ide_readw(%04X, %08X) = %04X\n", addr, priv, ret);
+    ide_log("[%04X:%08X] ide_readw(%04X, %08X) = %04X\n", CS, cpu_state.pc, addr, priv, ret);
 #endif
     return ret;
 }
@@ -2084,7 +2199,7 @@ ide_readl(uint16_t addr, void *priv)
     }
 
 #if defined(ENABLE_IDE_LOG) && (ENABLE_IDE_LOG == 2)
-    ide_log("ide_readl(%04X, %08X) = %04X\n", addr, priv, ret);
+    ide_log("[%04X:%08X] ide_readl(%04X, %08X) = %04X\n", CS, cpu_state.pc, addr, priv, ret);
 #endif
     return ret;
 }
@@ -2270,7 +2385,7 @@ ide_callback(void *priv)
                         ide->tf->atastat = DRQ_STAT | DRDY_STAT | DSC_STAT;
                         ide_set_callback(ide, 6.0 * IDE_TIME);
                         return;
-                    } else if (ret == 1) {
+                    } else if (ret & 1) {
                         /* DMA successful */
                         ide_log("IDE %i: DMA read successful\n", ide->channel);
 
@@ -2379,7 +2494,7 @@ ide_callback(void *priv)
                         ide->tf->atastat = DRQ_STAT | DRDY_STAT | DSC_STAT;
                         ide_set_callback(ide, 6.0 * IDE_TIME);
                         return;
-                    } else if (ret == 1) {
+                    } else if (ret & 1) {
                         /* DMA successful */
                         ret = hdd_image_write(ide->hdd_num, ide_get_sector(ide),
                                               ide->sector_pos, ide->sector_buffer);
@@ -2637,7 +2752,7 @@ ide_handlers(uint8_t board, int set)
         }
 
         if (ide_boards[board]->base[1]) {
-            io_handler(set, ide_boards[board]->base[1], 1,
+            io_handler(set, ide_boards[board]->base[1], 2,
                        ide_read_alt_status, NULL, NULL,
                        ide_write_devctl, NULL, NULL,
                        ide_boards[board]);
diff --git a/src/disk/hdc_ide_sff8038i.c b/src/disk/hdc_ide_sff8038i.c
index 73dc5f36b..2cc1fe72e 100644
--- a/src/disk/hdc_ide_sff8038i.c
+++ b/src/disk/hdc_ide_sff8038i.c
@@ -375,7 +375,7 @@ sff_bus_master_dma(uint8_t *data, int transfer_length, int out, void *priv)
             } else if (dev->eot) {
                 sff_log("Regular EOT\n");
                 dev->status &= ~3;
-                return 1; /* We have regularly reached EOT - clear status and break. */
+                return 3; /* We have regularly reached EOT - clear status and break. */
             } else {
                 /* We have more to transfer and there are blocks left, get next block. */
                 sff_bus_master_next_addr(dev);
diff --git a/src/floppy/fdd_86f.c b/src/floppy/fdd_86f.c
index 140e87899..f5626e35b 100644
--- a/src/floppy/fdd_86f.c
+++ b/src/floppy/fdd_86f.c
@@ -28,6 +28,7 @@
 #define HAVE_STDARG_H
 #include <86box/86box.h>
 #include <86box/timer.h>
+#include <86box/crc.h>
 #include <86box/dma.h>
 #include <86box/nvr.h>
 #include <86box/random.h>
@@ -223,6 +224,7 @@ typedef struct d86f_t {
     uint8_t    *filebuf;
     uint8_t    *outbuf;
     sector_t   *last_side_sector[2];
+    uint16_t    crc_table[256];
 } d86f_t;
 
 static const uint8_t encoded_fm[64] = {
@@ -247,7 +249,6 @@ static const uint8_t encoded_mfm[64] = {
 };
 
 static d86f_t  *d86f[FDD_NUM];
-static uint16_t CRCTable[256];
 static fdc_t   *d86f_fdc;
 uint64_t        poly = 0x42F0E1EBA9EA3693LL; /* ECMA normal */
 
@@ -276,28 +277,6 @@ d86f_log(const char *fmt, ...)
 #    define d86f_log(fmt, ...)
 #endif
 
-static void
-setup_crc(uint16_t poly)
-{
-    int      c = 256;
-    int      bc;
-    uint16_t temp;
-
-    while (c--) {
-        temp = c << 8;
-        bc   = 8;
-
-        while (bc--) {
-            if (temp & 0x8000)
-                temp = (temp << 1) ^ poly;
-            else
-                temp <<= 1;
-
-            CRCTable[c] = temp;
-        }
-    }
-}
-
 void
 d86f_destroy_linked_lists(int drive, int side)
 {
@@ -1237,16 +1216,10 @@ decodefm(UNUSED(int drive), uint16_t dat)
     return temp;
 }
 
-void
-fdd_calccrc(uint8_t byte, crc_t *crc_var)
-{
-    crc_var->word = (crc_var->word << 8) ^ CRCTable[(crc_var->word >> 8) ^ byte];
-}
-
 static void
 d86f_calccrc(d86f_t *dev, uint8_t byte)
 {
-    fdd_calccrc(byte, &(dev->calc_crc));
+    crc16_calc(dev->crc_table, byte, &(dev->calc_crc));
 }
 
 int
@@ -1274,7 +1247,9 @@ d86f_word_is_aligned(int drive, int side, uint32_t base_pos)
 
 /* State 1: Find sector ID */
 void
-d86f_find_address_mark_fm(int drive, int side, find_t *find, uint16_t req_am, uint16_t other_am, uint16_t wrong_am, uint16_t ignore_other_am)
+d86f_find_address_mark_fm(int drive, int side, find_t *find, uint16_t req_am,
+                          uint16_t other_am, uint16_t wrong_am,
+                          uint16_t ignore_other_am)
 {
     d86f_t *dev = d86f[drive];
 
@@ -1282,7 +1257,8 @@ d86f_find_address_mark_fm(int drive, int side, find_t *find, uint16_t req_am, ui
 
     if (dev->last_word[side] == req_am) {
         dev->calc_crc.word = 0xFFFF;
-        fdd_calccrc(decodefm(drive, dev->last_word[side]), &(dev->calc_crc));
+        crc16_calc(dev->crc_table, decodefm(drive, dev->last_word[side]),
+                   &(dev->calc_crc));
         find->sync_marks = find->bits_obtained =
         find->bytes_obtained                   = 0;
         find->sync_pos                         = 0xFFFFFFFF;
@@ -1302,7 +1278,8 @@ d86f_find_address_mark_fm(int drive, int side, find_t *find, uint16_t req_am, ui
 
     if ((ignore_other_am & 2) && (dev->last_word[side] == other_am)) {
         dev->calc_crc.word = 0xFFFF;
-        fdd_calccrc(decodefm(drive, dev->last_word[side]), &(dev->calc_crc));
+        crc16_calc(dev->crc_table, decodefm(drive, dev->last_word[side]),
+                   &(dev->calc_crc));
         find->sync_marks = find->bits_obtained = find->bytes_obtained = 0;
         find->sync_pos                                                = 0xFFFFFFFF;
         if (ignore_other_am & 1) {
@@ -1378,7 +1355,8 @@ d86f_find_address_mark_mfm(int drive, int side, find_t *find, uint16_t req_am, u
     if ((dev->last_word[side] == req_am) && (find->sync_marks >= 3)) {
         if (d86f_word_is_aligned(drive, side, find->sync_pos)) {
             dev->calc_crc.word = 0xCDB4;
-            fdd_calccrc(decodefm(drive, dev->last_word[side]), &(dev->calc_crc));
+            crc16_calc(dev->crc_table, decodefm(drive, dev->last_word[side]),
+                       &(dev->calc_crc));
             find->sync_marks = find->bits_obtained = find->bytes_obtained = 0;
             find->sync_pos                                                = 0xFFFFFFFF;
             dev->preceding_bit[side]                                      = dev->last_word[side] & 1;
@@ -1390,7 +1368,8 @@ d86f_find_address_mark_mfm(int drive, int side, find_t *find, uint16_t req_am, u
     if ((ignore_other_am & 2) && (dev->last_word[side] == other_am) && (find->sync_marks >= 3)) {
         if (d86f_word_is_aligned(drive, side, find->sync_pos)) {
             dev->calc_crc.word = 0xCDB4;
-            fdd_calccrc(decodefm(drive, dev->last_word[side]), &(dev->calc_crc));
+            crc16_calc(dev->crc_table, decodefm(drive, dev->last_word[side]),
+                       &(dev->calc_crc));
             find->sync_marks = find->bits_obtained = find->bytes_obtained = 0;
             find->sync_pos                                                = 0xFFFFFFFF;
             if (ignore_other_am & 1) {
@@ -1464,8 +1443,11 @@ d86f_read_sector_id(int drive, int side, int match)
             if (dev->id_find.bytes_obtained < 4) {
                 dev->last_sector.byte_array[dev->id_find.bytes_obtained] =
                 decodefm(drive, dev->last_word[side]);
-                fdd_calccrc(dev->last_sector.byte_array[dev->id_find.bytes_obtained], &(dev->calc_crc));
-            } else if ((dev->id_find.bytes_obtained >= 4) && (dev->id_find.bytes_obtained < 6)) {
+                crc16_calc(dev->crc_table,
+                           dev->last_sector.byte_array[dev->id_find.bytes_obtained],
+                           &(dev->calc_crc));
+            } else if ((dev->id_find.bytes_obtained >= 4) &&
+                       (dev->id_find.bytes_obtained < 6)) {
                 dev->track_crc.bytes[(dev->id_find.bytes_obtained & 1) ^ 1] =
                 decodefm(drive, dev->last_word[side]);
             }
@@ -1643,7 +1625,7 @@ d86f_read_sector_data(int drive, int side)
                         }
                     }
                 }
-                fdd_calccrc(data, &(dev->calc_crc));
+                crc16_calc(dev->crc_table, data, &(dev->calc_crc));
             } else if (dev->data_find.bytes_obtained < crc_pos)
                 dev->track_crc.bytes[(dev->data_find.bytes_obtained - sector_len) ^ 1] =
                 decodefm(drive, dev->last_word[side]);
@@ -1730,11 +1712,12 @@ d86f_write_sector_data(int drive, int side, int mfm, uint16_t am)
 
             if (dev->data_find.bytes_obtained < sector_len) {
                 /* This is a data byte, so CRC it. */
-                if (!dev->data_find.bytes_obtained) {
-                    fdd_calccrc(decodefm(drive, am), &(dev->calc_crc));
-                } else {
-                    fdd_calccrc(dev->current_byte[side], &(dev->calc_crc));
-                }
+                if (!dev->data_find.bytes_obtained)
+                    crc16_calc(dev->crc_table, decodefm(drive, am),
+                               &(dev->calc_crc));
+                else
+                    crc16_calc(dev->crc_table, dev->current_byte[side],
+                               &(dev->calc_crc));
             }
         }
     } else {
@@ -3861,8 +3844,6 @@ d86f_load(int drive, char *fn)
 void
 d86f_init(void)
 {
-    setup_crc(0x1021);
-
     for (uint8_t i = 0; i < FDD_NUM; i++)
         d86f[i] = NULL;
 }
@@ -3926,6 +3907,8 @@ d86f_setup(int drive)
     dev->last_side_sector[0] = NULL;
     dev->last_side_sector[1] = NULL;
 
+    crc16_setup(dev->crc_table, 0x1021);
+
     /* Set the drive as active. */
     d86f[drive] = dev;
 }
diff --git a/src/include/86box/cdrom.h b/src/include/86box/cdrom.h
index 805f08b10..30c6476fb 100644
--- a/src/include/86box/cdrom.h
+++ b/src/include/86box/cdrom.h
@@ -28,8 +28,9 @@
 #define CD_STATUS_PLAYING           5
 #define CD_STATUS_STOPPED           6
 #define CD_STATUS_PLAYING_COMPLETED 7
-#define CD_STATUS_HAS_AUDIO         4
-#define CD_STATUS_MASK              7
+#define CD_STATUS_HOLD              8
+#define CD_STATUS_HAS_AUDIO         0xc
+#define CD_STATUS_MASK              0xf
 
 /* Medium changed flag. */
 #define CD_STATUS_TRANSITION     0x40
@@ -50,8 +51,6 @@
 
 #define CD_IMAGE_HISTORY         10
 
-#define BUF_SIZE                 32768
-
 #define CDROM_IMAGE              200
 
 /* This is so that if/when this is changed to something else,
@@ -63,6 +62,8 @@
 #define RAW_SECTOR_SIZE          2352
 #define COOKED_SECTOR_SIZE       2048
 
+#define CD_BUF_SIZE              (16 * RAW_SECTOR_SIZE)
+
 #define DATA_TRACK               0x14
 #define AUDIO_TRACK              0x10
 
@@ -105,9 +106,9 @@ enum {
 #define CDV                         EMU_VERSION_EX
 
 static const struct cdrom_drive_types_s {
-    const char    vendor[9];
-    const char    model[17];
-    const char    revision[5];
+    const char *  vendor;
+    const char *  model;
+    const char *  revision;
     const char *  internal_name;
     const int     bus_type;
     /* SCSI standard for SCSI (or both) devices, early for IDE. */
@@ -298,9 +299,7 @@ typedef struct cdrom {
     void *             priv;
 
     char               image_path[1024];
-    char               prev_image_path[1024];
-
-    char *             image_history[CD_IMAGE_HISTORY];
+    char               prev_image_path[1280];
 
     uint32_t           sound_on;
     uint32_t           cdrom_capacity;
@@ -310,18 +309,21 @@ typedef struct cdrom {
     uint32_t           type;
     uint32_t           sector_size;
 
-    int                cd_buflen;
-    int                audio_op;
-    int                audio_muted_soft;
-    int                sony_msf;
-    int                real_speed;
-    int                is_early;
-    int                is_nec;
-
     uint32_t           inv_field;
+    int32_t            cached_sector;
+    int32_t            cd_buflen;
+    int32_t            sony_msf;
+    int32_t            real_speed;
+    int32_t            is_early;
+    int32_t            is_nec;
+    int32_t            is_bcd;
+
+    int32_t            cdrom_sector_size;
 
     const cdrom_ops_t *ops;
 
+    char *             image_history[CD_IMAGE_HISTORY];
+
     void *             local;
     void *             log;
 
@@ -330,24 +332,29 @@ typedef struct cdrom {
     uint32_t           (*get_volume)(void *p, int channel);
     uint32_t           (*get_channel)(void *p, int channel);
 
-    int16_t            cd_buffer[BUF_SIZE];
+    int16_t            cd_buffer[CD_BUF_SIZE];
 
     uint8_t            subch_buffer[96];
 
-    int                cdrom_sector_size;
+    /* Needs some extra breathing space in case of overflows. */
+    uint8_t            raw_buffer[2][4096];
+    uint8_t            extra_buffer[296];
+
+    int32_t            is_chinon;
+    int32_t            is_pioneer;
+    int32_t            is_plextor;
+    int32_t            is_sony;
+    int32_t            is_toshiba;
+
+    int32_t            c2_first;
+    int32_t            cur_buf;
+
     /* Only used on Windows hosts for disc change notifications. */
     uint8_t            host_letter;
-
-    /* Needs some extra breathing space in case of overflows. */
-    uint8_t            raw_buffer[4096];
-    uint8_t            extra_buffer[296];
 } cdrom_t;
 
 extern cdrom_t cdrom[CDROM_NUM];
 
-/* The addresses sent from the guest are absolute, ie. a LBA of 0 corresponds to a MSF of 00:00:00. Otherwise, the counter displayed by the guest is wrong:
-   there is a seeming 2 seconds in which audio plays but counter does not move, while a data track before audio jumps to 2 seconds before the actual start
-   of the audio while audio still plays. With an absolute conversion, the counter is fine. */
 #define MSFtoLBA(m, s, f)  ((((m * 60) + s) * 75) + f)
 
 static __inline int
@@ -368,8 +375,6 @@ extern char           *cdrom_get_revision(const int type);
 extern int             cdrom_get_scsi_std(const int type);
 extern int             cdrom_is_early(const int type);
 extern int             cdrom_is_generic(const int type);
-extern int             cdrom_has_date(const int type);
-extern int             cdrom_is_sony(const int type);
 extern int             cdrom_is_caddy(const int type);
 extern int             cdrom_get_speed(const int type);
 extern int             cdrom_get_inquiry_len(const int type);
@@ -386,6 +391,7 @@ extern void            cdrom_set_type(const int model, const int type);
 extern int             cdrom_get_type(const int model);
 
 extern int             cdrom_lba_to_msf_accurate(const int lba);
+extern void            cdrom_interleave_subch(uint8_t *d, const uint8_t *s);
 extern double          cdrom_seek_time(const cdrom_t *dev);
 extern void            cdrom_stop(cdrom_t *dev);
 extern void            cdrom_seek(cdrom_t *dev, const uint32_t pos, const uint8_t vendor_type);
@@ -398,7 +404,7 @@ extern uint8_t         cdrom_audio_track_search(cdrom_t *dev, const uint32_t pos
 extern uint8_t         cdrom_audio_track_search_pioneer(cdrom_t *dev, const uint32_t pos, const uint8_t playbit);
 extern uint8_t         cdrom_audio_play_pioneer(cdrom_t *dev, const uint32_t pos);
 extern uint8_t         cdrom_audio_play_toshiba(cdrom_t *dev, const uint32_t pos, const int type);
-extern uint8_t         cdrom_audio_scan(cdrom_t *dev, const uint32_t pos, const int type);
+extern uint8_t         cdrom_audio_scan(cdrom_t *dev, const uint32_t pos);
 extern void            cdrom_audio_pause_resume(cdrom_t *dev, const uint8_t resume);
 
 extern uint8_t         cdrom_get_current_status(const cdrom_t *dev);
@@ -426,6 +432,7 @@ extern int             cdrom_read_dvd_structure(const cdrom_t *dev, const uint8_
                                                 uint8_t *buffer, uint32_t *info);
 extern void            cdrom_read_disc_information(const cdrom_t *dev, uint8_t *buffer);
 extern int             cdrom_read_track_information(cdrom_t *dev, const uint8_t *cdb, uint8_t *buffer);
+extern uint8_t         cdrom_get_current_mode(cdrom_t *dev);
 extern void            cdrom_set_empty(cdrom_t *dev);
 extern void            cdrom_update_status(cdrom_t *dev);
 extern int             cdrom_load(cdrom_t *dev, const char *fn, const int skip_insert);
diff --git a/src/include/86box/crc.h b/src/include/86box/crc.h
new file mode 100644
index 000000000..1a6e76dab
--- /dev/null
+++ b/src/include/86box/crc.h
@@ -0,0 +1,34 @@
+/*
+ * 86Box    A hypervisor and IBM PC system emulator that specializes in
+ *          running old operating systems and software designed for IBM
+ *          PC systems and compatibles from 1981 through fairly recent
+ *          system designs based on the PCI bus.
+ *
+ *          This file is part of the 86Box distribution.
+ *
+ *          Definitions for the CRC code.
+ *
+ * Authors: Miran Grca, <mgrca8@gmail.com>
+ *
+ *          Copyright 2016-2025 Miran Grca.
+ */
+#ifndef EMU_CRC_H
+#define EMU_CRC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef union {
+    uint16_t word;
+    uint8_t  bytes[2];
+} crc_t;
+
+extern void crc16_setup(uint16_t *crc_table, uint16_t poly);
+extern void crc16_calc(uint16_t *crc_table, uint8_t byte, crc_t *crc_var);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*EMU_CRC_H*/
diff --git a/src/include/86box/fdd.h b/src/include/86box/fdd.h
index ff9315f1d..d6ade3bc6 100644
--- a/src/include/86box/fdd.h
+++ b/src/include/86box/fdd.h
@@ -8,15 +8,13 @@
  *
  *          Definitions for the floppy drive emulation.
  *
- *
- *
  * Authors: Sarah Walker, <https://pcem-emulator.co.uk/>
  *          Miran Grca, <mgrca8@gmail.com>
  *          Fred N. van Kempen, <decwiz@yahoo.com>
  *
- *          Copyright 2008-2018 Sarah Walker.
- *          Copyright 2016-2018 Miran Grca.
- *          Copyright 2018 Fred N. van Kempen.
+ *          Copyright 2008-2025 Sarah Walker.
+ *          Copyright 2016-2025 Miran Grca.
+ *          Copyright 2018-2025 Fred N. van Kempen.
  */
 #ifndef EMU_FDD_H
 #define EMU_FDD_H
@@ -129,13 +127,6 @@ extern int drive_empty[FDD_NUM];
 #define SECTOR_FIRST -2
 #define SECTOR_NEXT  -1
 
-typedef union {
-    uint16_t word;
-    uint8_t  bytes[2];
-} crc_t;
-
-void fdd_calccrc(uint8_t byte, crc_t *crc_var);
-
 typedef struct d86f_handler_t {
     uint16_t (*disk_flags)(int drive);
     uint16_t (*side_flags)(int drive);
diff --git a/src/include/86box/hdc_ide.h b/src/include/86box/hdc_ide.h
index 6af4d92e6..4e4ea4e5b 100644
--- a/src/include/86box/hdc_ide.h
+++ b/src/include/86box/hdc_ide.h
@@ -133,6 +133,8 @@ typedef struct ide_s {
     uint8_t (*phase_data_out)(scsi_common_t *sc);
     void    (*command_stop)(scsi_common_t *sc);
     void    (*bus_master_error)(scsi_common_t *sc);
+    void    (*read)(scsi_common_t *sc);
+    void    (*write)(scsi_common_t *sc);
 #else
     void *  get_max;
     void *  get_timings;
diff --git a/src/include/86box/hdd.h b/src/include/86box/hdd.h
index b80c21c13..eda4396ef 100644
--- a/src/include/86box/hdd.h
+++ b/src/include/86box/hdd.h
@@ -138,55 +138,63 @@ typedef struct hdd_zone_t {
 
 /* Define the virtual Hard Disk. */
 typedef struct hard_disk_t {
-    uint8_t id;
+    uint8_t           id;
+
     union {
-        uint8_t channel; /* Needed for Settings to reduce the number of if's */
+        /* Needed for Settings to reduce the number of if's */
+        uint8_t           channel;
 
-        uint8_t mfm_channel; /* Should rename and/or unionize */
-        uint8_t esdi_channel;
-        uint8_t xta_channel;
-        uint8_t ide_channel;
-        uint8_t scsi_id;
+        uint8_t           mfm_channel;
+        uint8_t           esdi_channel;
+        uint8_t           xta_channel;
+        uint8_t           ide_channel;
+        uint8_t           scsi_id;
     };
-    uint8_t bus_type;
-    uint8_t bus_mode;  /* Bit 0 = PIO suported;
-                          Bit 1 = DMA supportd. */
-    uint8_t wp; /* Disk has been mounted READ-ONLY */
-    uint8_t pad;
-    uint8_t pad0;
 
-    void *priv;
+    uint8_t            bus_type;
+    uint8_t            bus_mode;     /* Bit 0 = PIO suported;
+                                        Bit 1 = DMA supportd. */
+    uint8_t            wp;           /* Disk has been mounted
+                                        READ-ONLY */
+    uint8_t            pad;
+    uint8_t            pad0;
 
-    char fn[1024];         /* Name of current image file */
-    char vhd_parent[1041]; /* Differential VHD parent file */
+    void *             priv;
 
-    uint32_t seek_pos;
-    uint32_t seek_len;
-    uint32_t base;
-    uint32_t spt;
-    uint32_t hpc; /* Physical geometry parameters */
-    uint32_t tracks;
-    const char *model;
+    char               fn[1024];     /* Name of current image file */
+    /* Differential VHD parent file */
+    char               vhd_parent[1280];
 
-    hdd_zone_t  zones[HDD_MAX_ZONES];
-    uint32_t    num_zones;
-    hdd_cache_t cache;
-    uint32_t    phy_cyl;
-    uint32_t    phy_heads;
-    uint32_t    rpm;
-    uint8_t     max_multiple_block;
+    uint32_t           seek_pos;
+    uint32_t           seek_len;
+    uint32_t           base;
+    uint32_t           spt;          /* Physical geometry parameters */
+    uint32_t           hpc;
+    uint32_t           tracks;
+    uint32_t           speed_preset;
 
-    uint32_t cur_cylinder;
-    uint32_t cur_track;
-    uint32_t cur_addr;
+    uint32_t           num_zones;
+    uint32_t           phy_cyl;
+    uint32_t           phy_heads;
+    uint32_t           rpm;
+    uint32_t           cur_cylinder;
+    uint32_t           cur_track;
+    uint32_t           cur_addr;
+    uint32_t           vhd_blocksize;
 
-    uint32_t speed_preset;
-    uint32_t vhd_blocksize;
+    uint8_t            max_multiple_block;
+    uint8_t            pad1[3];
 
-    double avg_rotation_lat_usec;
-    double full_stroke_usec;
-    double head_switch_usec;
-    double cyl_switch_usec;
+    const char *       model;
+
+    hdd_zone_t         zones[HDD_MAX_ZONES];
+
+    hdd_cache_t        cache;
+
+    double             avg_rotation_lat_usec;
+    double             full_stroke_usec;
+    double             head_switch_usec;
+    double             cyl_switch_usec;
 } hard_disk_t;
 
 extern hard_disk_t  hdd[HDD_NUM];
diff --git a/src/include/86box/mo.h b/src/include/86box/mo.h
index 1df16c3fe..e09515b10 100644
--- a/src/include/86box/mo.h
+++ b/src/include/86box/mo.h
@@ -51,10 +51,10 @@ static const mo_type_t mo_types[KNOWN_MO_TYPES] = {
 };
 
 typedef struct mo_drive_type_t {
-    const char vendor[9];
-    const char model[16];
-    const char revision[5];
-    int8_t     supported_media[KNOWN_MO_TYPES];
+    const char *vendor;
+    const char *model;
+    const char *revision;
+    int8_t      supported_media[KNOWN_MO_TYPES];
 } mo_drive_type_t;
 
 #define KNOWN_MO_DRIVE_TYPES 22
@@ -161,6 +161,7 @@ typedef struct mo_t {
     uint32_t           sector_pos;
     uint32_t           sector_len;
     uint32_t           packet_len;
+    uint32_t           block_len;
 
     double             callback;
 
diff --git a/src/include/86box/scsi_cdrom.h b/src/include/86box/scsi_cdrom.h
index bc2d4c8bd..7bb39d9db 100644
--- a/src/include/86box/scsi_cdrom.h
+++ b/src/include/86box/scsi_cdrom.h
@@ -54,18 +54,24 @@ typedef struct scsi_cdrom_t {
     int                do_page_save;
     int                unit_attention;
     int                request_pos;
-    int                old_len;
-    int                media_status;
+    int                wait;
+    int                buffer_pos;
 
     uint32_t           sector_pos;
     uint32_t           sector_len;
     uint32_t           packet_len;
+    uint32_t           block_len;
 
     double             callback;
 
-    int                is_sony;
-    int                use_cdb_9;
+    uint8_t            (*ven_cmd)(void *sc, const uint8_t *cdb, int32_t *BufLen);
 
+    int                use_cdb_9;
+    int                was_cached;
+    int                toc_cached;
+    int                media_access;
+
+    uint8_t            vendor_type;
     uint8_t            ven_cmd_is_data[256];
 
     mode_sense_pages_t ms_drive_status_pages_saved;
@@ -74,8 +80,6 @@ typedef struct scsi_cdrom_t {
 
     mode_sense_pages_t ms_pages_default;
     mode_sense_pages_t ms_pages_changeable;
-
-    uint8_t            (*ven_cmd)(void *sc, const uint8_t *cdb, int32_t *BufLen);
 } scsi_cdrom_t;
 #endif
 
diff --git a/src/include/86box/scsi_device.h b/src/include/86box/scsi_device.h
index ffe042481..62da8b7dc 100644
--- a/src/include/86box/scsi_device.h
+++ b/src/include/86box/scsi_device.h
@@ -110,39 +110,40 @@
 #define GPCMD_MECHANISM_STATUS                        0xbd
 #define GPCMD_READ_CD                                 0xbe
 #define GPCMD_SEND_DVD_STRUCTURE                      0xbf /* This is for writing only, irrelevant to 86Box. */
-#define GPCMD_EJECT_CHINON                            0xc0 /* Chinon Vendor Unique command */
 #define GPCMD_AUDIO_TRACK_SEARCH_TOSHIBA              0xc0 /* Toshiba Vendor Unique command */
-#define GPCMD_SET_ADDRESS_FORMAT_SONY                 0xc0 /* Sony Vendor Unique command */
+#define GPCMD_EJECT_CHINON                            0xc0 /* Chinon Vendor Unique command */
 #define GPCMD_MAGAZINE_EJECT_PIONEER                  0xc0 /* Pioneer Vendor Unique command */
+#define GPCMD_SET_ADDRESS_FORMAT_SONY                 0xc0 /* Sony Vendor Unique command */
 #define GPCMD_PLAY_AUDIO_TOSHIBA                      0xc1 /* Toshiba Vendor Unique command */
-#define GPCMD_READ_TOC_SONY                           0xc1 /* Sony Vendor Unique command */
 #define GPCMD_READ_TOC_PIONEER                        0xc1 /* Pioneer Vendor Unique command */
+#define GPCMD_READ_TOC_SONY                           0xc1 /* Sony Vendor Unique command */
 #define GPCMD_PAUSE_RESUME_ALT                        0xc2
 #define GPCMD_READ_SUBCHANNEL_MATSUSHITA              0xc2 /* Matsushita Vendor Unique command */
+#define GPCMD_READ_SUBCODEQ_PIONEER                   0xc2 /* Pioneer Vendor Unique command */
 #define GPCMD_READ_SUBCHANNEL_SONY                    0xc2 /* Sony Vendor Unique command */
 #define GPCMD_STILL_TOSHIBA                           0xc2 /* Toshiba Vendor Unique command */
-#define GPCMD_READ_SUBCODEQ_PIONEER                   0xc2 /* Pioneer Vendor Unique command */
 #define GPCMD_READ_TOC_MATSUSHITA                     0xc3 /* Matsushita Vendor Unique command */
 #define GPCMD_READ_HEADER_SONY                        0xc3 /* Sony Vendor Unique command */
 #define GPCMD_SET_STOP_TIME_TOSHIBA                   0xc3 /* Toshiba Vendor Unique command */
-#define GPCMD_READ_HEADER_MATSUSHITA                  0xc4 /* Matsushita Vendor Unique command */
-#define GPCMD_PLAYBACK_STATUS_SONY                    0xc4 /* Sony Vendor Unique command */
 #define GPCMD_CADDY_EJECT_TOSHIBA                     0xc4 /* Toshiba Vendor Unique command */
+#define GPCMD_PLAYBACK_STATUS_SONY                    0xc4 /* Sony Vendor Unique command */
+#define GPCMD_READ_HEADER_MATSUSHITA                  0xc4 /* Matsushita Vendor Unique command */
 #define GPCMD_PAUSE_SONY                              0xc5 /* Sony Vendor Unique command */
 #define GPCMD_PLAY_AUDIO_MATSUSHITA                   0xc5 /* Matsushita Vendor Unique command */
 #define GPCMD_UNKNOWN_SCSI2_NEC                       0xc5 /* NEC Vendor Unique Command */
-#define GPCMD_STOP_CHINON                             0xc6 /* Chinon Vendor Unique command */
 #define GPCMD_PLAY_TRACK_SONY                         0xc6 /* Sony Vendor Unique command */
 #define GPCMD_READ_SUBCODEQ_PLAYING_STATUS_TOSHIBA    0xc6 /* Toshiba Vendor Unique command */
+#define GPCMD_STOP_CHINON                             0xc6 /* Chinon Vendor Unique command */
 #define GPCMD_PLAY_AUDIO_MSF_MATSUSHITA               0xc7 /* Matsushita Vendor Unique command*/
 #define GPCMD_PLAY_MSF_SONY                           0xc7 /* Sony Vendor Unique command*/
 #define GPCMD_READ_DISC_INFORMATION_TOSHIBA           0xc7 /* Toshiba Vendor Unique command */
-#define GPCMD_PLAY_AUDIO_TRACK_INDEX_MATSUSHITA       0xc8 /* Matsushita Vendor Unique command */
-#define GPCMD_PLAY_AUDIO_SONY                         0xc8 /* Sony Vendor Unique command */
 #define GPCMD_AUDIO_TRACK_SEARCH_PIONEER              0xc8 /* Pioneer Vendor Unique command */
+#define GPCMD_PLAY_AUDIO_SONY                         0xc8 /* Sony Vendor Unique command */
+#define GPCMD_PLAY_AUDIO_TRACK_INDEX_MATSUSHITA       0xc8 /* Matsushita Vendor Unique command */
+#define GPCMD_READ_CDROM_MODE_TOSHIBA                 0xc8 /* Toshiba Vendor Unique command */
+#define GPCMD_PLAY_AUDIO_PIONEER                      0xc9 /* Pioneer Vendor Unique command */
 #define GPCMD_PLAY_AUDIO_TRACK_RELATIVE_10_MATSUSHITA 0xc9 /* Matsushita Vendor Unique command */
 #define GPCMD_PLAYBACK_CONTROL_SONY                   0xc9 /* Sony Vendor Unique command */
-#define GPCMD_PLAY_AUDIO_PIONEER                      0xc9 /* Pioneer Vendor Unique command */
 #define GPCMD_PAUSE_PIONEER                           0xca /* Pioneer Vendor Unique command */
 #define GPCMD_PAUSE_RESUME_MATSUSHITA                 0xcb /* Matsushita Vendor Unique command */
 #define GPCMD_STOP_PIONEER                            0xcb /* Pioneer Vendor Unique command */
@@ -151,8 +152,8 @@
 #define GPCMD_READ_CD_MSF_OLD                         0xd5 /* Should be equivalent to 0xb9 */
 #define GPCMD_AUDIO_TRACK_SEARCH_NEC                  0xd8 /* NEC Vendor Unique command */
 #define GPCMD_PLAY_AUDIO_NEC                          0xd9 /* NEC Vendor Unique command */
-#define GPCMD_STILL_NEC                               0xda /* NEC Vendor Unique command */
 #define GPCMD_SET_SPEED_ALT                           0xda /* Should be equivalent to 0xbb */
+#define GPCMD_STILL_NEC                               0xda /* NEC Vendor Unique command */
 #define GPCMD_SET_STOP_TIME_NEC                       0xdb /* NEC Vendor Unique command */
 #define GPCMD_CADDY_EJECT_NEC                         0xdc /* NEC Vendor Unique command */
 #define GPCMD_READ_SUBCODEQ_PLAYING_STATUS_NEC        0xdd /* NEC Vendor Unique command */
@@ -409,12 +410,13 @@ typedef struct scsi_common_s {
     int                do_page_save;
     int                unit_attention;
     int                request_pos;
-    int                old_len;
-    int                media_status;
+    int                wait;
+    int                buffer_pos;
 
     uint32_t           sector_pos;
     uint32_t           sector_len;
     uint32_t           packet_len;
+    uint32_t           block_len;
 
     double             callback;
 
diff --git a/src/include/86box/scsi_disk.h b/src/include/86box/scsi_disk.h
index 7099b836a..293cc35e6 100644
--- a/src/include/86box/scsi_disk.h
+++ b/src/include/86box/scsi_disk.h
@@ -53,6 +53,7 @@ typedef struct scsi_disk_t {
     uint32_t           sector_pos;
     uint32_t           sector_len;
     uint32_t           packet_len;
+    uint32_t           block_len;
 
     double             callback;
 
diff --git a/src/include/86box/zip.h b/src/include/86box/zip.h
index 06c6e8485..443ab1327 100644
--- a/src/include/86box/zip.h
+++ b/src/include/86box/zip.h
@@ -108,6 +108,7 @@ typedef struct zip_t {
     uint32_t           sector_pos;
     uint32_t           sector_len;
     uint32_t           packet_len;
+    uint32_t           block_len;
 
     double             callback;
 
diff --git a/src/qt/win_cdrom_ioctl.c b/src/qt/win_cdrom_ioctl.c
index 309f861e0..ff72e58fe 100644
--- a/src/qt/win_cdrom_ioctl.c
+++ b/src/qt/win_cdrom_ioctl.c
@@ -43,9 +43,6 @@ typedef struct ioctl_t {
     void                   *log;
     int                     is_dvd;
     int                     has_audio;
-    int32_t                 tracks_num;
-    uint8_t                 cur_toc[65536];
-    CDROM_READ_TOC_EX       cur_read_toc_ex;
     int                     blocks_num;
     uint8_t                 cur_rti[65536];
     HANDLE                  handle;
@@ -91,37 +88,50 @@ ioctl_open_handle(ioctl_t *ioctl)
     ioctl_log(ioctl->log, "handle=%p, error=%x\n",
               ioctl->handle, (unsigned int) GetLastError());
 
+    if (ioctl->handle != INVALID_HANDLE_VALUE) {
+        CDROM_SET_SPEED set_speed = { 0 };
+
+        set_speed.RequestType     = CdromSetSpeed;
+        set_speed.ReadSpeed       = 0xffff;
+        set_speed.WriteSpeed      = 0xffff;
+        set_speed.RotationControl = CdromDefaultRotation;
+
+        (void) DeviceIoControl(ioctl->handle, IOCTL_CDROM_SET_SPEED,
+                               &set_speed, sizeof(set_speed),
+                               NULL, 0,
+                               0, NULL);
+    }
+
     return (ioctl->handle != INVALID_HANDLE_VALUE);
 }
 
 static int
-ioctl_read_normal_toc(ioctl_t *ioctl, uint8_t *toc_buf)
+ioctl_read_normal_toc(ioctl_t *ioctl, uint8_t *toc_buf, int32_t *tracks_num)
 {
-    long                     size         = 0;
-    PCDROM_TOC_FULL_TOC_DATA cur_full_toc = NULL;
+    long                     size            = 0;
+    PCDROM_TOC_FULL_TOC_DATA cur_full_toc    = NULL;
+    CDROM_READ_TOC_EX        cur_read_toc_ex = { 0 };
 
-    ioctl->tracks_num = 0;
+    *tracks_num = 0;
     memset(toc_buf, 0x00, 65536);
 
     cur_full_toc = (PCDROM_TOC_FULL_TOC_DATA) calloc(1, 65536);
 
-    ioctl->cur_read_toc_ex.Format       = CDROM_READ_TOC_EX_FORMAT_TOC;
-    ioctl_log(ioctl->log, "cur_read_toc_ex.Format = %i\n", ioctl->cur_read_toc_ex.Format);
-    ioctl->cur_read_toc_ex.Msf          = 1;
-    ioctl->cur_read_toc_ex.SessionTrack = 1;
+    cur_read_toc_ex.Format       = CDROM_READ_TOC_EX_FORMAT_TOC;
+    ioctl_log(ioctl->log, "cur_read_toc_ex.Format = %i\n", cur_read_toc_ex.Format);
+    cur_read_toc_ex.Msf          = 1;
+    cur_read_toc_ex.SessionTrack = 1;
 
-    ioctl_open_handle(ioctl);
     const int temp = DeviceIoControl(ioctl->handle, IOCTL_CDROM_READ_TOC_EX,
-                                     &ioctl->cur_read_toc_ex, 65535,
-                               cur_full_toc, 65535,
+                                     &cur_read_toc_ex, sizeof(CDROM_READ_TOC_EX),
+                                     cur_full_toc, 65535,
                                      (LPDWORD) &size, NULL);
-    ioctl_close_handle(ioctl);
     ioctl_log(ioctl->log, "temp = %i\n", temp);
 
     if (temp != 0) {
         const int length = ((cur_full_toc->Length[0] << 8) | cur_full_toc->Length[1]) + 2;
         memcpy(toc_buf, cur_full_toc, length);
-        ioctl->tracks_num = (length - 4) / 8;
+        *tracks_num = (length - 4) / 8;
     }
 
     free(cur_full_toc);
@@ -130,9 +140,9 @@ ioctl_read_normal_toc(ioctl_t *ioctl, uint8_t *toc_buf)
     PCDROM_TOC toc = (PCDROM_TOC) toc_buf;
 
     ioctl_log(ioctl->log, "%i tracks: %02X %02X %02X %02X\n",
-              ioctl->tracks_num, toc_buf[0], toc_buf[1], toc_buf[2], toc_buf[3]);
+              *tracks_num, toc_buf[0], toc_buf[1], toc_buf[2], toc_buf[3]);
 
-    for (int i = 0; i < ioctl->tracks_num; i++) {
+    for (int i = 0; i < *tracks_num; i++) {
         const uint8_t *t  = (const uint8_t *) &toc->TrackData[i];
         ioctl_log(ioctl->log, "Track %03i: %02X %02X %02X %02X %02X %02X %02X %02X\n",
                   i, t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7]);
@@ -145,10 +155,12 @@ ioctl_read_normal_toc(ioctl_t *ioctl, uint8_t *toc_buf)
 static void
 ioctl_read_raw_toc(ioctl_t *ioctl)
 {
-    PCDROM_TOC_FULL_TOC_DATA  cur_full_toc = NULL;
-    long                      size   = 0;
-    raw_track_info_t         *rti    = (raw_track_info_t *) ioctl->cur_rti;
-    uint8_t                  *buffer = (uint8_t *) calloc (1, 2052);
+    PCDROM_TOC_FULL_TOC_DATA  cur_full_toc    = NULL;
+    long                      size            = 0;
+    raw_track_info_t         *rti             = (raw_track_info_t *) ioctl->cur_rti;
+    uint8_t                  *buffer          = (uint8_t *) calloc (1, 2052);
+    int                       status          = 0;
+    CDROM_READ_TOC_EX         cur_read_toc_ex = { 0 };
 
     ioctl->is_dvd = (ioctl_read_dvd_structure(ioctl, 0, 0, buffer, NULL) > 0);
     free(buffer);
@@ -159,65 +171,75 @@ ioctl_read_raw_toc(ioctl_t *ioctl)
 
     cur_full_toc = (PCDROM_TOC_FULL_TOC_DATA) calloc(1, 65536);
 
-    ioctl->cur_read_toc_ex.Format       = CDROM_READ_TOC_EX_FORMAT_FULL_TOC;
-    ioctl_log(ioctl->log, "cur_read_toc_ex.Format = %i\n", ioctl->cur_read_toc_ex.Format);
-    ioctl->cur_read_toc_ex.Msf          = 1;
-    ioctl->cur_read_toc_ex.SessionTrack = 1;
+    cur_read_toc_ex.Format       = CDROM_READ_TOC_EX_FORMAT_FULL_TOC;
+    ioctl_log(ioctl->log, "cur_read_toc_ex.Format = %i\n", cur_read_toc_ex.Format);
+    cur_read_toc_ex.Msf          = 1;
+    cur_read_toc_ex.SessionTrack = 1;
 
-    ioctl_open_handle(ioctl);
-    const int status = DeviceIoControl(ioctl->handle, IOCTL_CDROM_READ_TOC_EX,
-                                       &ioctl->cur_read_toc_ex, 65535,
-                                       cur_full_toc, 65535,
-                                       (LPDWORD) &size, NULL);
-    ioctl_close_handle(ioctl);
-    ioctl_log(ioctl->log, "status = %i\n", status);
+    if (!ioctl->is_dvd) {
+        status = DeviceIoControl(ioctl->handle, IOCTL_CDROM_READ_TOC_EX,
+                                 &cur_read_toc_ex, sizeof(CDROM_READ_TOC_EX),
+                                 cur_full_toc, 65535,
+                                 (LPDWORD) &size, NULL);
+        ioctl_log(ioctl->log, "status = %i\n", status);
+    }
 
-    if ((status == 0) && (ioctl->tracks_num >= 1)) {
+    if (status == 0) {
         /*
            This is needed because in some circumstances (eg. a DVD .MDS
            mounted in Daemon Tools), reading the raw TOC fails but
            reading the cooked TOC does not, so we have to construct the
            raw TOC from the cooked TOC.
          */
-        const CDROM_TOC  *toc = (const CDROM_TOC *) ioctl->cur_toc;
-        const TRACK_DATA *ct  = &(toc->TrackData[ioctl->tracks_num - 1]);
+        uint8_t           cur_toc[65536] = { 0 };
+        int32_t           tracks_num     = 0;
 
-        rti[0].adr_ctl = ((ct->Adr & 0xf) << 4) | (ct->Control & 0xf);
-        rti[0].point   = 0xa0;
-        rti[0].pm      = toc->FirstTrack;
+        const CDROM_TOC * toc            = (const CDROM_TOC *) cur_toc;
 
-        rti[1].adr_ctl = rti[0].adr_ctl;
-        rti[1].point   = 0xa1;
-        rti[1].pm      = toc->LastTrack;
+        status                           = ioctl_read_normal_toc(ioctl, cur_toc, &tracks_num);
 
-        rti[2].adr_ctl = rti[0].adr_ctl;
-        rti[2].point   = 0xa2;
-        rti[2].pm      = ct->Address[1];
-        rti[2].ps      = ct->Address[2];
-        rti[2].pf      = ct->Address[3];
+        const TRACK_DATA *ct             = &(toc->TrackData[tracks_num - 1]);
 
-        ioctl->blocks_num = 3;
+        if ((status > 0) && (tracks_num >= 1)) {
+            rti[0].adr_ctl = ((ct->Adr & 0xf) << 4) | (ct->Control & 0xf);
+            rti[0].point   = 0xa0;
+            rti[0].pm      = toc->FirstTrack;
 
-        for (int i = 0; i < (ioctl->tracks_num - 1); i++) {
-            raw_track_info_t *crt = &(rti[ioctl->blocks_num]);
+            rti[1].adr_ctl = rti[0].adr_ctl;
+            rti[1].point   = 0xa1;
+            rti[1].pm      = toc->LastTrack;
 
-            ct           = &(toc->TrackData[i]);
+            rti[2].adr_ctl = rti[0].adr_ctl;
+            rti[2].point   = 0xa2;
+            rti[2].pm      = ct->Address[1];
+            rti[2].ps      = ct->Address[2];
+            rti[2].pf      = ct->Address[3];
 
-            crt->adr_ctl = ((ct->Adr & 0xf) << 4) | (ct->Control & 0xf);
-            crt->point   = ct->TrackNumber;
-            crt->pm      = ct->Address[1];
-            crt->ps      = ct->Address[2];
-            crt->pf      = ct->Address[3];
+            ioctl->blocks_num = 3;
 
-            ioctl->blocks_num++;
-        }
+            for (int i = 0; i < (tracks_num - 1); i++) {
+                raw_track_info_t *crt = &(rti[ioctl->blocks_num]);
+
+                ct           = &(toc->TrackData[i]);
+
+                crt->adr_ctl = ((ct->Adr & 0xf) << 4) | (ct->Control & 0xf);
+                crt->point   = ct->TrackNumber;
+                crt->pm      = ct->Address[1];
+                crt->ps      = ct->Address[2];
+                crt->pf      = ct->Address[3];
+
+                ioctl->blocks_num++;
+            }
+        } else if (status > 0)
+           /* Announce that we've had a failure. */
+           status = 0;
     } else if (status != 0) {
         ioctl->blocks_num = (((cur_full_toc->Length[0] << 8) |
                               cur_full_toc->Length[1]) - 2) / 11;
         memcpy(ioctl->cur_rti, cur_full_toc->Descriptors, ioctl->blocks_num * 11);
     }
 
-    if (ioctl->blocks_num)  for (int i = 0; i < ioctl->tracks_num; i++) {
+    if (ioctl->blocks_num)  for (int i = 0; i < ioctl->blocks_num; i++) {
         const raw_track_info_t *crt = &(rti[i]);
 
         if ((crt->point >= 1) && (crt->point <= 99) && !(crt->adr_ctl & 0x04)) {
@@ -244,13 +266,6 @@ ioctl_read_raw_toc(ioctl_t *ioctl)
     free(cur_full_toc);
 }
 
-static void
-ioctl_read_toc(ioctl_t *ioctl)
-{
-    (void) ioctl_read_normal_toc(ioctl, ioctl->cur_toc);
-    ioctl_read_raw_toc(ioctl);
-}
-
 static int
 ioctl_get_track(const ioctl_t *ioctl, const uint32_t sector) {
     raw_track_info_t *rti   = (raw_track_info_t *) ioctl->cur_rti;
@@ -296,23 +311,28 @@ static int
 ioctl_get_track_info(const void *local, const uint32_t track,
                      int end, track_info_t *ti)
 {
-    const ioctl_t *  ioctl = (const ioctl_t *) local;
-    const CDROM_TOC *toc   = (const CDROM_TOC *) ioctl->cur_toc;
-    int              ret   = 1;
+    const ioctl_t *         ioctl = (const ioctl_t *) local;
+    const raw_track_info_t *rti   = (const raw_track_info_t *) ioctl->cur_rti;
+    int                     ret   = 1;
+    int                     trk   = -1;
 
-    if ((track < 1) || (track == 0xaa) || (track > (toc->LastTrack + 1))) {
+    if ((track >= 1) && (track < 99))
+        for (int i = 0; i < ioctl->blocks_num; i++)
+             if (rti[i].point == track) {
+                 trk = i;
+                 break;
+             }
+
+    if ((track == 0xaa) || (trk == -1)) {
         ioctl_log(ioctl->log, "ioctl_get_track_info(%02i)\n", track);
         ret = 0;
     } else {
-        const TRACK_DATA * td    = &toc->TrackData[track - 1];
+        ti->m      = rti[trk].pm;
+        ti->s      = rti[trk].ps;
+        ti->f      = rti[trk].pf;
 
-        ti->m      = td->Address[1];
-        ti->s      = td->Address[2];
-        ti->f      = td->Address[3];
-
-        ti->number = td->TrackNumber;
-        ti->attr   = td->Control;
-        ti->attr  |= ((td->Adr << 4) & 0xf0);
+        ti->number = rti[trk].point;
+        ti->attr   = rti[trk].adr_ctl;
 
         ioctl_log(ioctl->log, "ioctl_get_track_info(%02i): %02i:%02i:%02i, %02i, %02X\n",
                   track, ti->m, ti->s, ti->f, ti->number, ti->attr);
@@ -370,8 +390,6 @@ ioctl_read_sector(const void *local, uint8_t *buffer, uint32_t const sector)
     int                          ret;
     SCSI_PASS_THROUGH_DIRECT_BUF req;
 
-    ioctl_open_handle((ioctl_t *) ioctl);
-
     if (ioctl->is_dvd) {
         int                          track;
 
@@ -503,8 +521,6 @@ ioctl_read_sector(const void *local, uint8_t *buffer, uint32_t const sector)
              for (int j = 7; j >= 0; j--)
                   buffer[2352 + (i * 8) + j] = ((buffer[sc_offs + i] >> (7 - j)) & 0x01) << 6;
 
-    ioctl_close_handle((ioctl_t *) ioctl);
-
     return ret;
 }
 
@@ -540,18 +556,15 @@ ioctl_get_track_type(const void *local, const uint32_t sector)
 static uint32_t
 ioctl_get_last_block(const void *local)
 {
-    const ioctl_t   *ioctl   = (const ioctl_t *) local;
-    const CDROM_TOC *toc     = (const CDROM_TOC *) ioctl->cur_toc;
+    const ioctl_t *  ioctl = (const ioctl_t *) local;
+    raw_track_info_t *rti  = (raw_track_info_t *) ioctl->cur_rti;
     uint32_t         lb      = 0;
 
-    for (int c = 0; c <= toc->LastTrack; c++) {
-        const TRACK_DATA *td      = &toc->TrackData[c];
-        const uint32_t    address = MSFtoLBA(td->Address[1], td->Address[2],
-                                             td->Address[3]) - 150;
-
-        if (address > lb)
-            lb = address;
-    }
+    for (int i = (ioctl->blocks_num - 1); i >= 0; i--)
+        if (rti[i].point == 0xa2) {
+            lb = MSFtoLBA(rti[i].pm, rti[i].ps, rti[i].pf) - 151;
+            break;
+        }
 
     ioctl_log(ioctl->log, "LBCapacity=%d\n", lb);
 
@@ -573,8 +586,6 @@ ioctl_read_dvd_structure(const void *local, const uint8_t layer, const uint8_t f
     const int                    len     = 2052;
     SCSI_PASS_THROUGH_DIRECT_BUF req;
 
-    ioctl_open_handle((ioctl_t *) ioctl);
-
     memset(&req, 0x00, sizeof(SCSI_PASS_THROUGH_DIRECT_BUF));
     req.spt.Length                = sizeof(SCSI_PASS_THROUGH_DIRECT);
     req.spt.PathId                = 0;
@@ -636,8 +647,6 @@ ioctl_read_dvd_structure(const void *local, const uint8_t layer, const uint8_t f
     } else
         ret = ret ? (req.spt.DataTransferLength >= len) : 0;
 
-    ioctl_close_handle((ioctl_t *) ioctl);
-
     return ret;
 }
 
@@ -670,8 +679,6 @@ ioctl_is_empty(const void *local)
     unsigned long int            unused  = 0;
     SCSI_PASS_THROUGH_DIRECT_BUF req;
 
-    ioctl_open_handle((ioctl_t *) ioctl);
-
     memset(&req, 0x00, sizeof(SCSI_PASS_THROUGH_DIRECT_BUF));
     req.spt.Length                = sizeof(SCSI_PASS_THROUGH_DIRECT);
     req.spt.PathId                = 0;
@@ -731,8 +738,6 @@ ioctl_is_empty(const void *local)
     } else
         ret = 0;
 
-    ioctl_close_handle((ioctl_t *) ioctl);
-
     return ret;
 }
 
@@ -760,14 +765,13 @@ ioctl_load(const void *local)
 {
     const ioctl_t *ioctl = (const ioctl_t *) local;
 
-    if (ioctl_open_handle((ioctl_t *) ioctl)) {
-        long size;
-        DeviceIoControl(ioctl->handle, IOCTL_STORAGE_LOAD_MEDIA,
-                        NULL, 0, NULL, 0,
-                        (LPDWORD) &size, NULL);
-        ioctl_close_handle((ioctl_t *) ioctl);
+    if ((ioctl->handle != NULL) || ioctl_open_handle((ioctl_t *) ioctl)) {
+        long size = 0;
+        (void) DeviceIoControl(ioctl->handle, IOCTL_STORAGE_LOAD_MEDIA,
+                               NULL, 0, NULL, 0,
+                               (LPDWORD) &size, NULL);
 
-        ioctl_read_toc((ioctl_t *) ioctl);
+        ioctl_read_raw_toc((ioctl_t *) ioctl);
     }
 }
 
diff --git a/src/scsi/scsi_cdrom.c b/src/scsi/scsi_cdrom.c
index e16b16e7c..292c54127 100644
--- a/src/scsi/scsi_cdrom.c
+++ b/src/scsi/scsi_cdrom.c
@@ -90,7 +90,7 @@ uint8_t scsi_cdrom_command_flags[0x100] = {
              eventually becomes ready, make the condition go away.
      */
     [0x43 ... 0x45] = IMPLEMENTED | CHECK_READY,
-    [0x46]            IMPLEMENTED | ALLOW_UA,
+    [0x46]          = IMPLEMENTED | ALLOW_UA,
     [0x47 ... 0x49] = IMPLEMENTED | CHECK_READY,
     [0x4a]          = IMPLEMENTED | ALLOW_UA,
     [0x4b]          = IMPLEMENTED | CHECK_READY,
@@ -110,6 +110,7 @@ uint8_t scsi_cdrom_command_flags[0x100] = {
     [0xbd]          = IMPLEMENTED,
     [0xbe ... 0xbf] = IMPLEMENTED | CHECK_READY,
     [0xc0 ... 0xcd] = IMPLEMENTED | CHECK_READY | SCSI_ONLY,
+    [0xd5]          = IMPLEMENTED | CHECK_READY,
     [0xd8 ... 0xde] = IMPLEMENTED | CHECK_READY | SCSI_ONLY,
     [0xe0 ... 0xe1] = IMPLEMENTED | CHECK_READY | SCSI_ONLY,
     [0xe3 ... 0xe9] = IMPLEMENTED | CHECK_READY | SCSI_ONLY,
@@ -303,15 +304,14 @@ scsi_cdrom_init(scsi_cdrom_t *dev)
             dev->tf->status = 0;
         dev->tf->pos         = 0;
         dev->packet_status   = PHASE_NONE;
-        scsi_cdrom_sense_key = scsi_cdrom_asc = scsi_cdrom_ascq = dev->unit_attention = 0;
+        scsi_cdrom_sense_key = scsi_cdrom_asc =
+        scsi_cdrom_ascq = dev->unit_attention = 0;
         scsi_cdrom_info      = 0x00000000;
         dev->drv->cd_status &= ~CD_STATUS_TRANSITION;
         dev->drv->cur_speed  = dev->drv->real_speed;
         scsi_cdrom_mode_sense_load(dev);
 
-        const char *vendor = cdrom_get_vendor(dev->drv->type);
-
-        if ((dev->drv->bus_type == CDROM_BUS_SCSI) && !strcmp(vendor, "PIONEER"))
+        if ((dev->drv->bus_type == CDROM_BUS_SCSI) && dev->drv->is_pioneer)
             scsi_cdrom_drive_status_load(dev);
     }
 }
@@ -339,7 +339,7 @@ scsi_cdrom_get_channel(void *priv, const int channel)
     uint32_t ret = channel + 1;
 
     if (dev != NULL)
-        ret = dev->ms_pages_saved.pages[GPMODE_CDROM_AUDIO_PAGE][channel ? 10 : 8];
+        ret = dev->ms_pages_saved.pages[GPMODE_CDROM_AUDIO_PAGE][channel ? 10 : 8] & 0x0f;
 
     return ret;
 }
@@ -530,7 +530,8 @@ scsi_cdrom_mode_sense(const scsi_cdrom_t *dev, uint8_t *buf, uint32_t pos,
                                 buf[pos++] = ((dev->drv->cur_speed * 176) & 0xff);
                             else
                                 buf[pos++] = ((dev->drv->cur_speed * 176) >> 8);
-                        } else if (dev->is_sony && (i == GPMODE_CDROM_AUDIO_PAGE_SONY) &&
+                        } else if (dev->drv->is_sony &&
+                                   (i == GPMODE_CDROM_AUDIO_PAGE_SONY) &&
                                    (j >= 6) && (j <= 13))
                             buf[pos++] = scsi_cdrom_mode_sense_read(dev, pgctl,
                                                                     GPMODE_CDROM_AUDIO_PAGE, 2 + j);
@@ -559,13 +560,21 @@ scsi_cdrom_update_request_length(scsi_cdrom_t *dev, int len, const int block_len
        matches the block length.
      */
     switch (dev->current_cdb[0]) {
+        case 0xbc:
+            if (!dev->drv->is_early) {
+                dev->packet_len   = len;
+                break;
+            }
+            fallthrough;
         case 0x08:
         case 0x28:
         case 0xa8:
+        case 0xb8:
         case 0xb9:
         case 0xbe:
+        case 0xd5:
             /* Round it to the nearest (block length) bytes. */
-            if ((dev->current_cdb[0] == 0xb9) || (dev->current_cdb[0] == 0xbe)) {
+            if (dev->current_cdb[0] >= 0xb8) {
                 /*
                    READ CD MSF and READ CD: Round the request length to the sector size - the
                    device must ensure that a media access comand does not DRQ in the middle
@@ -601,10 +610,13 @@ scsi_cdrom_update_request_length(scsi_cdrom_t *dev, int len, const int block_len
                     break;
                 }
             }
+
+            if ((dev->drv->bus_type != CDROM_BUS_SCSI) && (dev->block_len != 0))
+                dev->requested_blocks = (dev->packet_len  / dev->block_len);
             fallthrough;
 
         default:
-            dev->packet_len = len;
+            dev->packet_len   = len;
             break;
     }
     /*
@@ -648,94 +660,72 @@ scsi_cdrom_bus_speed(scsi_cdrom_t *dev)
     }
 }
 
+static void
+scsi_cdrom_set_period(scsi_cdrom_t *dev)
+{
+    scsi_cdrom_log(dev->log, "Current speed: %ix\n", dev->drv->cur_speed);
+
+    dev->callback = 0;
+
+    if (dev->packet_status != PHASE_COMPLETE) {
+        double  bytes_per_second;
+        double  period;
+
+        if (dev->was_cached != -1) {
+            if (dev->was_cached) {
+                dev->callback += 512.0;
+                scsi_cdrom_set_callback(dev);
+                return;
+            }
+
+            /* Seek time is in us. */
+            period = cdrom_seek_time(dev->drv);
+            scsi_cdrom_log(dev->log, "Seek period: %" PRIu64 " us\n",
+                           (uint64_t) period);
+            dev->callback += period;
+
+            /* 44100 * 16 bits * 2 channels = 176400 bytes per second */
+            bytes_per_second = 176400.0;
+            bytes_per_second *= (double) dev->drv->cur_speed;
+        } else {
+            bytes_per_second = scsi_cdrom_bus_speed(dev);
+            if (bytes_per_second == 0.0) {
+                dev->callback = -1; /* Speed depends on SCSI controller */
+                return;
+            }
+        }
+
+        period = 1000000.0 / bytes_per_second;
+        scsi_cdrom_log(dev->log, "Byte transfer period: %" PRIu64 " us\n",
+                       (uint64_t) period);
+        if (dev->was_cached == -1)
+            period *= (double) dev->packet_len;
+        else {
+            const int num = ((dev->drv->bus_type == CDROM_BUS_SCSI) ||
+                             (dev->block_len == 0)) ?
+                            dev->requested_blocks :
+                            ((scsi_cdrom_current_mode(dev) == 2) ? 1 :
+                             (dev->packet_len  / dev->block_len));
+
+            period *= ((double) num) * 2352.0;
+        }
+        scsi_cdrom_log(dev->log, "Sector transfer period: %" PRIu64 " us\n",
+                       (uint64_t) period);
+        dev->callback += period;
+    }
+    scsi_cdrom_set_callback(dev);
+}
+
 static void
 scsi_cdrom_command_common(scsi_cdrom_t *dev)
 {
-    const uint8_t cmd        = dev->current_cdb[0];
-
     /* MAP: BUSY_STAT, no DRQ, phase 1. */
     dev->tf->status    = BUSY_STAT;
     dev->tf->phase     = 1;
     dev->tf->pos       = 0;
     dev->callback      = 0;
 
-    scsi_cdrom_log(dev->log, "Current speed: %ix\n", dev->drv->cur_speed);
-
-    if (dev->packet_status == PHASE_COMPLETE)
-        dev->callback = 0;
-    else {
-        double  bytes_per_second;
-        double  period;
-
-        switch (cmd) {
-            case GPCMD_REZERO_UNIT:
-            case 0x0b:
-            case 0x2b:
-                /* Seek time is in us. */
-                period = cdrom_seek_time(dev->drv);
-                scsi_cdrom_log(dev->log, "Seek period: %" PRIu64 " us\n",
-                               (uint64_t) period);
-                dev->callback += period;
-                scsi_cdrom_set_callback(dev);
-                return;
-            case 0x08:
-            case 0x28:
-            case 0xa8:
-                /* Seek time is in us. */
-                period = cdrom_seek_time(dev->drv);
-                scsi_cdrom_log(dev->log, "Seek period: %" PRIu64 " us\n",
-                               (uint64_t) period);
-                scsi_cdrom_log(dev->log, "Seek period: %" PRIu64 " us, speed: %"
-                               PRIu64 " bytes per second, should be: %"
-                               PRIu64 " bytes per second\n",
-                               (uint64_t) period, (uint64_t) (1000000.0 / period),
-                               (uint64_t) (176400.0 * (double) dev->drv->cur_speed));
-                dev->callback += period;
-                fallthrough;
-            case 0x25:
-            case 0x42 ... 0x44:
-            case 0x51 ... 0x52:
-            case 0xad:
-            case 0xb8 ... 0xb9:
-            case 0xbe:
-                if (dev->current_cdb[0] == 0x42)
-                    dev->callback += 40.0;
-                /* Account for seek time. */
-                /* 44100 * 16 bits * 2 channels = 176400 bytes per second */
-                bytes_per_second = 176400.0;
-                bytes_per_second *= (double) dev->drv->cur_speed;
-                break;
-            case 0xc0 ... 0xc3:
-            case 0xc6 ... 0xc7:
-            case 0xdd ... 0xde:
-                if (dev->ven_cmd_is_data[cmd]) {
-                    if (dev->current_cdb[0] == 0xc2)
-                        dev->callback += 40.0;
-                    /* Account for seek time. */
-                    /* 44100 * 16 bits * 2 channels = 176400 bytes per second */
-                    bytes_per_second = 176400.0;
-                    bytes_per_second *= (double) dev->drv->cur_speed;
-                    break;
-                }
-                fallthrough;
-            default:
-                bytes_per_second = scsi_cdrom_bus_speed(dev);
-                if (bytes_per_second == 0.0) {
-                    dev->callback = -1; /* Speed depends on SCSI controller */
-                    return;
-                }
-                break;
-        }
-
-        period = 1000000.0 / bytes_per_second;
-        scsi_cdrom_log(dev->log, "Byte transfer period: %" PRIu64 " us\n",
-                       (uint64_t) period);
-        period = period * (double) (dev->packet_len);
-        scsi_cdrom_log(dev->log, "Sector transfer period: %" PRIu64 " us\n",
-                       (uint64_t) period);
-        dev->callback += period;
-    }
-    scsi_cdrom_set_callback(dev);
+    scsi_cdrom_set_period(dev);
 }
 
 static void
@@ -955,7 +945,7 @@ scsi_cdrom_invalid_lun(scsi_cdrom_t *dev, const uint8_t lun)
 static void
 scsi_cdrom_illegal_opcode(scsi_cdrom_t *dev, const uint8_t opcode)
 {
-    scsi_cdrom_log(dev->log, "Illegal opcode\n");
+    scsi_cdrom_log(dev->log, "Illegal opcode: %02X\n", opcode);
     scsi_cdrom_sense_key = SENSE_ILLEGAL_REQUEST;
     scsi_cdrom_asc       = ASC_ILLEGAL_OPCODE;
     scsi_cdrom_ascq      = 0;
@@ -966,7 +956,7 @@ scsi_cdrom_illegal_opcode(scsi_cdrom_t *dev, const uint8_t opcode)
 static void
 scsi_cdrom_lba_out_of_range(scsi_cdrom_t *dev)
 {
-    scsi_cdrom_log(dev->log, "LBA out of range\n");
+    scsi_cdrom_log(dev->log, "LBA out of range: %08X\n", dev->sector_pos);
     scsi_cdrom_sense_key = SENSE_ILLEGAL_REQUEST;
     scsi_cdrom_asc       = ASC_LBA_OUT_OF_RANGE;
     scsi_cdrom_ascq      = 0;
@@ -1051,77 +1041,75 @@ scsi_cdrom_illegal_mode(scsi_cdrom_t *dev)
 
 static int
 scsi_cdrom_read_data(scsi_cdrom_t *dev, const int msf, const int type, const int flags,
-                     int32_t *len, const int vendor_type)
+                     const int vendor_type)
 {
-    int      temp_len = 0;
-    int      ret      = 0;
+    int       temp_len = 0;
+    int       ret      = 0;
+    int       num      = (dev->drv->bus_type == CDROM_BUS_SCSI) ?
+                         dev->requested_blocks : 1;
 
     if (dev->drv->cd_status == CD_STATUS_EMPTY)
         scsi_cdrom_not_ready(dev);
-    else {
-        const uint32_t cdsize   = dev->drv->cdrom_capacity;
+    else if (dev->sector_pos > dev->drv->cdrom_capacity) {
+        scsi_cdrom_lba_out_of_range(dev);
+        ret = -1;
+    } else {
+        ret = 1;
+        for (int i = 0; (i < num) && (ret > 0); i++) {
+            ret = cdrom_readsector_raw(dev->drv, dev->buffer + dev->buffer_pos,
+                                       dev->sector_pos, msf, type,
+                                       flags, &temp_len, vendor_type);
 
-        if (dev->sector_pos >= cdsize) {
-            scsi_cdrom_log(dev->log, "Trying to read from beyond the end of "
-                           "disc (%i >= %i)\n", dev->sector_pos, cdsize);
-            scsi_cdrom_lba_out_of_range(dev);
-            ret = -1;
-        } else {
-            int      data_pos = 0;
+            if (ret < 0)
+                scsi_cdrom_circ_error(dev);
+            else if (ret == 0)
+                scsi_cdrom_illegal_mode(dev);
+            else {
+                if (dev->block_len == 0xffffffff) {
+                    dev->block_len = temp_len;
 
-            dev->old_len = 0;
-            *len         = 0;
-
-            ret = 1;
-
-            for (int i = 0; i < dev->requested_blocks; i++) {
-                ret = cdrom_readsector_raw(dev->drv, dev->buffer + data_pos,
-                                           dev->sector_pos + i, msf, type,
-                                           flags, &temp_len, vendor_type);
-
-                data_pos += temp_len;
-                dev->old_len += temp_len;
-
-                *len += temp_len;
-
-                if (ret == 0) {
-                    scsi_cdrom_illegal_mode(dev);
-                    break;
+                    if ((dev->drv->bus_type != CDROM_BUS_SCSI) &&
+                        (scsi_cdrom_current_mode(dev) != 2))
+                        num = (dev->packet_len / dev->block_len);
                 }
 
-                if (ret < 0) {
-                    scsi_cdrom_circ_error(dev);
-                    break;
-                }
+                dev->sector_pos++;
+                dev->drv->seek_pos = dev->sector_pos;
+
+                dev->sector_len--;
+
+                dev->buffer_pos += temp_len;
             }
         }
     }
 
+    if ((ret < 1) || (dev->sector_len == 0))
+        dev->wait = 0;
+
     return ret;
 }
 
 static int
-scsi_cdrom_read_blocks(scsi_cdrom_t *dev, int32_t *len, const int vendor_type)
+scsi_cdrom_read_blocks(scsi_cdrom_t *dev)
 {
     int ret   = 1;
     int msf   = 0;
     int type  = dev->sector_type;
     int flags = dev->sector_flags;
 
-    /* Any of these commands stop the audio playing. */
-    cdrom_stop(dev->drv);
-
     switch (dev->current_cdb[0]) {
         case GPCMD_READ_CD_MSF_OLD:
         case GPCMD_READ_CD_MSF:
             msf = 1;
             fallthrough;
+        case GPCMD_PLAY_CD:
         case GPCMD_READ_CD_OLD:
         case GPCMD_READ_CD:
             type  = (dev->current_cdb[1] >> 2) & 7;
             flags = dev->current_cdb[9] | (((uint32_t) dev->current_cdb[10]) << 8);
             break;
         case GPCMD_READ_HEADER:
+        case GPCMD_READ_HEADER_SONY:
             type  = 0x00;
             flags = 0x20;
             break;
@@ -1142,16 +1130,10 @@ scsi_cdrom_read_blocks(scsi_cdrom_t *dev, int32_t *len, const int vendor_type)
         scsi_cdrom_log(dev->log, "Reading %i blocks starting from %i...\n",
                        dev->requested_blocks, dev->sector_pos);
 
-        ret = scsi_cdrom_read_data(dev, msf, type, flags, len, vendor_type);
+        ret = scsi_cdrom_read_data(dev, msf, type, flags, dev->vendor_type);
 
-        scsi_cdrom_log(dev->log, "Read %i bytes of blocks (ret = %i)...\n", *len, ret);
-    }
-
-    if ((ret > 0) && (dev->current_cdb[0] != GPCMD_READ_HEADER)) {
-        dev->sector_pos += dev->requested_blocks;
-        dev->drv->seek_pos = dev->sector_pos;
-
-        dev->sector_len -= dev->requested_blocks;
+        scsi_cdrom_log(dev->log, "Read %i bytes of blocks (ret = %i)...\n",
+                       dev->block_len, ret);
     }
 
     return ret;
@@ -1192,7 +1174,7 @@ scsi_command_check_ready(const scsi_cdrom_t *dev, const uint8_t *cdb)
                            check for ready status but they do on Y vendor.
                            Quite confusing I know.
          */
-        if (!dev->is_sony || (cdb[0] != 0xc0))
+        if (!dev->drv->is_sony || (cdb[0] != 0xc0))
             ret = 1;
     } else if ((cdb[0] == GPCMD_READ_DVD_STRUCTURE) && (cdb[7] < 0xc0))
         ret = 1;
@@ -1295,12 +1277,6 @@ skip_ready_check:
     if (cdb[0] != GPCMD_REQUEST_SENSE)
         scsi_cdrom_sense_clear(dev, cdb[0]);
 
-    /* Next it's time for NOT READY. */
-    if (ready)
-        dev->media_status = dev->unit_attention ? MEC_NEW_MEDIA : MEC_NO_CHANGE;
-    else
-        dev->media_status = MEC_MEDIA_REMOVAL;
-
     if (!ready && scsi_command_check_ready(dev, cdb)) {
         scsi_cdrom_log(dev->log, "Not ready (%02X)\n", cdb[0]);
         scsi_cdrom_not_ready(dev);
@@ -1314,6 +1290,7 @@ skip_ready_check:
 static void
 scsi_cdrom_rezero(scsi_cdrom_t *dev)
 {
+    dev->drv->seek_diff = ABS(dev->sector_pos);
     dev->sector_pos = dev->sector_len = 0;
     cdrom_seek(dev->drv, 0, 0);
 }
@@ -1366,6 +1343,10 @@ scsi_cdrom_update_sector_flags(scsi_cdrom_t *dev)
             dev->sector_type  = 0x00;
             dev->sector_flags = 0x02f8;
             break;
+        case 2646:
+            dev->sector_type  = 0x00;
+            dev->sector_flags = 0x00fa;
+            break;
     }
 
     return ret;
@@ -1390,9 +1371,11 @@ scsi_cdrom_reset(scsi_common_t *sc)
         dev->drv->sector_size   = 2048;
         (void) scsi_cdrom_update_sector_flags(dev);
 
-        scsi_cdrom_sense_key = scsi_cdrom_asc = scsi_cdrom_ascq = dev->unit_attention = 0;
-        scsi_cdrom_info      = 0x00000000;
-        dev->drv->cd_status &= ~CD_STATUS_TRANSITION;
+        scsi_cdrom_sense_key    = scsi_cdrom_asc = scsi_cdrom_ascq = dev->unit_attention = 0;
+        scsi_cdrom_info         = 0x00000000;
+        dev->drv->cd_status    &= ~CD_STATUS_TRANSITION;
+        dev->drv->cached_sector = -1;
+        dev->toc_cached         = 0;
     }
 }
 
@@ -1476,6 +1459,8 @@ scsi_cdrom_stop(const scsi_common_t *sc)
     const scsi_cdrom_t *dev = (const scsi_cdrom_t *) sc;
 
     cdrom_stop(dev->drv);
+
+    ui_sb_update_icon(SB_CDROM | dev->id, 0);
 }
 
 static void
@@ -1514,6 +1499,7 @@ scsi_cdrom_command_chinon(void *sc, const uint8_t *cdb, UNUSED(int32_t *BufLen))
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             scsi_cdrom_stop(sc);
             cdrom_eject(dev->id);
+            dev->toc_cached = 0;
             scsi_cdrom_command_complete(dev);
             cmd_stat = 0x01;
             break;
@@ -1529,16 +1515,66 @@ scsi_cdrom_command_chinon(void *sc, const uint8_t *cdb, UNUSED(int32_t *BufLen))
     return cmd_stat;
 }
 
+static void
+scsi_cdrom_cache_toc(scsi_cdrom_t *dev)
+{
+    if (!dev->toc_cached) {
+        dev->toc_cached         = 1;
+        dev->drv->seek_diff     = dev->drv->seek_pos + 150;
+        dev->sector_pos         = -150;
+        dev->drv->seek_pos      = -150;
+        dev->requested_blocks   = 150;
+        dev->drv->cached_sector = -1;
+    }
+}
+
+static void
+scsi_cdrom_one_sector_seek(scsi_cdrom_t *dev)
+{
+    if (!dev->was_cached) {
+        dev->drv->seek_diff   = 0;
+        dev->requested_blocks = 1;
+    }
+}
+
+static void
+scsi_cdrom_media_access_complete(scsi_cdrom_t *dev, const int ret)
+{
+    ui_sb_update_icon(SB_CDROM | dev->id, 0);
+    scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
+    dev->packet_status = (ret < 0) ? PHASE_ERROR : PHASE_COMPLETE;
+    dev->callback      = 20.0 * CDROM_TIME;
+    scsi_cdrom_set_callback(dev);
+}
+
+static void
+scsi_cdrom_read(scsi_common_t *sc)
+{
+    scsi_cdrom_t *dev   = (scsi_cdrom_t *) sc;
+    const int osl       = dev->sector_len;
+    const int ret       = scsi_cdrom_read_blocks(dev);
+
+    dev->drv->seek_diff = 0;
+
+    if (ret > 0) {
+        if (osl > 0)        
+            scsi_cdrom_set_period(dev);
+
+        ui_sb_update_icon(SB_CDROM | dev->id,
+                          (dev->packet_status != PHASE_COMPLETE));
+    } else
+        scsi_cdrom_media_access_complete(dev, ret);
+}
+
 static uint8_t
 scsi_cdrom_command_dec_sony_texel(void *sc, const uint8_t *cdb, int32_t *BufLen)
 {
     scsi_cdrom_t *dev                    = (scsi_cdrom_t *) sc;
-    int           msf;
+    int           ret                    = 1;
     uint8_t       cmd_stat               = 0x00;
+    int           msf;
     int           len;
     int           max_len;
-    int           alloc_length;
-    int           real_pos;
 
     switch (cdb[0]) {
         default:
@@ -1553,7 +1589,9 @@ scsi_cdrom_command_dec_sony_texel(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
         case GPCMD_READ_TOC_SONY:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
-            msf              = dev->drv->sony_msf;
+            dev->was_cached = dev->toc_cached;
+
+            msf             = dev->drv->sony_msf;
 
             max_len = cdb[7];
             max_len <<= 8;
@@ -1570,6 +1608,8 @@ scsi_cdrom_command_dec_sony_texel(void *sc, const uint8_t *cdb, int32_t *BufLen)
                     /* If the returned length is -1, this means cdrom_read_toc_sony() has encountered an error. */
                     scsi_cdrom_invalid_field(dev, dev->drv->inv_field);
                 else {
+                    scsi_cdrom_cache_toc(dev);
+
                     scsi_cdrom_set_buf_len(dev, BufLen, &len);
                     scsi_cdrom_data_command_finish(dev, len, len, len, 0);
                 }
@@ -1579,6 +1619,7 @@ scsi_cdrom_command_dec_sony_texel(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
         case GPCMD_READ_SUBCHANNEL_SONY:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = (dev->drv->cached_sector != -1);
 
             max_len = cdb[7];
             max_len <<= 8;
@@ -1593,6 +1634,7 @@ scsi_cdrom_command_dec_sony_texel(void *sc, const uint8_t *cdb, int32_t *BufLen)
                 memset(dev->buffer, 0, 9);
                 len = 9;
                 cdrom_get_current_subchannel_sony(dev->drv, dev->buffer, msf);
+                scsi_cdrom_one_sector_seek(dev);
                 len = MIN(len, max_len);
                 scsi_cdrom_set_buf_len(dev, BufLen, &len);
                 scsi_cdrom_data_command_finish(dev, len, len, len, 0);
@@ -1609,23 +1651,54 @@ scsi_cdrom_command_dec_sony_texel(void *sc, const uint8_t *cdb, int32_t *BufLen)
         case GPCMD_READ_HEADER_SONY:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
 
-            alloc_length = ((cdb[7] << 8) | cdb[8]);
-            scsi_cdrom_buf_alloc(dev, 4);
+            len                   = (cdb[7] << 8) | cdb[8];
+            dev->sector_len       = 1;
+            dev->sector_pos       = (cdb[2] << 24) | (cdb[3] << 16) |
+                                    (cdb[4] << 8) | cdb[5];
+            dev->was_cached       = (dev->drv->cached_sector == dev->sector_pos);
+            scsi_cdrom_log(dev->log, "READ HEADER SONY: Length: %i, LBA: %i\n",
+                           dev->sector_len, dev->sector_pos);
 
-            dev->sector_len = 1;
-            dev->sector_pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
-            real_pos        = cdrom_lba_to_msf_accurate(dev->sector_pos);
-            dev->buffer[0]  = ((real_pos >> 16) & 0xff);
-            dev->buffer[1]  = ((real_pos >> 8) & 0xff);
-            dev->buffer[2]  = real_pos & 0xff;
-            dev->buffer[3]  = 1; /*2048 bytes user data*/
+            if (len > 0) {
+                max_len               = 1;
+                dev->requested_blocks = 1;
 
-            len = 4;
-            len = MIN(len, alloc_length);
+                dev->packet_len       = len;
+                scsi_cdrom_buf_alloc(dev, 2352);
 
-            scsi_cdrom_set_buf_len(dev, BufLen, &len);
+                scsi_cdrom_one_sector_seek(dev);
 
-            scsi_cdrom_data_command_finish(dev, len, len, len, 0);
+                /* Any of these commands stop the audio playing. */
+                cdrom_stop(dev->drv);
+
+                dev->vendor_type      = 0x00;
+
+                dev->buffer_pos       = 0x00000000;
+
+                ret = scsi_cdrom_read_blocks(dev);
+
+                if (ret > 0) {
+                    len = MIN(4, len);
+
+                    scsi_cdrom_set_buf_len(dev, BufLen, &len);
+
+                    scsi_cdrom_data_command_finish(dev, len, len,
+                                                   len, 0);
+
+                    ui_sb_update_icon(SB_CDROM | dev->id, 0);
+                } else {
+                    scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
+                    dev->packet_status = (ret < 0) ? PHASE_ERROR : PHASE_COMPLETE;
+                    dev->callback      = 20.0 * CDROM_TIME;
+                    scsi_cdrom_set_callback(dev);
+                }
+            } else {
+                scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
+                /* scsi_cdrom_log(dev->log, "All done - callback set\n"); */
+                dev->packet_status = PHASE_COMPLETE;
+                dev->callback      = 20.0 * CDROM_TIME;
+                scsi_cdrom_set_callback(dev);
+            }
             cmd_stat = 0x01;
             break;
 
@@ -1680,7 +1753,11 @@ scsi_cdrom_command_dec_sony_texel(void *sc, const uint8_t *cdb, int32_t *BufLen)
                     scsi_cdrom_illegal_mode(dev);
                 else {
                     /* In this case, len is unused so just pass a fixed value of 1 intead. */
-                    const int ret = cdrom_audio_play(dev->drv, pos, 1, msf);
+                    const int ret         = cdrom_audio_play(dev->drv, pos, 1, msf);
+                    dev->requested_blocks = 0;
+
+                    dev->drv->seek_diff   = ABS(dev->sector_pos - dev->drv->seek_pos);
+                    dev->sector_pos       = dev->drv->seek_pos;
 
                     if (ret)
                         scsi_cdrom_command_complete(dev);
@@ -1724,6 +1801,7 @@ scsi_cdrom_command_dec_sony_texel(void *sc, const uint8_t *cdb, int32_t *BufLen)
                 scsi_cdrom_set_buf_len(dev, BufLen, &len);
                 scsi_cdrom_data_command_finish(dev, len, len, len, 1);
             }
+            cmd_stat = 0x01;
             break;
     }
 
@@ -1852,12 +1930,16 @@ scsi_cdrom_command_nec(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
         case GPCMD_AUDIO_TRACK_SEARCH_NEC:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
+            dev->was_cached = 0;
+
             if ((dev->drv->image_path[0] == 0x00) || (dev->drv->cd_status <= CD_STATUS_DVD))
                 scsi_cdrom_illegal_mode(dev);
             else {
-                pos                = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
-                ret                = cdrom_audio_track_search(dev->drv, pos, cdb[9] & 0xc0, cdb[1] & 1);
-                dev->drv->audio_op = (cdb[1] & 1) ? 0x03 : 0x02;
+                pos                 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
+                ret                 = cdrom_audio_track_search(dev->drv, pos, cdb[9] & 0xc0, cdb[1] & 1);
+
+                dev->drv->seek_diff = ABS(dev->sector_pos - dev->drv->seek_pos);
+                dev->sector_pos     = dev->drv->seek_pos;
 
                 if (ret)
                     scsi_cdrom_command_complete(dev);
@@ -1887,7 +1969,6 @@ scsi_cdrom_command_nec(void *sc, const uint8_t *cdb, int32_t *BufLen)
         case GPCMD_STILL_NEC:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             cdrom_audio_pause_resume(dev->drv, 0x00);
-            dev->drv->audio_op = 0x01;
             scsi_cdrom_command_complete(dev);
             cmd_stat = 0x01;
             break;
@@ -1902,12 +1983,14 @@ scsi_cdrom_command_nec(void *sc, const uint8_t *cdb, int32_t *BufLen)
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             scsi_cdrom_stop(sc);
             cdrom_eject(dev->id);
+            dev->toc_cached = 0;
             scsi_cdrom_command_complete(dev);
             cmd_stat = 0x01;
             break;
 
         case GPCMD_READ_SUBCODEQ_PLAYING_STATUS_NEC:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = (dev->drv->cached_sector == -1);
 
             alloc_length = cdb[1] & 0x1f;
             len          = 10;
@@ -1936,6 +2019,8 @@ scsi_cdrom_command_nec(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
         case GPCMD_READ_DISC_INFORMATION_NEC:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = dev->toc_cached;
+
             /*
                NEC manual claims 4 bytes but the Linux kernel
                (namely sr_vendor.c) actually states otherwise.
@@ -1945,6 +2030,8 @@ scsi_cdrom_command_nec(void *sc, const uint8_t *cdb, int32_t *BufLen)
             ret = cdrom_read_disc_info_toc(dev->drv, dev->buffer, cdb[2], cdb[1] & 3);
             len = 22;
             if (ret) {
+                scsi_cdrom_cache_toc(dev);
+
                 scsi_cdrom_set_buf_len(dev, BufLen, &len);
                 scsi_cdrom_data_command_finish(dev, len, len, len, 0);
             } else
@@ -1976,12 +2063,15 @@ scsi_cdrom_command_pioneer(void *sc, const uint8_t *cdb, int32_t *BufLen)
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             scsi_cdrom_stop(sc);
             cdrom_eject(dev->id);
+            dev->toc_cached = 0;
             scsi_cdrom_command_complete(dev);
             cmd_stat = 0x01;
             break;
 
         case GPCMD_READ_TOC_PIONEER:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = dev->toc_cached;
+
             scsi_cdrom_buf_alloc(dev, 4);
 
             if (dev->drv->ops == NULL)
@@ -1991,6 +2081,8 @@ scsi_cdrom_command_pioneer(void *sc, const uint8_t *cdb, int32_t *BufLen)
                 len = 4;
 
                 if (ret) {
+                    scsi_cdrom_cache_toc(dev);
+
                     scsi_cdrom_set_buf_len(dev, BufLen, &len);
                     scsi_cdrom_data_command_finish(dev, len, len, len, 0);
                 } else
@@ -2001,6 +2093,7 @@ scsi_cdrom_command_pioneer(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
         case GPCMD_READ_SUBCODEQ_PIONEER:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = (dev->drv->cached_sector != -1);
 
             alloc_length = cdb[1] & 0x1f;
             len          = 9;
@@ -2019,6 +2112,7 @@ scsi_cdrom_command_pioneer(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
                 memset(dev->buffer, 0, len);
                 cdrom_get_current_subcodeq(dev->drv, &dev->buffer[1]);
+                scsi_cdrom_one_sector_seek(dev);
                 scsi_cdrom_log(dev->log, "Audio Status = %02x\n", dev->buffer[0]);
 
                 scsi_cdrom_set_buf_len(dev, BufLen, &alloc_length);
@@ -2029,15 +2123,18 @@ scsi_cdrom_command_pioneer(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
         case GPCMD_AUDIO_TRACK_SEARCH_PIONEER:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
+            dev->was_cached = 0;
+
             if ((dev->drv->image_path[0] == 0x00) || (dev->drv->cd_status <= CD_STATUS_DVD))
                 ret = 0;
             else {
                 pos                = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
                 ret                = cdrom_audio_track_search_pioneer(dev->drv, pos, cdb[1] & 1);
-
-                dev->drv->audio_op = (cdb[1] & 1) ? 0x03 : 0x02;
             }
 
+            dev->drv->seek_diff = ABS(dev->sector_pos - dev->drv->seek_pos);
+            dev->sector_pos     = dev->drv->seek_pos;
+
             if (ret)
                 scsi_cdrom_command_complete(dev);
             else
@@ -2156,13 +2253,17 @@ scsi_cdrom_command_toshiba(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
         case GPCMD_AUDIO_TRACK_SEARCH_TOSHIBA:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
+            dev->was_cached = 0;
+
             if ((dev->drv->image_path[0] == 0x00) || (dev->drv->cd_status <= CD_STATUS_DVD)) {
                 scsi_cdrom_illegal_mode(dev);
                 break;
             }
-            pos                = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
-            ret                = cdrom_audio_track_search(dev->drv, pos, cdb[9] & 0xc0, cdb[1] & 1);
-            dev->drv->audio_op = (cdb[1] & 1) ? 0x03 : 0x02;
+            pos                 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
+            ret                 = cdrom_audio_track_search(dev->drv, pos, cdb[9] & 0xc0, cdb[1] & 1);
+
+            dev->drv->seek_diff = ABS(dev->sector_pos - dev->drv->seek_pos);
+            dev->sector_pos     = dev->drv->seek_pos;
 
             if (ret)
                 scsi_cdrom_command_complete(dev);
@@ -2191,7 +2292,6 @@ scsi_cdrom_command_toshiba(void *sc, const uint8_t *cdb, int32_t *BufLen)
         case GPCMD_STILL_TOSHIBA:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             cdrom_audio_pause_resume(dev->drv, 0x00);
-            dev->drv->audio_op = 0x01;
             scsi_cdrom_command_complete(dev);
             cmd_stat = 0x01;
             break;
@@ -2206,12 +2306,14 @@ scsi_cdrom_command_toshiba(void *sc, const uint8_t *cdb, int32_t *BufLen)
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             scsi_cdrom_stop(sc);
             cdrom_eject(dev->id);
+            dev->toc_cached = 0;
             scsi_cdrom_command_complete(dev);
             cmd_stat = 0x01;
             break;
 
         case GPCMD_READ_SUBCODEQ_PLAYING_STATUS_TOSHIBA:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = (dev->drv->cached_sector != -1);
 
             alloc_length = cdb[1] & 0x1f;
             len          = 10;
@@ -2230,6 +2332,7 @@ scsi_cdrom_command_toshiba(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
                 memset(dev->buffer, 0, len);
                 dev->buffer[0] = cdrom_get_current_subcodeq_playstatus(dev->drv, &dev->buffer[1]);
+                scsi_cdrom_one_sector_seek(dev);
                 scsi_cdrom_log(dev->log, "Audio Status = %02x\n", dev->buffer[0]);
 
                 scsi_cdrom_set_buf_len(dev, BufLen, &alloc_length);
@@ -2240,6 +2343,8 @@ scsi_cdrom_command_toshiba(void *sc, const uint8_t *cdb, int32_t *BufLen)
 
         case GPCMD_READ_DISC_INFORMATION_TOSHIBA:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = dev->toc_cached;
+
             scsi_cdrom_buf_alloc(dev, 4);
 
             if (dev->drv->ops == NULL)
@@ -2248,6 +2353,8 @@ scsi_cdrom_command_toshiba(void *sc, const uint8_t *cdb, int32_t *BufLen)
                 ret = cdrom_read_disc_info_toc(dev->drv, dev->buffer, cdb[2], cdb[1] & 3);
                 len = 4;
                 if (ret) {
+                    scsi_cdrom_cache_toc(dev);
+
                     scsi_cdrom_set_buf_len(dev, BufLen, &len);
                     scsi_cdrom_data_command_finish(dev, len, len, len, 0);
                 } else
@@ -2255,6 +2362,25 @@ scsi_cdrom_command_toshiba(void *sc, const uint8_t *cdb, int32_t *BufLen)
             }
             cmd_stat = 0x01;
             break;
+
+        case GPCMD_READ_CDROM_MODE_TOSHIBA:
+            scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = (dev->drv->cached_sector != -1);
+
+            scsi_cdrom_buf_alloc(dev, 1);
+
+            alloc_length    = 1;
+
+            len             = alloc_length;
+            dev->buffer[0]  = cdrom_get_current_mode(dev->drv);
+
+            scsi_cdrom_one_sector_seek(dev);
+
+            scsi_cdrom_set_buf_len(dev, BufLen, &len);
+            scsi_cdrom_data_command_finish(dev, len, len, len, 0);
+
+            cmd_stat = 0x01;
+            break;
     }
 
     return cmd_stat;
@@ -2284,6 +2410,8 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
     int           toc_format;
     int32_t      *BufLen;
 
+    dev->was_cached  = -1;
+
     if (dev->drv->bus_type == CDROM_BUS_SCSI) {
         BufLen = &scsi_devices[scsi_bus][scsi_id].buffer_length;
         dev->tf->status &= ~ERR_STAT;
@@ -2295,6 +2423,8 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
     dev->packet_len  = 0;
     dev->request_pos = 0;
 
+    dev->block_len   = 0;
+
     memcpy(dev->current_cdb, cdb, 12);
 
 #if ENABLE_SCSI_CDROM_LOG == 2
@@ -2309,8 +2439,9 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                        cdb[8], cdb[9], cdb[10], cdb[11]);
 #endif
 
-    msf             = cdb[1] & 2;
-    dev->sector_len = 0;
+    msf                   = cdb[1] & 2;
+    dev->sector_len       = 0;
+    dev->requested_blocks = 0;
 
     scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
 
@@ -2326,17 +2457,21 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
         scsi_cdrom_sense_clear(dev, cdb[0]);
     }
 
-    if ((dev->ven_cmd == NULL) || (dev->ven_cmd(sc, cdb, BufLen) == 0x00))  switch (dev->current_cdb[0]) {
+    if ((dev->ven_cmd == NULL) ||
+        (dev->ven_cmd(sc, cdb, BufLen) == 0x00))  switch (dev->current_cdb[0]) {
         case GPCMD_TEST_UNIT_READY:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             scsi_cdrom_command_complete(dev);
             break;
 
         case GPCMD_REZERO_UNIT:
+            dev->was_cached                   = 0;
             scsi_cdrom_stop(sc);
-            dev->sector_pos = dev->sector_len = 0;
+            dev->requested_blocks             = 0;
             dev->drv->seek_diff               = dev->drv->seek_pos;
             cdrom_seek(dev->drv, 0, 0);
+            dev->sector_pos                   = dev->drv->seek_pos;
+            dev->drv->cached_sector           = -1;
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             break;
 
@@ -2365,6 +2500,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
         case GPCMD_SCAN_PIONEER:
         case GPCMD_AUDIO_SCAN:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
+            dev->was_cached = 0;
 
             if ((dev->drv->image_path[0] == 0x00) ||
                 (dev->drv->cd_status <= CD_STATUS_DVD)) {
@@ -2373,7 +2509,10 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
             }
 
             pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
-            ret = cdrom_audio_scan(dev->drv, pos, 0);
+            ret = cdrom_audio_scan(dev->drv, pos);
+
+            dev->drv->seek_diff   = ABS(dev->sector_pos - dev->drv->seek_pos);
+            dev->sector_pos       = dev->drv->seek_pos;
 
             if (ret)
                 scsi_cdrom_command_complete(dev);
@@ -2397,6 +2536,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
         case GPCMD_READ_TOC_PMA_ATIP:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = dev->toc_cached;
 
             max_len = cdb[7];
             max_len <<= 8;
@@ -2417,6 +2557,8 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                 if (len == -1)
                     scsi_cdrom_invalid_field(dev, dev->drv->inv_field);
                 else {
+                    scsi_cdrom_cache_toc(dev);
+
                     scsi_cdrom_set_buf_len(dev, BufLen, &len);
                     scsi_cdrom_data_command_finish(dev, len, len, len, 0);
                 }
@@ -2424,6 +2566,16 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                 scsi_cdrom_invalid_field(dev, toc_format);
             break;
 
+        case GPCMD_PLAY_CD:
+            /*
+               According to the ATAPI specification, this was actually READ CD
+               on early drives.
+             */
+            if (!dev->drv->is_early) {
+                scsi_cdrom_illegal_opcode(dev, dev->current_cdb[0]);
+                break;
+            }
+            fallthrough;
         case GPCMD_READ_6:
         case GPCMD_READ_10:
         case GPCMD_READ_12:
@@ -2432,9 +2584,11 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
         case GPCMD_READ_CD:
         case GPCMD_READ_CD_MSF:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
-            alloc_length = dev->drv->sector_size;
+            dev->was_cached = 0;
 
-            switch (cdb[0]) {
+            alloc_length    = dev->drv->sector_size;
+
+            switch (dev->current_cdb[0]) {
                 case GPCMD_READ_6:
                     dev->sector_len = cdb[4];
                     /*
@@ -2469,6 +2623,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                 case GPCMD_READ_CD_MSF:
                     msf = 1;
                     fallthrough;
+                case GPCMD_PLAY_CD:
                 case GPCMD_READ_CD_OLD:
                 case GPCMD_READ_CD:
                     alloc_length    = 2856;
@@ -2513,22 +2668,30 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                     dev->drv->seek_diff = ABS((int) (pos - dev->sector_pos));
                     dev->drv->seek_pos  = dev->sector_pos;                   
 
-                    if (dev->use_cdb_9 && ((cdb[0] == GPCMD_READ_10) ||
-                        (cdb[0] == GPCMD_READ_12)))
-                        ret = scsi_cdrom_read_blocks(dev, &alloc_length,
-                                                     cdb[9] & 0xc0);
+                    /* Any of these commands stop the audio playing. */
+                    cdrom_stop(dev->drv);
+
+                    if (dev->use_cdb_9 &&
+                        ((dev->current_cdb[0] == GPCMD_READ_10) ||
+                         (dev->current_cdb[0] == GPCMD_READ_12)))
+                        dev->vendor_type  = cdb[9] & 0xc0;
                     else
-                        ret = scsi_cdrom_read_blocks(dev, &alloc_length, 0);
+                        dev->vendor_type  = 0x00;
+
+                    dev->block_len      = 0xffffffff;
+                    dev->buffer_pos     = 0x00000000;
+
+                    ret                 = scsi_cdrom_read_blocks(dev);
+                    alloc_length        = dev->requested_blocks * dev->block_len;
 
                     if (ret > 0) {
-                        dev->requested_blocks = max_len;
                         dev->packet_len       = alloc_length;
 
                         scsi_cdrom_set_buf_len(dev, BufLen,
                                                (int32_t *) &dev->packet_len);
 
                         scsi_cdrom_data_command_finish(dev, alloc_length,
-                                                       alloc_length / dev->requested_blocks,
+                                                       dev->block_len,
                                                        alloc_length, 0);
 
                         if (dev->packet_status != PHASE_COMPLETE)
@@ -2553,11 +2716,14 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
         case GPCMD_READ_HEADER:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
-            alloc_length = 2352;
 
-            len             = (cdb[7] << 8) | cdb[8];
-            dev->sector_len = 1;
-            dev->sector_pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
+            alloc_length          = 2352;
+
+            len                   = (cdb[7] << 8) | cdb[8];
+            dev->sector_len       = 1;
+            dev->sector_pos       = (cdb[2] << 24) | (cdb[3] << 16) |
+                                    (cdb[4] << 8) | cdb[5];
+            dev->was_cached       = (dev->drv->cached_sector == dev->sector_pos);
             scsi_cdrom_log(dev->log, "READ HEADER: Length: %i, LBA: %i\n",
                            dev->sector_len, dev->sector_pos);
 
@@ -2568,10 +2734,15 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                 dev->packet_len       = len;
                 scsi_cdrom_buf_alloc(dev, 2352);
 
-                dev->drv->seek_diff   = ABS((int) (pos - dev->sector_pos));
-                dev->drv->seek_pos    = dev->sector_pos;
+                scsi_cdrom_one_sector_seek(dev);
 
-                ret = scsi_cdrom_read_blocks(dev, &alloc_length, 0);
+                /* Any of these commands stop the audio playing. */
+                cdrom_stop(dev->drv);
+
+                dev->vendor_type      = 0x00;
+
+                dev->buffer_pos       = 0x00000000;
+                ret = scsi_cdrom_read_blocks(dev);
 
                 if (ret > 0) {
                     uint8_t header[4] = { 0 };
@@ -2628,7 +2799,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
             else
                 block_desc = !((cdb[1] >> 3) & 1);
 
-            if (cdb[0] == GPCMD_MODE_SENSE_6) {
+            if (dev->current_cdb[0] == GPCMD_MODE_SENSE_6) {
                 len = cdb[4];
                 scsi_cdrom_buf_alloc(dev, 256);
             } else {
@@ -2659,7 +2830,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                 else
                     max_len = 3; /* Audio or mixed-mode CD. */
 
-                if (cdb[0] == GPCMD_MODE_SENSE_6) {
+                if (dev->current_cdb[0] == GPCMD_MODE_SENSE_6) {
                     len            = scsi_cdrom_mode_sense(dev, dev->buffer, 4, cdb[2], block_desc);
                     len            = MIN(len, alloc_length);
                     dev->buffer[0] = len - 1;
@@ -2692,7 +2863,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
         case GPCMD_MODE_SELECT_10:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_OUT);
 
-            if (cdb[0] == GPCMD_MODE_SELECT_6) {
+            if (dev->current_cdb[0] == GPCMD_MODE_SELECT_6) {
                 len = cdb[4];
                 scsi_cdrom_buf_alloc(dev, 256);
             } else {
@@ -2897,7 +3068,10 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                     gesn_event_header->notification_class |= GESN_MEDIA;
 
                     /* Bits 7-4 = Reserved, Bits 4-1 = Media Status. */
-                    dev->buffer[4] = dev->media_status;
+                    if (dev->drv->cd_status == CD_STATUS_EMPTY)
+                        dev->buffer[4] = MEC_MEDIA_REMOVAL;
+                    else
+                        dev->buffer[4] = dev->unit_attention ? MEC_NEW_MEDIA : MEC_NO_CHANGE;
                     /* Power Status (1 = Active). */
                     dev->buffer[5] = 1;
                     dev->buffer[6] = 0;
@@ -2925,6 +3099,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
         case GPCMD_READ_DISC_INFORMATION:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = dev->toc_cached;
 
             max_len = cdb[7];
             max_len <<= 8;
@@ -2936,6 +3111,8 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
             len = MIN(34, max_len);
 
+            scsi_cdrom_cache_toc(dev);
+
             scsi_cdrom_set_buf_len(dev, BufLen, &len);
 
             scsi_cdrom_data_command_finish(dev, len, len, len, 0);
@@ -2943,6 +3120,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
         case GPCMD_READ_TRACK_INFORMATION:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = dev->toc_cached;
 
             max_len = cdb[7];
             max_len <<= 8;
@@ -2961,6 +3139,8 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                     dev->buffer[1] = (max_len - 2) & 0xff;
                 }
 
+                scsi_cdrom_cache_toc(dev);
+
                 scsi_cdrom_set_buf_len(dev, BufLen, &len);
                 scsi_cdrom_data_command_finish(dev, len, len, max_len, 0);
             } else
@@ -2977,7 +3157,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
             len = 0;
 
-            switch (cdb[0]) {
+            switch (dev->current_cdb[0]) {
                 case GPCMD_PLAY_AUDIO_10:
                     msf = 0;
                     pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
@@ -3017,9 +3197,11 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
             }
 
             if (ret && (dev->drv->image_path[0] != 0x00) &&
-                (dev->drv->cd_status > CD_STATUS_DVD))
-                ret = cdrom_audio_play(dev->drv, pos, len, msf);
-            else
+                (dev->drv->cd_status > CD_STATUS_DVD)) {
+                ret                   = cdrom_audio_play(dev->drv, pos, len, msf);
+
+                dev->sector_pos       = dev->drv->seek_pos;
+            } else
                 ret = 0;
 
             if (ret)
@@ -3030,13 +3212,14 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
         case GPCMD_READ_SUBCHANNEL:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = (dev->drv->cached_sector != -1);
 
             max_len = cdb[7];
             max_len <<= 8;
             max_len |= cdb[8];
             msf = (cdb[1] >> 1) & 1;
 
-            scsi_cdrom_buf_alloc(dev, 32);
+            scsi_cdrom_buf_alloc(dev, 128);
 
             scsi_cdrom_log(dev->log, "Getting page %i (%s)\n", cdb[3],
                            msf ? "MSF" : "LBA");
@@ -3068,23 +3251,23 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
                 len = alloc_length;
 
-                memset(dev->buffer, 0, 24);
-                pos                = 0x00;
-                dev->buffer[pos++] = 0x00;
-                dev->buffer[pos++] = 0x00;    /* Audio status */
-                dev->buffer[pos++] = 0x00;
-                dev->buffer[pos++] = 0x00;    /* Subchannel length */
-                dev->buffer[pos++] = cdb[3];    /* Format code */
+                memset(dev->buffer, 0x00, 128);
 
-                if (alloc_length != 4) {
+                if (alloc_length > 4) {
+                    dev->buffer[4] = cdb[3];    /* Format code */
                     cdrom_get_current_subchannel(dev->drv, &dev->buffer[4], msf);
 
-                    dev->buffer[2] = alloc_length - 4;
+                    alloc_length = MIN(max_len, alloc_length);
+
+                    dev->buffer[3] = (alloc_length - 4) & 0xff;
+                    dev->buffer[4] = cdb[3];    /* Format code */
                 }
 
                 dev->buffer[1] = cdrom_get_current_status(dev->drv);
 
-                scsi_cdrom_log(dev->log, "Audio Status = %02x\n", dev->buffer[1]);
+                scsi_cdrom_log(dev->log, "Audio status: %02X\n", dev->buffer[1]);
+
+                scsi_cdrom_one_sector_seek(dev);
 
                 len = MIN(len, max_len);
                 scsi_cdrom_set_buf_len(dev, BufLen, &len);
@@ -3097,7 +3280,6 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
 
             alloc_length = (((uint32_t) cdb[8]) << 8) | ((uint32_t) cdb[9]);
-
             scsi_cdrom_buf_alloc(dev, alloc_length);
 
             if ((cdb[7] < 0xc0) && (dev->drv->cd_status != CD_STATUS_DVD))
@@ -3146,10 +3328,13 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                        This makes no sense under emulation as this would do
                        absolutely nothing, so just break.
                      */
+                    dev->toc_cached = 0;
+                    scsi_cdrom_cache_toc(dev);
                     break;
                 case 2: /* Eject the disc if possible. */
                     scsi_cdrom_stop(sc);
                     cdrom_eject(dev->id);
+                    dev->toc_cached = 0;
                     break;
                 case 3: /* Load the disc (close tray). */
                     cdrom_reload(dev->id);
@@ -3243,9 +3428,10 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                 dev->buffer[1] = 0x80;    /* Removable */
 
                 if (dev->drv->bus_type == CDROM_BUS_SCSI) {
-                    dev->buffer[3] = cdrom_get_scsi_std(dev->drv->type);
+                    dev->buffer[2] = (dev->ven_cmd == scsi_cdrom_command_nec) ?
+                                     0x00 : cdrom_get_scsi_std(dev->drv->type);
 
-                    if (!strcmp(cdrom_get_vendor(dev->drv->type), "TOSHIBA"))
+                    if (dev->drv->is_toshiba)
                         /* Linked Command and Relative Addressing supported */
                         dev->buffer[7] = 0x88;
                 } else {
@@ -3265,7 +3451,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                 ide_padstr8(dev->buffer + 32,  4,
                             cdrom_get_revision(dev->drv->type));    /* Revision */
 
-                if (cdrom_has_date(dev->drv->type)) {
+                if (dev->drv->is_pioneer) {
                     dev->buffer[36] = 0x20;
                     ide_padstr8(dev->buffer + 37, 10, "1991/01/01");                      /* Date */
                 }
@@ -3299,15 +3485,15 @@ atapi_out:
         case GPCMD_PAUSE_RESUME:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
             cdrom_audio_pause_resume(dev->drv, cdb[8] & 0x01);
-            dev->drv->audio_op = (cdb[8] & 0x01) ? 0x03 : 0x01;
             scsi_cdrom_command_complete(dev);
             break;
 
         case GPCMD_SEEK_6:
         case GPCMD_SEEK_10:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_STATUS);
+            dev->was_cached = 0;
 
-            switch (cdb[0]) {
+            switch (dev->current_cdb[0]) {
                 case GPCMD_SEEK_6:
                     pos = (cdb[2] << 8) | cdb[3];
                     break;
@@ -3324,16 +3510,20 @@ atapi_out:
             /* Stop the audio playing. */
             cdrom_stop(dev->drv);
 
-            if (dev->use_cdb_9 && (cdb[0] == GPCMD_SEEK_10))
+            if (dev->use_cdb_9 && (dev->current_cdb[0] == GPCMD_SEEK_10))
                 cdrom_seek(dev->drv, pos, cdb[9] & 0xc0);
             else
                 cdrom_seek(dev->drv, pos, 0);
 
+            dev->sector_pos         = dev->drv->seek_pos;
+            dev->drv->cached_sector = -1;
+
             scsi_cdrom_command_complete(dev);
             break;
 
         case GPCMD_READ_CDROM_CAPACITY:
             scsi_cdrom_set_phase(dev, SCSI_PHASE_DATA_IN);
+            dev->was_cached = dev->toc_cached;
 
             scsi_cdrom_buf_alloc(dev, 8);
 
@@ -3348,6 +3538,8 @@ atapi_out:
 
             scsi_cdrom_log(dev->log, "CD-ROM Capacity: %08X\n",
                            dev->drv->cdrom_capacity - 1);
+
+            scsi_cdrom_cache_toc(dev);
             scsi_cdrom_set_buf_len(dev, BufLen, &len);
 
             scsi_cdrom_data_command_finish(dev, len, len, len, 0);
@@ -3366,7 +3558,7 @@ atapi_out:
             break;
 
         default:
-            scsi_cdrom_illegal_opcode(dev, cdb[0]);
+            scsi_cdrom_illegal_opcode(dev, dev->current_cdb[0]);
             break;
     }
 
@@ -3464,17 +3656,24 @@ scsi_cdrom_phase_data_out(scsi_common_t *sc)
 
                 pos += 2;
 
-                if (dev->is_sony && (page == 0x08) && (page_len == 0x02))
+                /* Ignore any page codes with zero length. */
+                if (page_len == 0)
+                    continue;
+
+                if (dev->drv->is_sony && (page == 0x08) && (page_len == 0x02))
                     dev->drv->sony_msf = dev->buffer[pos] & 0x01;
 
                 if (!(dev->ms_page_flags & (1LL << ((uint64_t) page)))) {
                     scsi_cdrom_log(dev->log, "Unimplemented page %02X\n", page);
                     error |= 1;
+                    break;
                 } else {
                     for (i = 0; i < page_len; i++) {
                         uint8_t pg = page;
 
-                        if (dev->is_sony && (page == GPMODE_CDROM_AUDIO_PAGE_SONY) && (i >= 6) && (i <= 13))
+                        if (dev->drv->is_sony &&
+                            (page == GPMODE_CDROM_AUDIO_PAGE_SONY) &&
+                            (i >= 6) && (i <= 13))
                             pg = GPMODE_CDROM_AUDIO_PAGE;
 
                         ch      = dev->ms_pages_changeable.pages[pg][i + 2];
@@ -3488,9 +3687,13 @@ scsi_cdrom_phase_data_out(scsi_common_t *sc)
                                                "%02X on page %02X\n", i + 2, page);
                                 scsi_cdrom_invalid_field_pl(dev, val);
                                 error |= 1;
+                                break;
                             }
                         }
                     }
+
+                    if (error)
+                        break;
                 }
 
                 pos += page_len;
@@ -3506,11 +3709,12 @@ scsi_cdrom_phase_data_out(scsi_common_t *sc)
 
             if (error) {
                 scsi_cdrom_buf_free(dev);
+                scsi_cdrom_command_stop((scsi_common_t *) dev);
                 return 0;
             }
             break;
         case 0xc9:
-            if (dev->is_sony) {
+            if (dev->drv->is_sony) {
                 for (i = 0; i < 18; i++) {
                     if ((i >= 8) && (i <= 15))
                         dev->ms_pages_saved.pages[GPMODE_CDROM_AUDIO_PAGE][i] =
@@ -3665,12 +3869,15 @@ scsi_cdrom_drive_reset(const int c)
     dev->id  = c;
     dev->drv = drv;
 
-    dev->cur_lun = SCSI_LUN_USE_CDB;
+    dev->cur_lun       = SCSI_LUN_USE_CDB;
 
-    drv->insert      = scsi_cdrom_insert;
-    drv->get_volume  = scsi_cdrom_get_volume;
-    drv->get_channel = scsi_cdrom_get_channel;
-    drv->close       = scsi_cdrom_close;
+    dev->toc_cached    = 0;
+    drv->cached_sector = -1;
+
+    drv->insert        = scsi_cdrom_insert;
+    drv->get_volume    = scsi_cdrom_get_volume;
+    drv->get_channel   = scsi_cdrom_get_channel;
+    drv->close         = scsi_cdrom_close;
 
     drv->sector_size = 2048;
     (void) scsi_cdrom_update_sector_flags(dev);
@@ -3680,22 +3887,19 @@ scsi_cdrom_drive_reset(const int c)
 
         dev->ven_cmd               = NULL;
         memset(dev->ven_cmd_is_data, 0x00, sizeof(dev->ven_cmd_is_data));
-        dev->is_sony               = 0;
         dev->use_cdb_9             = 0;
         dev->ms_page_flags         = scsi_cdrom_ms_page_flags_scsi;
         dev->ms_pages_default      = scsi_cdrom_ms_pages_default_scsi;
         dev->ms_pages_changeable   = scsi_cdrom_ms_pages_changeable_scsi;
 
-        if (!strcmp(vendor, "CHINON"))
+        if (dev->drv->is_chinon)
             dev->ven_cmd               = scsi_cdrom_command_chinon;
-        else if (!strcmp(vendor, "DEC") || !strcmp(vendor, "ShinaKen") ||
-                 !strcmp(vendor, "SONY") || !strcmp(vendor, "TEXEL")) {
+        else if (dev->drv->is_sony) {
             dev->ven_cmd               = scsi_cdrom_command_dec_sony_texel;
             dev->ven_cmd_is_data[0xc0] = 1;
             dev->ven_cmd_is_data[0xc1] = 1;
             dev->ven_cmd_is_data[0xc2] = 1;
             dev->ven_cmd_is_data[0xc3] = 1;
-            dev->is_sony               = 1;
             dev->ms_page_flags         = scsi_cdrom_ms_page_flags_sony_scsi;
             dev->ms_pages_default      = scsi_cdrom_ms_pages_default_sony_scsi;
             dev->ms_pages_changeable   = scsi_cdrom_ms_pages_changeable_sony_scsi;
@@ -3705,12 +3909,12 @@ scsi_cdrom_drive_reset(const int c)
             dev->ven_cmd               = scsi_cdrom_command_nec;
             dev->ven_cmd_is_data[0xdd] = 1;
             dev->ven_cmd_is_data[0xde] = 1;
-        } else if (!strcmp(vendor, "PIONEER")) {
+        } else if (dev->drv->is_pioneer) {
             dev->ven_cmd               = scsi_cdrom_command_pioneer;
             dev->ven_cmd_is_data[0xc1] = 1;
             dev->ven_cmd_is_data[0xc2] = 1;
             dev->ven_cmd_is_data[0xc3] = 1;
-        } else if (!strcmp(vendor, "TOSHIBA")) {
+        } else if (dev->drv->is_toshiba) {
             dev->ven_cmd               = scsi_cdrom_command_toshiba;
             dev->ven_cmd_is_data[0xc6] = 1;
             dev->ven_cmd_is_data[0xc7] = 1;
@@ -3746,7 +3950,6 @@ scsi_cdrom_drive_reset(const int c)
         if (id) {
             dev->ven_cmd               = NULL;
             memset(dev->ven_cmd_is_data, 0x00, sizeof(dev->ven_cmd_is_data));
-            dev->is_sony               = 0;
             dev->use_cdb_9             = 0;
             dev->ms_page_flags         = scsi_cdrom_ms_page_flags;
             dev->ms_pages_default      = scsi_cdrom_ms_pages_default;
@@ -3764,6 +3967,8 @@ scsi_cdrom_drive_reset(const int c)
             id->phase_data_out         = scsi_cdrom_phase_data_out;
             id->command_stop           = scsi_cdrom_command_stop;
             id->bus_master_error       = scsi_cdrom_bus_master_error;
+            id->read                   = scsi_cdrom_read;
+            id->write                  = NULL;
             id->interrupt_drq          = dev->drv->is_early;
 
             valid = 1;
diff --git a/src/sound/sound.c b/src/sound/sound.c
index 28cb96629..0c8dffe12 100644
--- a/src/sound/sound.c
+++ b/src/sound/sound.c
@@ -274,83 +274,89 @@ sound_cd_thread(UNUSED(void *param))
         temp_buffer[0] = temp_buffer[1] = 0;
 
         for (uint8_t i = 0; i < CDROM_NUM; i++) {
-            if ((cdrom[i].bus_type == CDROM_BUS_DISABLED) || (cdrom[i].cd_status == CD_STATUS_EMPTY))
+            /* Just in case the thread is in a loop when it gets terminated. */
+            if (!cdaudioon)
+                break;
+
+            if ((cdrom[i].bus_type == CDROM_BUS_DISABLED) ||
+                (cdrom[i].cd_status != CD_STATUS_PLAYING))
                 continue;
-            const uint32_t lba = cdrom[i].seek_pos;
-            const int r        = cdrom_audio_callback(&(cdrom[i]), cd_buffer[i], CD_BUFLEN * 2);
-            if (!cdrom[i].sound_on || !r)
-                continue;
-            const int pre      = cdrom_is_pre(&(cdrom[i]), lba);
+            const int ret = cdrom_audio_callback(&(cdrom[i]), cd_buffer[i],
+                                                 CD_BUFLEN * 2);
 
-
-            if (cdrom[i].get_volume) {
-                audio_vol_l = cd_audio_volume_lut[cdrom[i].get_volume(cdrom[i].priv, 0)];
-                audio_vol_r = cd_audio_volume_lut[cdrom[i].get_volume(cdrom[i].priv, 1)];
-            } else {
-                audio_vol_l = cd_audio_volume_lut[255];
-                audio_vol_r = cd_audio_volume_lut[255];
-            }
-
-            if (cdrom[i].get_channel) {
-                channel_select[0] = (int) cdrom[i].get_channel(cdrom[i].priv, 0);
-                channel_select[1] = (int) cdrom[i].get_channel(cdrom[i].priv, 1);
-            } else {
-                channel_select[0] = 1;
-                channel_select[1] = 2;
-            }
-
-            for (int c = 0; c < CD_BUFLEN * 2; c += 2) {
-                /*Apply ATAPI channel select*/
-                cd_buffer_temp[0] = cd_buffer_temp[1] = 0.0;
-
-                if ((audio_vol_l != 0.0) && (channel_select[0] != 0)) {
-                    if (channel_select[0] & 1)
-                        cd_buffer_temp[0] += ((double) cd_buffer[i][c]); /* Channel 0 => Port 0 */
-                    if (channel_select[0] & 2)
-                        cd_buffer_temp[0] += ((double) cd_buffer[i][c + 1]); /* Channel 1 => Port 0 */
-
-                    cd_buffer_temp[0] *= audio_vol_l; /* Multiply Port 0 by Port 0 volume */
-
-                    if (pre)
-                        cd_buffer_temp[0] = deemph_iir(0, cd_buffer_temp[0]); /* De-emphasize if necessary */
-                }
-
-                if ((audio_vol_r != 0.0) && (channel_select[1] != 0)) {
-                    if (channel_select[1] & 1)
-                        cd_buffer_temp[1] += ((double) cd_buffer[i][c]); /* Channel 0 => Port 1 */
-                    if (channel_select[1] & 2)
-                        cd_buffer_temp[1] += ((double) cd_buffer[i][c + 1]); /* Channel 1 => Port 1 */
-
-                    cd_buffer_temp[1] *= audio_vol_r; /* Multiply Port 1 by Port 1 volume */
-
-                    if (pre)
-                        cd_buffer_temp[1] = deemph_iir(1, cd_buffer_temp[1]); /* De-emphasize if necessary */
-                }
-
-                /* Apply sound card CD volume and filters */
-                if (filter_cd_audio != NULL) {
-                    filter_cd_audio(0, &(cd_buffer_temp[0]), filter_cd_audio_p);
-                    filter_cd_audio(1, &(cd_buffer_temp[1]), filter_cd_audio_p);
-                }
-
-                if (sound_is_float) {
-                    cd_out_buffer[c] += (float) (cd_buffer_temp[0] / 32768.0);
-                    cd_out_buffer[c + 1] += (float) (cd_buffer_temp[1] / 32768.0);
+            if (ret) {
+                if (cdrom[i].get_volume) {
+                    audio_vol_l = cd_audio_volume_lut[cdrom[i].get_volume(cdrom[i].priv, 0)];
+                    audio_vol_r = cd_audio_volume_lut[cdrom[i].get_volume(cdrom[i].priv, 1)];
                 } else {
-                    temp_buffer[0] += (int) trunc(cd_buffer_temp[0]);
-                    temp_buffer[1] += (int) trunc(cd_buffer_temp[1]);
+                    audio_vol_l = cd_audio_volume_lut[255];
+                    audio_vol_r = cd_audio_volume_lut[255];
+                }
 
-                    if (temp_buffer[0] > 32767)
-                        temp_buffer[0] = 32767;
-                    if (temp_buffer[0] < -32768)
-                        temp_buffer[0] = -32768;
-                    if (temp_buffer[1] > 32767)
-                        temp_buffer[1] = 32767;
-                    if (temp_buffer[1] < -32768)
-                        temp_buffer[1] = -32768;
+                if (cdrom[i].get_channel) {
+                    channel_select[0] = (int) cdrom[i].get_channel(cdrom[i].priv, 0);
+                    channel_select[1] = (int) cdrom[i].get_channel(cdrom[i].priv, 1);
+                } else {
+                    channel_select[0] = 1;
+                    channel_select[1] = 2;
+                }
 
-                    cd_out_buffer_int16[c]     = (int16_t) temp_buffer[0];
-                    cd_out_buffer_int16[c + 1] = (int16_t) temp_buffer[1];
+                // uint16_t *cddab = (uint16_t *) cdrom[i].raw_buffer;
+                for (int c = 0; c < CD_BUFLEN * 2; c += 2) {
+                    /* Apply ATAPI channel select */
+                    cd_buffer_temp[0] = cd_buffer_temp[1] = 0.0;
+
+                    if ((audio_vol_l != 0.0) && (channel_select[0] != 0)) {
+                        if (channel_select[0] & 1)
+                            /* Channel 0 => Port 0 */
+                            cd_buffer_temp[0] += ((double) cd_buffer[i][c]);
+                        if (channel_select[0] & 2)
+                            /* Channel 1 => Port 0 */
+                            cd_buffer_temp[0] += ((double) cd_buffer[i][c + 1]);
+
+                        /* Multiply Port 0 by Port 0 volume */
+                        cd_buffer_temp[0] *= audio_vol_l;
+                    }
+
+                    if ((audio_vol_r != 0.0) && (channel_select[1] != 0)) {
+                        if (channel_select[1] & 1)
+                            /* Channel 0 => Port 1 */
+                            cd_buffer_temp[1] += ((double) cd_buffer[i][c]);
+                        if (channel_select[1] & 2)
+                            /* Channel 1 => Port 1 */
+                            cd_buffer_temp[1] += ((double) cd_buffer[i][c + 1]);
+
+                        /* Multiply Port 1 by Port 1 volume */
+                        cd_buffer_temp[1] *= audio_vol_r;
+                    }
+
+                    /* Apply sound card CD volume and filters */
+                    if (filter_cd_audio != NULL) {
+                        filter_cd_audio(0, &(cd_buffer_temp[0]),
+                                        filter_cd_audio_p);
+                        filter_cd_audio(1, &(cd_buffer_temp[1]),
+                                        filter_cd_audio_p);
+                    }
+
+                    if (sound_is_float) {
+                        cd_out_buffer[c] += (float) (cd_buffer_temp[0] / 32768.0);
+                        cd_out_buffer[c + 1] += (float) (cd_buffer_temp[1] / 32768.0);
+                    } else {
+                        temp_buffer[0] = (int) trunc(cd_buffer_temp[0]);
+                        temp_buffer[1] = (int) trunc(cd_buffer_temp[1]);
+
+                        if (temp_buffer[0] > 32767)
+                            temp_buffer[0] = 32767;
+                        if (temp_buffer[0] < -32768)
+                            temp_buffer[0] = -32768;
+                        if (temp_buffer[1] > 32767)
+                            temp_buffer[1] = 32767;
+                        if (temp_buffer[1] < -32768)
+                            temp_buffer[1] = -32768;
+
+                        cd_out_buffer_int16[c]     += (int16_t) temp_buffer[0];
+                        cd_out_buffer_int16[c + 1] += (int16_t) temp_buffer[1];
+                    }
                 }
             }
         }
diff --git a/src/utils/CMakeLists.txt b/src/utils/CMakeLists.txt
new file mode 100644
index 000000000..2ffe41f7b
--- /dev/null
+++ b/src/utils/CMakeLists.txt
@@ -0,0 +1,26 @@
+#
+# 86Box    A hypervisor and IBM PC system emulator that specializes in
+#          running old operating systems and software designed for IBM
+#          PC systems and compatibles from 1981 through fairly recent
+#          system designs based on the PCI bus.
+#
+#          This file is part of the 86Box distribution.
+#
+#          CMake build script.
+#
+# Authors: David Hrdlička, <hrdlickadavid@outlook.com>
+#          Jasmine Iwanek, <jriwanek@gmail.com>
+#
+#          Copyright 2020-2021 David Hrdlička.
+#          Copyright 2024      Jasmine Iwanek.
+#
+
+add_library(utils OBJECT
+    cJSON.c
+    crc.c
+    fifo.c
+    fifo8.c
+    ini.c
+    log.c
+    random.c
+)
diff --git a/src/cJSON.c b/src/utils/cJSON.c
similarity index 100%
rename from src/cJSON.c
rename to src/utils/cJSON.c
diff --git a/src/utils/crc.c b/src/utils/crc.c
new file mode 100644
index 000000000..096a94c72
--- /dev/null
+++ b/src/utils/crc.c
@@ -0,0 +1,77 @@
+/*
+ * 86Box    A hypervisor and IBM PC system emulator that specializes in
+ *          running old operating systems and software designed for IBM
+ *          PC systems and compatibles from 1981 through fairly recent
+ *          system designs based on the PCI bus.
+ *
+ *          This file is part of the 86Box distribution.
+ *
+ *          CRC implementation.
+ *
+ * Authors: Miran Grca, <mgrca8@gmail.com>
+ *
+ *          Copyright 2016-2025 Miran Grca.
+ */
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <wchar.h>
+#define HAVE_STDARG_H
+#include <86box/86box.h>
+#include <86box/timer.h>
+#include <86box/dma.h>
+#include <86box/nvr.h>
+#include <86box/random.h>
+#include <86box/plat.h>
+#include <86box/ui.h>
+#include <86box/crc.h>
+
+#ifdef ENABLE_CRC_LOG
+int d86f_do_log = ENABLE_CRC_LOG;
+
+static void
+crc_log(const char *fmt, ...)
+{
+    va_list ap;
+
+    if (crc_do_log) {
+        va_start(ap, fmt);
+        pclog_ex(fmt, ap);
+        va_end(ap);
+    }
+}
+#else
+#    define crc_log(fmt, ...)
+#endif
+
+void
+crc16_setup(uint16_t *crc_table, uint16_t poly)
+{
+    int      c = 256;
+    int      bc;
+    uint16_t temp;
+
+    while (c--) {
+        temp = c << 8;
+        bc   = 8;
+
+        while (bc--) {
+            if (temp & 0x8000)
+                temp = (temp << 1) ^ poly;
+            else
+                temp <<= 1;
+
+            crc_table[c] = temp;
+        }
+    }
+}
+
+void
+crc16_calc(uint16_t *crc_table, uint8_t byte, crc_t *crc_var)
+{
+    crc_var->word = (crc_var->word << 8) ^
+                    crc_table[(crc_var->word >> 8) ^ byte];
+}
diff --git a/src/fifo.c b/src/utils/fifo.c
similarity index 100%
rename from src/fifo.c
rename to src/utils/fifo.c
diff --git a/src/fifo8.c b/src/utils/fifo8.c
similarity index 100%
rename from src/fifo8.c
rename to src/utils/fifo8.c
diff --git a/src/ini.c b/src/utils/ini.c
similarity index 100%
rename from src/ini.c
rename to src/utils/ini.c
diff --git a/src/log.c b/src/utils/log.c
similarity index 100%
rename from src/log.c
rename to src/utils/log.c
diff --git a/src/random.c b/src/utils/random.c
similarity index 100%
rename from src/random.c
rename to src/utils/random.c