diff --git a/src/cdrom/cdrom.c b/src/cdrom/cdrom.c
index 2cdcc5a22..9e6c57e70 100644
--- a/src/cdrom/cdrom.c
+++ b/src/cdrom/cdrom.c
@@ -89,8 +89,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;
@@ -122,7 +124,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);
@@ -286,32 +288,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);
@@ -406,7 +415,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 };
@@ -417,8 +426,13 @@ 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);
+    pclog("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);
 
@@ -458,7 +472,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 */
 
@@ -466,7 +484,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;
@@ -527,14 +545,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;
@@ -586,6 +608,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;
         }
 
@@ -642,9 +674,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;
 
@@ -660,7 +692,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;
     }
@@ -668,7 +700,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;
     }
@@ -678,7 +710,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;
         }
@@ -688,12 +720,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;
         }
@@ -702,7 +734,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);
     }
 }
@@ -716,7 +748,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;
     }
@@ -724,7 +756,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;
     }
@@ -733,7 +765,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;
     }
@@ -741,7 +773,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);
     }
 }
@@ -755,7 +787,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;
     }
@@ -763,7 +795,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;
     }
@@ -771,7 +803,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;
     }
@@ -780,12 +812,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;
         }
@@ -794,7 +826,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);
     }
 }
@@ -808,7 +840,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;
     }
@@ -816,7 +848,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;
     }
@@ -824,7 +856,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;
     }
@@ -832,14 +864,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. */
@@ -851,31 +883,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;
@@ -890,7 +956,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);
@@ -900,6 +967,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)
@@ -1001,24 +1101,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)
 {
@@ -1067,7 +1149,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);
@@ -1197,6 +1279,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)
 {
@@ -1261,40 +1361,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;
@@ -1302,9 +1420,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;
 }
@@ -1313,15 +1434,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;
@@ -1331,13 +1455,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 {
@@ -1357,7 +1485,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) {
@@ -1371,7 +1499,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;
@@ -1391,8 +1519,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.
@@ -1400,10 +1526,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);
@@ -1424,6 +1551,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,39 +1574,37 @@ 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;
+                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:
                 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;
@@ -1501,15 +1628,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 {
@@ -1533,7 +1660,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;
@@ -1552,6 +1678,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,7 +1692,19 @@ cdrom_audio_play_toshiba(cdrom_t *dev, const uint32_t pos, const int type)
                 dev->cd_end = pos2;
                 break;
             } case 0x80:
-                dev->cd_end = (pos2 >> 24) & 0xff;
+                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:
                 if (pos == 0xffffffff) {
@@ -1577,55 +1717,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) {
@@ -1650,8 +1767,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;
 }
@@ -1659,9 +1776,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",
@@ -1674,17 +1796,29 @@ 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) {
+                // pclog("Format 0 on ATAPI\n");
+                break;
+            }
+            // pclog("Format 0 on SCSI\n");
+            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);
@@ -1714,26 +1848,37 @@ cdrom_get_current_subchannel(cdrom_t *dev, uint8_t *b, const int msf)
                 b[10] = (dat >> 8) & 0xff;
                 b[11] = dat & 0xff;
             }
-            break;
+            pclog("%02X %02X %02X %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], b[ 9], b[10], b[11]);
+            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]);
@@ -1842,7 +1987,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;
@@ -1851,6 +1996,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
@@ -1860,20 +2009,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;
 }
 
@@ -2041,14 +2195,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;
 
@@ -2108,7 +2259,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);
@@ -2195,7 +2346,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) {
@@ -2228,28 +2378,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) {
@@ -2281,7 +2432,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;
             }
         }
@@ -2617,7 +2768,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;
@@ -2641,57 +2792,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
@@ -2714,6 +2830,7 @@ cdrom_update_status(cdrom_t *dev)
         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) {
@@ -2744,6 +2861,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;
@@ -2790,6 +2909,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
@@ -2799,11 +2921,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);
 
@@ -2824,7 +2961,8 @@ cdrom_hard_reset(void)
                     break;
             }
 
-            dev->cd_status = CD_STATUS_EMPTY;
+            dev->cd_status     = CD_STATUS_EMPTY;
+            dev->cached_sector = -1;
 
             if (strlen(dev->image_path) > 0) {
 #ifdef _WIN32
@@ -2889,6 +3027,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);
 
@@ -2901,6 +3041,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)
+        /* 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)
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 3683c8671..e367f73b0 100644
--- a/src/disk/hdc_ide.c
+++ b/src/disk/hdc_ide.c
@@ -241,6 +241,7 @@ int    ide_qua_enabled = 0;
 static void ide_atapi_callback(ide_t *ide);
 static void ide_callback(void *priv);
 
+#define ENABLE_IDE_LOG 1
 #ifdef ENABLE_IDE_LOG
 int ide_do_log = ENABLE_IDE_LOG;
 
@@ -1028,9 +1029,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 +1056,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 +1076,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 +1086,30 @@ 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);
+                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 +1118,69 @@ 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);
+                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;
     }
@@ -1134,22 +1200,37 @@ ide_atapi_pio_request(ide_t *ide, uint8_t out)
         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->write != NULL))
+                ide->write(dev);
+            else if (!out && (dev->sector_len != 0) && (ide->read != NULL))
+                ide->read(dev);
+        }
+
+        if ((dev->block_len == 0) || (dev->sector_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,10 +1238,20 @@ ide_atapi_pio_request(ide_t *ide, uint8_t out)
 
         dev->packet_status = PHASE_DATA_IN | out;
 
+        if (dev->block_len != 0) {
+            if (out && (ide->write != NULL))
+                ide->write(dev);
+            else if (!out && (dev->sector_len != 0) && (ide->read != NULL))
+                ide->read(dev);
+        }
+
         ide->tf->atastat = BSY_STAT;
         ide->tf->phase  = 1;
-        ide_atapi_callback(ide);
-        ide_set_callback(ide, 0.0);
+
+        if ((dev->block_len == 0) || (dev->sector_len == 0)) {
+            ide_atapi_callback(ide);
+            ide_set_callback(ide, 0.0);
+        }
 
         dev->request_pos = 0;
     }
@@ -1179,19 +1270,26 @@ 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);
-        }
+        } else if ((dev->block_len != 0) &&
+                   (dev->sector_len != 0) &&
+                   ((dev->request_pos % dev->block_len) == 0) &&
+                   (ide->read != NULL))
+            ide->read(dev);
     }
 
     return ret;
@@ -1221,10 +1319,14 @@ 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);
-            }
+            } else if ((dev->block_len != 0) &&
+                       ((dev->request_pos % dev->block_len) == 0) &&
+                       (ide->write != NULL))
+                ide->write(dev);
         } else if (dev->packet_status == PHASE_IDLE) {
             if (ide->tf->pos >= 12) {
                 ide->tf->pos       = 0;
@@ -1287,7 +1389,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 +1423,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 +1473,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 +1583,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 +1933,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 +2112,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 +2124,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 +2157,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 +2188,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 +2374,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 +2483,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 +2741,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/include/86box/cdrom.h b/src/include/86box/cdrom.h
index 7c028d7d6..c6347fc3e 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,22 +332,26 @@ 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[4096];
+    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;
 } 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
@@ -366,8 +372,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);
@@ -384,6 +388,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);
@@ -396,7 +401,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);
@@ -424,6 +429,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/device.h b/src/include/86box/device.h
index 1c2ec5203..6902ffdfd 100644
--- a/src/include/86box/device.h
+++ b/src/include/86box/device.h
@@ -118,16 +118,6 @@ enum {
 #define BIOS_INTERLEAVED_INVERT          8
 #define BIOS_HIGH_BIT_INVERT             16
 
-#define device_common_config_t                      \
-    const char                     *name;           \
-    const char                     *description;    \
-    int                             type;           \
-    const char                     *default_string; \
-    int                             default_int;    \
-    const char                     *file_filter;    \
-    const device_config_spinner_t   spinner;        \
-    const device_config_selection_t selection[32]
-
 typedef struct device_config_selection_t {
     const char *description;
     int         value;
@@ -139,10 +129,6 @@ typedef struct device_config_spinner_t {
     int16_t step;
 } device_config_spinner_t;
 
-typedef struct _device_dep_config_ {
-    device_common_config_t;
-} device_dep_config_t;
-
 typedef struct device_config_bios_t {
     const char *name;
     const char *internal_name;
@@ -153,15 +139,18 @@ typedef struct device_config_bios_t {
     void       *dev1;
     void       *dev2;
     const char *files[9];
-    /* Configuration options that depend on the device variant.
-       To prevent excessive nesting, there is no CONFIG_BIOS
-       option a dep_config struct  */
-    const device_dep_config_t *dep_config;
 } device_config_bios_t;
 
 typedef struct _device_config_ {
-    device_common_config_t;
-    const device_config_bios_t      bios[32];
+    const char                      *name;
+    const char                      *description;
+    int                              type;
+    const char                      *default_string;
+    int                              default_int;
+    const char                      *file_filter;
+    const device_config_spinner_t    spinner;
+    const device_config_selection_t  selection[32];
+    const device_config_bios_t       bios[32];
 } device_config_t;
 
 typedef struct _device_ {
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/qt_winrawinputfilter.cpp b/src/qt/qt_winrawinputfilter.cpp
index 13e0ec9a7..272b389c5 100644
--- a/src/qt/qt_winrawinputfilter.cpp
+++ b/src/qt/qt_winrawinputfilter.cpp
@@ -65,6 +65,7 @@ extern void    win_keyboard_handle(uint32_t scancode, int up, int e0, int e1);
 #include "ui_qt_mainwindow.h"
 
 bool windows_is_light_theme() {
+    return 0;
     // based on https://stackoverflow.com/questions/51334674/how-to-detect-windows-10-light-dark-mode-in-win32-application
 
     // The value is expected to be a REG_DWORD, which is a signed 32-bit little-endian
diff --git a/src/qt/win_cdrom_ioctl.c b/src/qt/win_cdrom_ioctl.c
index 621cf0b76..3d9ecefd5 100644
--- a/src/qt/win_cdrom_ioctl.c
+++ b/src/qt/win_cdrom_ioctl.c
@@ -91,6 +91,20 @@ 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);
 }
 
diff --git a/src/scsi/scsi_cdrom.c b/src/scsi/scsi_cdrom.c
index 04c6532df..07590d5ae 100644
--- a/src/scsi/scsi_cdrom.c
+++ b/src/scsi/scsi_cdrom.c
@@ -15,6 +15,7 @@
  */
 #include <inttypes.h>
 #include <math.h>
+#define ENABLE_SCSI_CDROM_LOG 2
 #ifdef ENABLE_SCSI_CDROM_LOG
 #include <stdarg.h>
 #endif
@@ -110,6 +111,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 +305,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 +340,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 +531,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 +561,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 +611,11 @@ scsi_cdrom_update_request_length(scsi_cdrom_t *dev, int len, const int block_len
                     break;
                 }
             }
+            dev->requested_blocks = 1;
             fallthrough;
 
         default:
-            dev->packet_len = len;
+            dev->packet_len   = len;
             break;
     }
     /*
@@ -649,16 +660,10 @@ scsi_cdrom_bus_speed(scsi_cdrom_t *dev)
 }
 
 static void
-scsi_cdrom_command_common(scsi_cdrom_t *dev)
+scsi_cdrom_set_period(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)
@@ -667,91 +672,38 @@ scsi_cdrom_command_common(scsi_cdrom_t *dev)
         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;
+        if (dev->was_cached != -1) {
+            if (dev->was_cached) {
+                dev->callback += 512.0;
                 scsi_cdrom_set_callback(dev);
                 return;
-            case 0x43:
-                dev->drv->seek_diff = dev->drv->seek_pos + 150;
-                dev->drv->seek_pos  = 0;
-                fallthrough;
-            case 0x08:
-            case 0x28:
-            case 0x42: case 0x44:
-            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 */
-                /*
-                   TODO: This is a bit of a lie - the actual period is closer to
-                         75 * 2448 bytes per second, because the subchannel data
-                         has to be read as well.
-                 */
-                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;
+            }
+
+            /* 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);
-        switch (cmd) {
-            default:
-                period = period * (double) (dev->packet_len);
-                break;
-            case 0x42: case 0x44:
-                /* READ SUBCHANNEL or READ HEADER - period of 1 entire sector. */
-                period = period * 2352.0;
-                break;
-            case 0x43:
-                /* READ TOC - period of 175 entire frames. */
-                period = period * 150.0 * 2352.0;
-                break;
+        if (dev->was_cached == -1)
+            period *= (double) dev->packet_len;
+        else {
+            period *= ((double) dev->requested_blocks) * 2352.0;
+            pclog("[%02X] Calculated period for %i * 2352 bytes\n", cmd, dev->requested_blocks);
         }
         scsi_cdrom_log(dev->log, "Sector transfer period: %" PRIu64 " us\n",
                        (uint64_t) period);
@@ -760,6 +712,18 @@ scsi_cdrom_command_common(scsi_cdrom_t *dev)
     scsi_cdrom_set_callback(dev);
 }
 
+static void
+scsi_cdrom_command_common(scsi_cdrom_t *dev)
+{
+    /* 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_set_period(dev);
+}
+
 static void
 scsi_cdrom_command_complete(scsi_cdrom_t *dev)
 {
@@ -977,7 +941,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;
@@ -988,7 +952,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;
@@ -1073,7 +1037,7 @@ 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;
@@ -1081,69 +1045,60 @@ scsi_cdrom_read_data(scsi_cdrom_t *dev, const int msf, const int type, const int
     if (dev->drv->cd_status == CD_STATUS_EMPTY)
         scsi_cdrom_not_ready(dev);
     else {
-        const uint32_t cdsize   = dev->drv->cdrom_capacity;
-
-        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);
+        if (dev->sector_pos > dev->drv->cdrom_capacity) {
             scsi_cdrom_lba_out_of_range(dev);
             ret = -1;
         } else {
-            int      data_pos = 0;
+            ret = cdrom_readsector_raw(dev->drv, dev->buffer + dev->buffer_pos,
+                                       dev->sector_pos, msf, type,
+                                       flags, &temp_len, vendor_type);
 
-            dev->old_len = 0;
-            *len         = 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;
 
-            ret = 1;
+                dev->sector_pos++;
+                dev->drv->seek_pos = dev->sector_pos;
 
-            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);
+                dev->sector_len--;
 
-                data_pos += temp_len;
-                dev->old_len += temp_len;
-
-                *len += temp_len;
-
-                if (ret == 0) {
-                    scsi_cdrom_illegal_mode(dev);
-                    break;
-                }
-
-                if (ret < 0) {
-                    scsi_cdrom_circ_error(dev);
-                    break;
-                }
+                pclog("Sector read to buffer position %08X\n", dev->buffer_pos);
+                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;
@@ -1164,16 +1119,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;
@@ -1214,7 +1163,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;
@@ -1317,12 +1266,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);
@@ -1336,6 +1279,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);
 }
@@ -1388,6 +1332,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;
@@ -1412,9 +1360,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;
     }
 }
 
@@ -1498,6 +1448,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
@@ -1536,6 +1488,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;
@@ -1551,16 +1504,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 ret       = scsi_cdrom_read_blocks(dev);
+
+    dev->drv->seek_diff = 0;
+
+    if (ret > 0) {
+        if (dev->packet_status != PHASE_COMPLETE) {
+            ui_sb_update_icon(SB_CDROM | dev->id, 1);
+
+            scsi_cdrom_set_period(dev);
+        } else
+            ui_sb_update_icon(SB_CDROM | dev->id, 0);
+    } 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:
@@ -1575,7 +1578,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;
@@ -1592,6 +1597,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);
                 }
@@ -1601,6 +1608,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;
@@ -1615,6 +1623,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);
@@ -1631,23 +1640,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;
 
@@ -1702,7 +1742,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);
@@ -1746,6 +1790,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;
     }
 
@@ -1874,12 +1919,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);
@@ -1909,7 +1958,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;
@@ -1924,12 +1972,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;
@@ -1958,6 +2008,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.
@@ -1967,6 +2019,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
@@ -1998,12 +2052,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)
@@ -2013,6 +2070,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
@@ -2023,6 +2082,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;
@@ -2041,6 +2101,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);
@@ -2051,15 +2112,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
@@ -2178,13 +2242,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);
@@ -2213,7 +2281,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;
@@ -2228,12 +2295,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;
@@ -2252,6 +2321,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);
@@ -2262,6 +2332,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)
@@ -2270,6 +2342,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
@@ -2277,6 +2351,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;
@@ -2306,6 +2399,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;
@@ -2317,6 +2412,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
@@ -2331,8 +2428,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);
 
@@ -2348,17 +2446,22 @@ 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:
+            pclog("Rezero unit\n");
+            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;
 
@@ -2386,7 +2489,9 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
 
         case GPCMD_SCAN_PIONEER:
         case GPCMD_AUDIO_SCAN:
+            pclog("Audio scan\n");
             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)) {
@@ -2395,7 +2500,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);
@@ -2419,6 +2527,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;
@@ -2427,6 +2536,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
             scsi_cdrom_buf_alloc(dev, 65536);
 
             toc_format = cdb[2] & 0xf;
+            pclog("READ TOC format %1X\n", toc_format);
 
             if (toc_format == 0)
                 toc_format = (cdb[9] >> 6) & 3;
@@ -2439,6 +2549,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);
                 }
@@ -2446,6 +2558,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:
@@ -2454,9 +2576,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];
                     /*
@@ -2491,6 +2615,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;
@@ -2535,22 +2660,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)
@@ -2575,11 +2708,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);
 
@@ -2590,10 +2726,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 };
@@ -2650,7 +2791,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 {
@@ -2681,7 +2822,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;
@@ -2714,7 +2855,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 {
@@ -2919,7 +3060,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;
@@ -2947,6 +3091,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;
@@ -2958,6 +3103,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);
@@ -2965,6 +3112,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;
@@ -2983,6 +3131,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
@@ -2999,21 +3149,25 @@ 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];
                     len = (cdb[7] << 8) | cdb[8];
+                    pclog("Play audio (10)\n");
                     break;
                 case GPCMD_PLAY_AUDIO_12:
                     msf = 0;
                     pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
                     len = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
+                    pclog("Play audio (12)\n");
                     break;
                 case GPCMD_PLAY_AUDIO_MSF:
                     msf = 1;
                     pos = (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
                     len = (cdb[6] << 16) | (cdb[7] << 8) | cdb[8];
+                    pclog("Play audio MSF: %2i:%02i.%02i-%2i:%02i.%02i\n",
+                          cdb[3], cdb[4], cdb[5], cdb[6], cdb[7], cdb[8]);
                     break;
                 case GPCMD_PLAY_AUDIO_TRACK_INDEX:
                     msf = 2;
@@ -3022,16 +3176,19 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                         len = cdb[7];
                     } else
                         ret = 0;
+                    pclog("Play audio track index\n");
                     break;
                 case GPCMD_PLAY_AUDIO_TRACK_RELATIVE_10:
                     msf = 0x100 | cdb[6];
                     pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
                     len = (cdb[7] << 8) | cdb[8];
+                    pclog("Play audio track relative (10)\n");
                     break;
                 case GPCMD_PLAY_AUDIO_TRACK_RELATIVE_12:
                     msf = 0x100 | cdb[10];
                     pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
                     len = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
+                    pclog("Play audio track relative (12)\n");
                     break;
 
                 default:
@@ -3039,9 +3196,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)
@@ -3052,13 +3211,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");
@@ -3090,23 +3250,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);
@@ -3119,7 +3279,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))
@@ -3168,10 +3327,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);
@@ -3267,7 +3429,7 @@ scsi_cdrom_command(scsi_common_t *sc, const uint8_t *cdb)
                 if (dev->drv->bus_type == CDROM_BUS_SCSI) {
                     dev->buffer[3] = 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 {
@@ -3287,7 +3449,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 */
                 }
@@ -3321,15 +3483,16 @@ 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:
+            pclog("Seek\n");
             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;
@@ -3346,16 +3509,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);
 
@@ -3370,6 +3537,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);
@@ -3388,7 +3557,7 @@ atapi_out:
             break;
 
         default:
-            scsi_cdrom_illegal_opcode(dev, cdb[0]);
+            scsi_cdrom_illegal_opcode(dev, dev->current_cdb[0]);
             break;
     }
 
@@ -3486,7 +3655,7 @@ scsi_cdrom_phase_data_out(scsi_common_t *sc)
 
                 pos += 2;
 
-                if (dev->is_sony && (page == 0x08) && (page_len == 0x02))
+                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)))) {
@@ -3496,7 +3665,9 @@ scsi_cdrom_phase_data_out(scsi_common_t *sc)
                     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];
@@ -3532,7 +3703,7 @@ scsi_cdrom_phase_data_out(scsi_common_t *sc)
             }
             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] =
@@ -3687,12 +3858,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);
@@ -3702,22 +3876,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;
@@ -3727,12 +3898,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;
@@ -3768,7 +3939,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;
@@ -3786,6 +3956,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];
+                    }
                 }
             }
         }