dep: Add rcheevos

dep/rcheevos/src/rhash/cdreader.c

@@ -0,0 +1,782 @@
+#include "rc_hash.h"
+
+#include "../rcheevos/rc_compat.h"
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+
+/* internal helper functions in hash.c */
+extern void* rc_file_open(const char* path);
+extern void rc_file_seek(void* file_handle, size_t offset, int origin);
+extern size_t rc_file_tell(void* file_handle);
+extern size_t rc_file_read(void* file_handle, void* buffer, int requested_bytes);
+extern void rc_file_close(void* file_handle);
+extern int rc_hash_error(const char* message);
+extern const char* rc_path_get_filename(const char* path);
+extern int rc_path_compare_extension(const char* path, const char* ext);
+extern rc_hash_message_callback verbose_message_callback;
+
+struct cdrom_t
+{
+  void* file_handle;
+  int sector_size;
+  int sector_header_size;
+  int first_sector_offset;
+  int first_sector;
+};
+
+static void cdreader_determine_sector_size(struct cdrom_t* cdrom)
+{
+  /* Attempt to determine the sector and header sizes. The CUE file may be lying.
+   * Look for the sync pattern using each of the supported sector sizes.
+   * Then check for the presence of "CD001", which is gauranteed to be in either the
+   * boot record or primary volume descriptor, one of which is always at sector 16.
+   */
+  const unsigned char sync_pattern[] = {
+    0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00
+  };
+
+  unsigned char header[32];
+  const int toc_sector = 16;
+
+  cdrom->sector_size = 0;
+  cdrom->sector_header_size = 0;
+
+  rc_file_seek(cdrom->file_handle, toc_sector * 2352 + cdrom->first_sector_offset, SEEK_SET);
+  rc_file_read(cdrom->file_handle, header, sizeof(header));
+
+  if (memcmp(header, sync_pattern, 12) == 0)
+  {
+    cdrom->sector_size = 2352;
+
+    if (memcmp(&header[25], "CD001", 5) == 0)
+      cdrom->sector_header_size = 24;
+    else
+      cdrom->sector_header_size = 16;
+  }
+  else
+  {
+    rc_file_seek(cdrom->file_handle, toc_sector * 2336 + cdrom->first_sector_offset, SEEK_SET);
+    rc_file_read(cdrom->file_handle, header, sizeof(header));
+
+    if (memcmp(header, sync_pattern, 12) == 0)
+    {
+      cdrom->sector_size = 2336;
+
+      if (memcmp(&header[25], "CD001", 5) == 0)
+        cdrom->sector_header_size = 24;
+      else
+        cdrom->sector_header_size = 16;
+    }
+    else
+    {
+      rc_file_seek(cdrom->file_handle, toc_sector * 2048 + cdrom->first_sector_offset, SEEK_SET);
+      rc_file_read(cdrom->file_handle, header, sizeof(header));
+
+      if (memcmp(&header[1], "CD001", 5) == 0)
+      {
+        cdrom->sector_size = 2048;
+        cdrom->sector_header_size = 0;
+      }
+    }
+  }
+}
+
+static void* cdreader_open_bin_track(const char* path, uint32_t track)
+{
+  void* file_handle;
+  struct cdrom_t* cdrom;
+
+  if (track > 1)
+  {
+    if (verbose_message_callback)
+      verbose_message_callback("Cannot locate secondary tracks without a cue sheet");
+
+    return NULL;
+  }
+
+  file_handle = rc_file_open(path);
+  if (!file_handle)
+    return NULL;
+
+  cdrom = (struct cdrom_t*)calloc(1, sizeof(*cdrom));
+  cdrom->file_handle = file_handle;
+
+  cdreader_determine_sector_size(cdrom);
+
+  if (cdrom->sector_size == 0)
+  {
+    size_t size;
+
+    rc_file_seek(cdrom->file_handle, 0, SEEK_END);
+    size = ftell(cdrom->file_handle);
+
+    if ((size % 2352) == 0)
+    {
+      /* raw tracks use all 2352 bytes and have a 24 byte header */
+      cdrom->sector_size = 2352;
+      cdrom->sector_header_size = 24;
+    }
+    else if ((size % 2048) == 0)
+    {
+      /* cooked tracks eliminate all header/footer data */
+      cdrom->sector_size = 2048;
+      cdrom->sector_header_size = 0;
+    }
+    else if ((size % 2336) == 0)
+    {
+      /* MODE 2 format without 16-byte sync data */
+      cdrom->sector_size = 2336;
+      cdrom->sector_header_size = 8;
+    }
+    else
+    {
+      free(cdrom);
+
+      if (verbose_message_callback)
+        verbose_message_callback("Could not determine sector size");
+
+      return NULL;
+    }
+  }
+
+  return cdrom;
+}
+
+static int cdreader_open_bin(struct cdrom_t* cdrom, const char* path, const char* mode)
+{
+  cdrom->file_handle = rc_file_open(path);
+  if (!cdrom->file_handle)
+    return 0;
+
+  /* determine sector size */
+  cdreader_determine_sector_size(cdrom);
+
+  /* could not determine, which means we'll probably have more issues later
+   * but use the CUE provided information anyway
+   */
+  if (cdrom->sector_size == 0)
+  {
+    /* All of these modes have 2048 byte payloads. In MODE1/2352 and MODE2/2352
+     * modes, the mode can actually be specified per sector to change the payload
+     * size, but that reduces the ability to recover from errors when the disc
+     * is damaged, so it's seldomly used, and when it is, it's mostly for audio
+     * or video data where a blip or two probably won't be noticed by the user.
+     * So, while we techincally support all of the following modes, we only do
+     * so with 2048 byte payloads.
+     * http://totalsonicmastering.com/cuesheetsyntax.htm
+     * MODE1/2048 ? CDROM Mode1 Data (cooked) [no header, no footer]
+     * MODE1/2352 ? CDROM Mode1 Data (raw)    [16 byte header, 288 byte footer]
+     * MODE2/2336 ? CDROM-XA Mode2 Data       [8 byte header, 280 byte footer]
+     * MODE2/2352 ? CDROM-XA Mode2 Data       [24 byte header, 280 byte footer]
+     */
+    if (memcmp(mode, "MODE2/2352", 10) == 0)
+    {
+      cdrom->sector_size = 2352;
+      cdrom->sector_header_size = 24;
+    }
+    else if (memcmp(mode, "MODE1/2048", 10) == 0)
+    {
+      cdrom->sector_size = 2048;
+      cdrom->sector_header_size = 0;
+    }
+    else if (memcmp(mode, "MODE2/2336", 10) == 0)
+    {
+      cdrom->sector_size = 2336;
+      cdrom->sector_header_size = 8;
+    }
+    else if (memcmp(mode, "MODE1/2352", 10) == 0)
+    {
+      cdrom->sector_size = 2352;
+      cdrom->sector_header_size = 16;
+    }
+  }
+
+  return (cdrom->sector_size != 0);
+}
+
+static char* cdreader_get_bin_path(const char* cue_path, const char* bin_name)
+{
+  const char* filename = rc_path_get_filename(cue_path);
+  const size_t bin_name_len = strlen(bin_name);
+  const size_t cue_path_len = filename - cue_path;
+  const size_t needed = cue_path_len + bin_name_len + 1;
+
+  char* bin_filename = (char*)malloc(needed);
+  if (!bin_filename)
+  {
+    char buffer[64];
+    snprintf(buffer, sizeof(buffer), "Failed to allocate %u bytes", (unsigned)needed);
+    rc_hash_error((const char*)buffer);
+  }
+  else
+  {
+    memcpy(bin_filename, cue_path, cue_path_len);
+    memcpy(bin_filename + cue_path_len, bin_name, bin_name_len + 1);
+  }
+
+  return bin_filename;
+}
+
+static size_t cdreader_get_bin_size(const char* cue_path, const char* bin_name)
+{
+  size_t size = 0;
+  char* bin_filename = cdreader_get_bin_path(cue_path, bin_name);
+  if (bin_filename)
+  {
+    void* file_handle = rc_file_open(bin_filename);
+    if (file_handle)
+    {
+      rc_file_seek(file_handle, 0, SEEK_END);
+      size = rc_file_tell(file_handle);
+      rc_file_close(file_handle);
+    }
+
+    free(bin_filename);
+  }
+
+  return size;
+}
+
+static void* cdreader_open_cue_track(const char* path, uint32_t track)
+{
+  void* file_handle;
+  size_t file_offset = 0;
+  char buffer[1024], mode[16];
+  char* bin_filename;
+  char file[256];
+  char *ptr, *ptr2, *end;
+  int current_track = 0;
+  int sector_size = 0;
+  int track_first_sector = 0;
+  int previous_sector_size = 0;
+  int previous_index_sector_offset = 0;
+  int previous_track_is_data = 0;
+  int previous_track_sector_offset = 0;
+  char previous_track_mode[16];
+  int largest_track = 0;
+  int largest_track_sector_count = 0;
+  int largest_track_offset = 0;
+  char largest_track_mode[16];
+  char largest_track_file[256];
+  int offset = 0;
+  int done = 0;
+  size_t num_read = 0;
+  struct cdrom_t* cdrom = NULL;
+
+  file_handle = rc_file_open(path);
+  if (!file_handle)
+    return NULL;
+
+  file[0] = '\0';
+  do
+  {
+    num_read = rc_file_read(file_handle, buffer, sizeof(buffer) - 1);
+    if (num_read == 0)
+      break;
+
+    buffer[num_read] = 0;
+    if (num_read == sizeof(buffer) - 1)
+      end = buffer + sizeof(buffer) * 3 / 4;
+    else
+      end = buffer + num_read;
+
+    for (ptr = buffer; ptr < end; ++ptr)
+    {
+      while (*ptr == ' ')
+        ++ptr;
+
+      if (strncasecmp(ptr, "INDEX ", 6) == 0)
+      {
+        int m = 0, s = 0, f = 0;
+        int index, sector_offset;
+
+        ptr += 6;
+        index = atoi(ptr);
+
+        while (*ptr != ' ' && *ptr != '\n')
+          ++ptr;
+        while (*ptr == ' ')
+          ++ptr;
+
+        /* convert mm:ss:ff to sector count */
+        sscanf(ptr, "%d:%d:%d", &m, &s, &f);
+        sector_offset = ((m * 60) + s) * 75 + f;
+        sector_offset -= previous_index_sector_offset;
+
+        if (index == 1)
+          track_first_sector += sector_offset;
+
+        /* if looking for the largest data track, determine previous track size */
+        if (index == 1 && track == RC_HASH_CDTRACK_LARGEST && previous_track_is_data)
+        {
+          if (sector_offset > largest_track_sector_count)
+          {
+            largest_track_sector_count = sector_offset;
+            largest_track_offset = previous_track_sector_offset;
+            largest_track = current_track - 1;
+            memcpy(largest_track_mode, previous_track_mode, sizeof(largest_track_mode));
+            strcpy(largest_track_file, file);
+          }
+        }
+
+        /* calculate the true offset and update the counters for the next INDEX marker */
+        offset += sector_offset * previous_sector_size;
+        previous_sector_size = sector_size;
+        previous_index_sector_offset += sector_offset;
+
+        if (index == 1)
+        {
+          if (verbose_message_callback)
+          {
+            char message[128];
+            char* scan = mode;
+            while (*scan && !isspace(*scan))
+              ++scan;
+            *scan = '\0';
+
+            snprintf(message, sizeof(message), "Found %s track %d (sector size %d, track starts at %d)", mode, current_track, sector_size, offset);
+            verbose_message_callback(message);
+          }
+
+          if (current_track == (int)track)
+          {
+            done = 1;
+            break;
+          }
+
+          memcpy(previous_track_mode, mode, sizeof(previous_track_mode));
+          previous_track_is_data = (memcmp(mode, "MODE", 4) == 0);
+          previous_track_sector_offset = offset;
+
+          if (previous_track_is_data && track == RC_HASH_CDTRACK_FIRST_DATA)
+          {
+            track = current_track;
+            done = 1;
+            break;
+          }
+        }
+      }
+      else if (strncasecmp(ptr, "TRACK ", 6) == 0)
+      {
+        ptr += 6;
+        current_track = atoi(ptr);
+
+        while (*ptr != ' ')
+          ++ptr;
+        while (*ptr == ' ')
+          ++ptr;
+        memcpy(mode, ptr, sizeof(mode));
+
+        previous_sector_size = sector_size;
+
+        if (memcmp(mode, "MODE", 4) == 0)
+        {
+          sector_size = atoi(ptr + 6);
+        }
+        else
+        {
+          /* assume AUDIO */
+          sector_size = 2352;
+        }
+      }
+      else if (strncasecmp(ptr, "FILE ", 5) == 0)
+      {
+        if (previous_sector_size > 0)
+        {
+          /* determine previous track size */
+          int sector_count = (int)cdreader_get_bin_size(path, file) / previous_sector_size;
+          track_first_sector += sector_count;
+
+          /* if looking for the largest data track, check to see if this one is larger */
+          if (track == RC_HASH_CDTRACK_LARGEST && previous_track_is_data)
+          {
+            if (sector_count > largest_track_sector_count)
+            {
+              largest_track_sector_count = sector_count;
+              largest_track_offset = previous_track_sector_offset;
+              largest_track = current_track;
+              memcpy(largest_track_mode, previous_track_mode, sizeof(largest_track_mode));
+              strcpy(largest_track_file, file);
+            }
+          }
+        }
+
+        ptr += 5;
+        ptr2 = ptr;
+        if (*ptr == '"')
+        {
+          ++ptr;
+          do
+          {
+            ++ptr2;
+          } while (*ptr2 && *ptr2 != '\n' && *ptr2 != '"');
+        }
+        else
+        {
+          do
+          {
+            ++ptr2;
+          } while (*ptr2 && *ptr2 != '\n' && *ptr2 != ' ');
+        }
+
+        if (ptr2 - ptr < (int)sizeof(file))
+        {
+          memcpy(file, ptr, ptr2 - ptr);
+          file[ptr2 - ptr] = '\0';
+        }
+        else
+        {
+          file[0] = '\0';
+        }
+
+        current_track = 0;
+        previous_sector_size = 0;
+        previous_index_sector_offset = 0;
+        offset = 0;
+      }
+
+      while (*ptr && *ptr != '\n')
+        ++ptr;
+    }
+
+    if (done)
+      break;
+
+    file_offset += (ptr - buffer);
+    rc_file_seek(file_handle, file_offset, SEEK_SET);
+
+  } while (1);
+
+  rc_file_close(file_handle);
+
+  if (track == RC_HASH_CDTRACK_LARGEST)
+  {
+    previous_track_is_data = (memcmp(mode, "MODE", 4) == 0);
+    if (previous_track_is_data)
+    {
+      int sector_count = (int)cdreader_get_bin_size(path, file) / previous_sector_size;
+      sector_count -= previous_index_sector_offset;
+
+      if (sector_count > largest_track_sector_count)
+      {
+        largest_track_sector_count = sector_count;
+        largest_track_offset = previous_track_sector_offset;
+        largest_track = current_track;
+        memcpy(largest_track_mode, previous_track_mode, sizeof(largest_track_mode));
+        strcpy(largest_track_file, file);
+      }
+    }
+
+    if (largest_track > 0)
+    {
+      current_track = largest_track;
+      track = (uint32_t)largest_track;
+      offset = largest_track_offset;
+      memcpy(mode, largest_track_mode, sizeof(mode));
+      strcpy(file, largest_track_file);
+    }
+  }
+
+  if (current_track == (int)track)
+  {
+    cdrom = (struct cdrom_t*)calloc(1, sizeof(*cdrom));
+    if (!cdrom)
+    {
+      snprintf((char*)buffer, sizeof(buffer), "Failed to allocate %u bytes", (unsigned)sizeof(*cdrom));
+      rc_hash_error((const char*)buffer);
+      return NULL;
+    }
+
+    cdrom->first_sector_offset = offset;
+    cdrom->first_sector = track_first_sector;
+
+    /* verify existance of bin file */
+    bin_filename = cdreader_get_bin_path(path, file);
+    if (bin_filename)
+    {
+      if (cdreader_open_bin(cdrom, bin_filename, mode))
+      {
+        if (verbose_message_callback)
+        {
+          if (cdrom->first_sector_offset)
+            snprintf((char*)buffer, sizeof(buffer), "Opened track %d (sector size %d, track starts at %d)", track, cdrom->sector_size, cdrom->first_sector_offset);
+          else
+            snprintf((char*)buffer, sizeof(buffer), "Opened track %d (sector size %d)", track, cdrom->sector_size);
+
+          verbose_message_callback((const char*)buffer);
+        }
+      }
+      else
+      {
+        snprintf((char*)buffer, sizeof(buffer), "Could not open %s", bin_filename);
+        rc_hash_error((const char*)buffer);
+
+        free(cdrom);
+        cdrom = NULL;
+      }
+
+      free(bin_filename);
+    }
+  }
+
+  return cdrom;
+}
+
+static void* cdreader_open_gdi_track(const char* path, uint32_t track)
+{
+  void* file_handle;
+  char buffer[1024];
+  char mode[16] = "MODE1/";
+  char sector_size[16];
+  char file[256];
+  size_t track_size;
+  int track_type;
+  char* bin_path = "";
+  uint32_t current_track = 0;
+  char* ptr, *ptr2, *end;
+  int lba = 0;
+
+  uint32_t largest_track = 0;
+  size_t largest_track_size = 0;
+  char largest_track_file[256];
+  char largest_track_sector_size[16];
+  int largest_track_lba = 0;
+
+  int found = 0;
+  size_t num_read = 0;
+  size_t file_offset = 0;
+  struct cdrom_t* cdrom = NULL;
+
+  file_handle = rc_file_open(path);
+  if (!file_handle)
+    return NULL;
+
+  file[0] = '\0';
+  do
+  {
+    num_read = rc_file_read(file_handle, buffer, sizeof(buffer) - 1);
+    if (num_read == 0)
+      break;
+
+    buffer[num_read] = 0;
+    if (num_read == sizeof(buffer) - 1)
+      end = buffer + sizeof(buffer) * 3 / 4;
+    else
+      end = buffer + num_read;
+
+    ptr = buffer;
+
+    /* the first line contains the number of tracks, so we can get the last track index from it */
+    if (track == RC_HASH_CDTRACK_LAST)
+      track = atoi(ptr);
+
+    /* first line contains the number of tracks and will be skipped */
+    while (ptr < end)
+    {
+      /* skip until next newline */
+      while (*ptr != '\n' && ptr < end)
+        ++ptr;
+
+      /* skip newlines */
+      while ((*ptr == '\n' || *ptr == '\r') && ptr < end)
+        ++ptr;
+
+      /* line format: [trackid] [lba] [type] [sectorsize] [file] [?] */
+      current_track = (uint32_t)atoi(ptr);
+      if (track && current_track != track)
+        continue;
+
+      while (isdigit(*ptr))
+        ++ptr;
+      ++ptr;
+
+      lba = atoi(ptr);
+      while (isdigit(*ptr))
+        ++ptr;
+      ++ptr;
+
+      track_type = atoi(ptr);
+      while (isdigit(*ptr))
+        ++ptr;
+      ++ptr;
+
+      ptr2 = sector_size;
+      while (isdigit(*ptr))
+        *ptr2++ = *ptr++;
+      *ptr2 = '\0';
+      ++ptr;
+
+      ptr2 = file;
+      if (*ptr == '\"')
+      {
+        ++ptr;
+        while (*ptr != '\"')
+          *ptr2++ = *ptr++;
+        ++ptr;
+      }
+      else
+      {
+        while (*ptr != ' ')
+          *ptr2++ = *ptr++;
+      }
+      *ptr2 = '\0';
+
+      if (track == current_track || (track == RC_HASH_CDTRACK_FIRST_DATA && track_type == 4))
+      {
+        found = 1;
+        break;
+      }
+      else if (track == RC_HASH_CDTRACK_LARGEST && track_type == 4)
+      {
+        track_size = cdreader_get_bin_size(path, file);
+        if (track_size > largest_track_size)
+        {
+          largest_track_size = track_size;
+          largest_track = current_track;
+          largest_track_lba = lba;
+          strcpy(largest_track_file, file);
+          strcpy(largest_track_sector_size, sector_size);
+        }
+      }
+    }
+
+    if (found)
+      break;
+
+    file_offset += (ptr - buffer);
+    rc_file_seek(file_handle, file_offset, SEEK_SET);
+
+  } while (1);
+
+  rc_file_close(file_handle);
+
+  cdrom = (struct cdrom_t*)calloc(1, sizeof(*cdrom));
+  if (!cdrom)
+  {
+    snprintf((char*)buffer, sizeof(buffer), "Failed to allocate %u bytes", (unsigned)sizeof(*cdrom));
+    rc_hash_error((const char*)buffer);
+    return NULL;
+  }
+
+  /* if we were tracking the largest track, make it the current track.
+   * otherwise, current_track will be the requested track, or last track. */
+  if (largest_track != 0 && largest_track != current_track)
+  {
+    current_track = largest_track;
+    strcpy(file, largest_track_file);
+    strcpy(sector_size, largest_track_sector_size);
+    lba = largest_track_lba;
+  }
+
+  /* open the bin file for the track - construct mode parameter from sector_size */
+  ptr = &mode[6];
+  ptr2 = sector_size;
+  while (*ptr2 && *ptr2 != '\"')
+    *ptr++ = *ptr2++;
+  *ptr = '\0';
+
+  bin_path = cdreader_get_bin_path(path, file);
+  if (cdreader_open_bin(cdrom, bin_path, mode))
+  {
+    cdrom->first_sector_offset = 0;
+    cdrom->first_sector = lba;
+
+    if (verbose_message_callback)
+    {
+      snprintf((char*)buffer, sizeof(buffer), "Opened track %d (sector size %d)", track, cdrom->sector_size);
+      verbose_message_callback((const char*)buffer);
+    }
+  }
+  else
+  {
+    snprintf((char*)buffer, sizeof(buffer), "Could not open %s", bin_path);
+    rc_hash_error((const char*)buffer);
+
+    free(cdrom);
+    cdrom = NULL;
+  }
+
+  return cdrom;
+}
+
+static void* cdreader_open_track(const char* path, uint32_t track)
+{
+  /* backwards compatibility - 0 used to mean largest */
+  if (track == 0)
+    track = RC_HASH_CDTRACK_LARGEST;
+
+  if (rc_path_compare_extension(path, "cue"))
+    return cdreader_open_cue_track(path, track);
+  if (rc_path_compare_extension(path, "gdi"))
+    return cdreader_open_gdi_track(path, track);
+
+  return cdreader_open_bin_track(path, track);
+}
+
+static size_t cdreader_read_sector(void* track_handle, uint32_t sector, void* buffer, size_t requested_bytes)
+{
+  size_t sector_start;
+  size_t num_read, total_read = 0;
+  uint8_t* buffer_ptr = (uint8_t*)buffer;
+
+  struct cdrom_t* cdrom = (struct cdrom_t*)track_handle;
+  if (!cdrom)
+    return 0;
+
+  sector_start = sector * cdrom->sector_size + cdrom->sector_header_size + cdrom->first_sector_offset;
+
+  while (requested_bytes > 2048)
+  {
+    rc_file_seek(cdrom->file_handle, sector_start, SEEK_SET);
+    num_read = rc_file_read(cdrom->file_handle, buffer_ptr, 2048);
+    total_read += num_read;
+
+    if (num_read < 2048)
+      return total_read;
+
+    buffer_ptr += 2048;
+    sector_start += cdrom->sector_size;
+    requested_bytes -= 2048;
+  }
+
+  rc_file_seek(cdrom->file_handle, sector_start, SEEK_SET);
+  num_read = rc_file_read(cdrom->file_handle, buffer_ptr, (int)requested_bytes);
+  total_read += num_read;
+
+  return total_read;
+}
+
+static void cdreader_close_track(void* track_handle)
+{
+  struct cdrom_t* cdrom = (struct cdrom_t*)track_handle;
+  if (cdrom)
+  {
+    if (cdrom->file_handle)
+      rc_file_close(cdrom->file_handle);
+
+    free(track_handle);
+  }
+}
+
+static uint32_t cdreader_absolute_sector_to_track_sector(void* track_handle, uint32_t sector)
+{
+  struct cdrom_t* cdrom = (struct cdrom_t*)track_handle;
+  if (cdrom)
+    return sector - cdrom->first_sector;
+
+  return 0;
+}
+
+void rc_hash_init_default_cdreader()
+{
+  struct rc_hash_cdreader cdreader;
+
+  cdreader.open_track = cdreader_open_track;
+  cdreader.read_sector = cdreader_read_sector;
+  cdreader.close_track = cdreader_close_track;
+  cdreader.absolute_sector_to_track_sector = cdreader_absolute_sector_to_track_sector;
+
+  rc_hash_init_custom_cdreader(&cdreader);
+}