Imported Upstream version 1.1.11upstream/1.1.11upstream

1 files changed, 3841 insertions, 0 deletions

diff --git a/icedax/toc.c b/icedax/toc.c
new file mode 100644
index 0000000..e03c23d
--- /dev/null
+++ b/icedax/toc.c
@@ -0,0 +1,3841 @@
+/*
+ * This file has been modified for the cdrkit suite.
+ *
+ * The behaviour and appearence of the program code below can differ to a major
+ * extent from the version distributed by the original author(s).
+ *
+ * For details, see Changelog file distributed with the cdrkit package. If you
+ * received this file from another source then ask the distributing person for
+ * a log of modifications.
+ *
+ */
+
+/* @(#)toc.c	1.57 06/02/19 Copyright 1998-2003 Heiko Eissfeldt */
+/*
+ * Copyright: GNU Public License 2 applies
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2, or (at your option)
+ *   any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * CDDA2WAV (C) Heiko Eissfeldt heiko@hexco.de
+ * CDDB routines (C) Ti Kan and Steve Scherf
+ */
+#include "config.h"
+#include <stdio.h>
+#include <standard.h>
+#include <stdxlib.h>
+#include <strdefs.h>
+#include <utypes.h>
+#include <intcvt.h>
+#include <unixstd.h>		/* sleep */
+#include <ctype.h>
+#include <errno.h>
+#include <fctldefs.h>
+#include <vadefs.h>
+#include <schily.h>
+#include <libport.h>
+#include <sys/ioctl.h>
+
+#define CD_TEXT
+#define CD_EXTRA
+#undef DEBUG_XTRA
+#undef DEBUG_CDTEXT
+#undef DEBUG_CDDBP
+
+
+#include <usal/scsitransp.h>
+
+#include "mytype.h"
+#include "byteorder.h"
+#include "interface.h"
+#include "icedax.h"
+#include "global.h"
+#include "sha.h"
+#include "base64.h"
+#include "toc.h"
+#include "exitcodes.h"
+#include "ringbuff.h"
+
+int Get_Mins(unsigned long p_track);
+int Get_Secs(unsigned long p_track);
+int Get_Frames(unsigned long p_track);
+int Get_Flags(unsigned long p_track);
+int Get_SCMS(unsigned long p_track);
+
+
+#if	defined	USE_REMOTE
+/* tcp stuff */
+/* fix OS/2 compilation */
+#ifdef	__EMX__
+#define	gethostid	nogethostid
+#endif
+#include <sys/socket.h>
+#undef gethostid
+#include <netinet/in.h>
+#if	defined(HAVE_NETDB_H) && !defined(HOST_NOT_FOUND) && \
+				!defined(_INCL_NETDB_H)
+#include <netdb.h>
+#define	_INCL_NETDB_H
+#endif
+#endif
+
+int have_CD_text;
+int have_multisession;
+int have_CD_extra;
+int have_CDDB;
+
+struct iterator;
+
+static void 			UpdateTrackData(int p_num);
+static void 			UpdateIndexData(int p_num);
+static void 			UpdateTimeData(int p_min, int p_sec, int p_frm);
+static unsigned int 	is_multisession(void);
+static unsigned int 	get_end_of_last_audio_track(unsigned mult_off);
+static int 				cddb_sum(int n);
+static void 			dump_extra_info(unsigned from);
+static int 				GetIndexOfSector(unsigned sec, unsigned track);
+static int 				patch_cd_extra(unsigned track, unsigned long sector);
+static void 			patch_to_audio(unsigned long p_track);
+static int 				restrict_tracks_illleadout(void);
+static void 			Set_MCN(unsigned char *MCN_arg);
+static void 			Set_ISRC(int track, const unsigned char *ISRC_arg);
+static void 			InitIterator(struct iterator *iter, unsigned long p_track);
+
+static unsigned char g_track=0xff, g_index=0xff;	/* current track, index */
+
+/* Conversion function: from logical block adresses  to minute,second,frame
+ */
+int lba_2_msf(long lba, int *m, int *s, int *f)
+{
+#ifdef  __follow_redbook__
+	if (lba >= -150 && lba < 405000) {      /* lba <= 404849 */
+#else
+	if (lba >= -150) {
+#endif
+		lba += 150;
+	} else if (lba >= -45150 && lba <= -151) {
+		lba += 450150;
+	} else
+		return 1;
+
+	*m = lba / 60 / 75;
+	lba -= (*m)*60*75;
+	*s = lba / 75;
+	lba -= (*s)*75;
+	*f = lba;
+
+	return 0;
+}
+
+/* print the track currently read */
+static void UpdateTrackData(int p_num)
+{
+  if (global.quiet == 0) { 
+    fprintf (stderr, "\ntrack: %.2d, ", p_num); fflush(stderr);
+  }
+  g_track = (unsigned char) p_num;
+}
+
+
+/* print the index currently read */
+static void UpdateIndexData(int p_num)
+{
+  if (global.quiet == 0) { 
+    fprintf (stderr, "index: %.2d\n", p_num); fflush(stderr);
+  }
+  g_index = (unsigned char) p_num;
+}
+
+
+/* print the time of track currently read */
+static void UpdateTimeData(int p_min, int p_sec, int p_frm)
+{
+  if (global.quiet == 0) {
+    fprintf (stderr, "time: %.2d:%.2d.%.2d\r", p_min, p_sec, p_frm); 
+    fflush(stderr);
+  }
+}
+
+void AnalyzeQchannel(unsigned frame)
+{
+    subq_chnl *sub_ch;
+
+    if (trackindex_disp != 0) {
+	sub_ch = ReadSubQ(get_scsi_p(), GET_POSITIONDATA,0);
+	/* analyze sub Q-channel data */
+	if (sub_ch->track != g_track ||
+	    sub_ch->index != g_index) {
+	    UpdateTrackData (sub_ch->track);
+	    UpdateIndexData (sub_ch->index);
+	}
+    }
+    frame += 150;
+    UpdateTimeData ((unsigned char) (frame / (60*75)), 
+		    (unsigned char) ((frame % (60*75)) / 75), 
+		    (unsigned char) (frame % 75));
+}
+
+unsigned cdtracks = 0;
+
+int no_disguised_audiotracks(void)
+{
+	/* we can assume no audio tracks according to toc here. */
+	/* read a data sector from the first data track */
+	unsigned char p[3000];
+	int retval;
+	get_scsi_p()->silent++;
+	retval = 1 == ReadCdRomData(get_scsi_p(), p, Get_StartSector(1), 1);
+	get_scsi_p()->silent--;
+	if (retval == 0) {
+		int i;
+fprintf(stderr, "Warning: wrong track types found: patching to audio...\n");
+		for (i = 0; i < cdtracks; i++)
+			patch_to_audio(i);
+	}
+	return retval;
+}
+
+
+#undef SIM_ILLLEADOUT
+int ReadToc(void)
+{
+    int retval = (*doReadToc)( get_scsi_p() );
+#if	defined SIM_ILLLEADOUT
+    g_toc[cdtracks+1] = 20*75;
+#endif
+    return retval;
+}
+
+static int can_read_illleadout(void);
+
+static int can_read_illleadout(void)
+{
+	SCSI *usalp = get_scsi_p();
+
+	UINT4 buffer [CD_FRAMESIZE_RAW/4];
+	if (global.illleadout_cd == 0) return 0;
+
+	usalp->silent++;
+	global.reads_illleadout = 
+	    ReadCdRom(usalp, buffer, Get_AudioStartSector(CDROM_LEADOUT), 1);
+	usalp->silent--;
+	return global.reads_illleadout;
+}
+
+
+unsigned find_an_off_sector(unsigned lSector, unsigned SectorBurstVal);
+
+unsigned find_an_off_sector(unsigned lSector, unsigned SectorBurstVal)
+{
+	long track_of_start = Get_Track(lSector);
+	long track_of_end = Get_Track(lSector + SectorBurstVal -1);
+	long start = Get_AudioStartSector(track_of_start);
+	long end = Get_EndSector(track_of_end);
+
+	if (lSector - start > end - lSector + SectorBurstVal -1)
+		return start;
+	else
+		return end;
+}
+
+#ifdef CD_TEXT
+#include "scsi_cmds.h"
+#endif
+
+
+int handle_cdtext(void)
+{
+#ifdef CD_TEXT
+	if (bufferTOC[0] == 0 && bufferTOC[1] == 0) {
+		have_CD_text = 0;
+		return have_CD_text;
+	}
+
+	/* do a quick scan over all pack type indicators */
+	{
+		int i;
+		int count_fails = 0;
+		int len = (bufferTOC[0] << 8) | bufferTOC[1];
+
+		len = min(len, 2048);
+		for (i = 0; i < len-4; i += 18) {
+			if (bufferTOC[4+i] < 0x80 || bufferTOC[4+i] > 0x8f) {
+				count_fails++;
+			}
+		}
+		have_CD_text = len > 4 && count_fails < 3;
+	}
+
+#else
+	have_CD_text = 0;
+#endif
+	return have_CD_text;
+}
+
+
+#ifdef CD_TEXT
+#include "cd_text.c"
+#endif
+
+
+#if defined CDROMMULTISESSION
+static int tmp_fd;
+#endif
+
+#ifdef CD_EXTRA
+#include "cd_extra.c"
+#endif
+
+static unsigned session_start;
+/*
+   A Cd-Extra is detected, if it is a multisession CD with
+   only audio tracks in the first session and a data track
+   in the last session.
+ */
+static unsigned is_multisession(void)
+{
+  unsigned mult_off;
+#if defined CDROMMULTISESSION
+  /*
+   * FIXME: we would have to do a ioctl (CDROMMULTISESSION)
+   *        for the cdrom device associated with the generic device
+   *	    not just AUX_DEVICE
+   */
+  struct cdrom_multisession ms_str;
+
+  if (interface == GENERIC_SCSI)
+    tmp_fd = open (global.aux_name, O_RDONLY);
+  else
+    tmp_fd = global.cooked_fd;
+
+  if (tmp_fd != -1) {
+    int result;
+
+    ms_str.addr_format = CDROM_LBA;
+    result = ioctl(tmp_fd, CDROMMULTISESSION, &ms_str);
+    if (result == -1) {
+      if (global.verbose != 0)
+        perror("multi session ioctl not supported: ");
+    } else {
+#ifdef DEBUG_XTRA
+  fprintf(stderr, "current ioctl multisession_offset = %u\n", ms_str.addr.lba);
+#endif
+	if (interface == GENERIC_SCSI)
+		close (tmp_fd);
+	if (ms_str.addr.lba > 0)
+	  return ms_str.addr.lba;
+    }
+  }
+#endif
+  mult_off = 0;
+  if (LastAudioTrack() + 1 == FirstDataTrack()) {
+	  mult_off = Get_StartSector(FirstDataTrack());
+  }
+
+#ifdef DEBUG_XTRA
+  fprintf(stderr, "current guessed multisession_offset = %u\n", mult_off);
+#endif
+  return mult_off;
+}
+
+#define SESSIONSECTORS (152*75)
+/*
+   The solution is to read the Table of Contents of the first
+   session only (if the drive permits that) and directly use
+   the start of the leadout. If this is not supported, we subtract
+   a constant of SESSIONSECTORS sectors (found heuristically).
+ */
+static unsigned get_end_of_last_audio_track(unsigned mult_off)
+{
+   unsigned retval;
+
+   /* Try to read the first session table of contents.
+      This works for Sony and mmc type drives. */
+   if (ReadLastAudio && (retval = ReadLastAudio(get_scsi_p())) != 0) {
+     return retval;
+   } else {
+     return mult_off - SESSIONSECTORS;
+   }
+}
+
+static void dump_cdtext_info(void);
+
+#if defined CDDB_SUPPORT
+static void emit_cddb_form(char *fname_baseval);
+#endif
+
+#if defined CDINDEX_SUPPORT
+static void emit_cdindex_form(char *fname_baseval);
+#endif
+
+
+typedef struct TOC {	/* structure of table of contents (cdrom) */
+	unsigned char reserved1;
+	unsigned char bFlags;
+	unsigned char bTrack;
+	unsigned char reserved2;
+	unsigned int dwStartSector;
+	int mins;
+	int secs;
+	int frms;
+	unsigned char ISRC[16];
+	int	SCMS;
+} TOC;
+
+
+/* Flags contains two fields:
+    bits 7-4 (ADR)
+ 	: 0 no sub-q-channel information
+	: 1 sub-q-channel contains current position
+	: 2 sub-q-channel contains media catalog number
+	: 3 sub-q-channel contains International Standard
+				   Recording Code ISRC
+	: other values reserved
+    bits 3-0 (Control) :
+    bit 3 : when set indicates there are 4 audio channels else 2 channels
+    bit 2 : when set indicates this is a data track else an audio track
+    bit 1 : when set indicates digital copy is permitted else prohibited
+    bit 0 : when set indicates pre-emphasis is present else not present
+ */
+
+#define GETFLAGS(x) ((x)->bFlags)
+#define GETTRACK(x) ((x)->bTrack)
+#define GETSTART(x) ((x)->dwStartSector)
+#define GETMINS(x)  ((x)->mins)
+#define GETSECS(x)  ((x)->secs)
+#define GETFRAMES(x) ((x)->frms)
+#define GETISRC(x)  ((x)->ISRC)
+
+#define IS__PREEMPHASIZED(p) ( (GETFLAGS(p) & 0x10) != 0)
+#define IS__INCREMENTAL(p) ( (GETFLAGS(p) & 0x10) != 0)
+#define IS__COPYRESTRICTED(p) (!(GETFLAGS(p) & 0x20) != 0)
+#define IS__COPYRIGHTED(p) (!(GETFLAGS(p) & 0x20) != 0)
+#define IS__DATA(p)        ( (GETFLAGS(p) & 0x40) != 0)
+#define IS__AUDIO(p)       (!(GETFLAGS(p) & 0x40) != 0)
+#define IS__QUADRO(p)      ( (GETFLAGS(p) & 0x80) != 0)
+
+/*
+ * Iterator interface inspired from Java
+ */
+struct iterator {
+	int index;
+	int startindex;
+	void        (*reset)(struct iterator *this);
+	struct TOC *(*getNextTrack)(struct iterator *this);
+	int         (*hasNextTrack)(struct iterator *this);
+};
+
+
+
+
+/* The Table of Contents needs to be corrected if we
+   have a CD-Extra. In this case all audio tracks are
+   followed by a data track (in the second session).
+   Unlike for single session CDs the end of the last audio
+   track cannot be set to the start of the following
+   track, since the lead-out and lead-in would then
+   errenously be part of the audio track. This would
+   lead to read errors when trying to read into the
+   lead-out area.
+   So the length of the last track in case of Cd-Extra
+   has to be fixed.
+ */
+unsigned FixupTOC(unsigned no_tracks)
+{
+    unsigned mult_off;
+    unsigned offset = 0;
+    int j = -1;
+    unsigned real_end = 2000000;
+
+    /* get the multisession offset in sectors */
+    mult_off = is_multisession();
+
+    /* if the first track address had been the victim of an underflow,
+     * set it to zero.
+     */
+    if (Get_StartSector(1) > Get_StartSector(LastTrack())) {
+	fprintf(stderr, "Warning: first track has negative start sector! Setting to zero.\n");
+	toc_entry( 1, Get_Flags(1), Get_Tracknumber(1), Get_ISRC(1), 0, 0, 2, 0 );
+    }
+
+#ifdef DEBUG_XTRA
+    fprintf(stderr, "current multisession_offset = %u\n", mult_off);
+#endif
+    dump_cdtext_info();
+
+    if (mult_off > 100) { /* the offset has to have a minimum size */
+
+      /* believe the multisession offset :-) */
+      /* adjust end of last audio track to be in the first session */
+      real_end = get_end_of_last_audio_track(mult_off);
+#ifdef DEBUG_XTRA
+      fprintf(stderr, "current end = %u\n", real_end);
+#endif
+
+      j = FirstDataTrack();
+      if (LastAudioTrack() + 1 == j) {
+	  long sj = Get_StartSector(j);
+	  if (sj > (long)real_end) {
+	    session_start = mult_off;
+		have_multisession = sj;
+
+#ifdef CD_EXTRA
+	    offset = Read_CD_Extra_Info(sj);
+
+	    if (offset != 0) {
+		have_CD_extra = sj;
+		dump_extra_info(offset);
+	    }
+#endif
+	  }
+      }
+    }
+    if (global.cddbp) {
+#if	defined USE_REMOTE
+        if (global.disctitle == NULL) {
+	    have_CDDB = !request_titles();
+        }
+#else
+        fprintf(stderr, "Cannot lookup titles: no cddbp support included!\n");
+#endif
+    }
+#if defined CDINDEX_SUPPORT || defined CDDB_SUPPORT
+    if (have_CD_text || have_CD_extra || have_CDDB) {
+	    unsigned long	count_audio_tracks = 0;
+	    static struct iterator i;
+	    if (i.reset == NULL)
+		    InitIterator(&i, 1);
+
+	    while (i.hasNextTrack(&i)) {
+		    struct TOC *p = i.getNextTrack(&i);
+		    if (IS__AUDIO(p)) count_audio_tracks++;
+	    }
+
+	    if (count_audio_tracks > 0 && global.no_cddbfile == 0) {
+#if defined CDINDEX_SUPPORT
+		    emit_cdindex_form(global.fname_base);
+#endif
+#if defined CDDB_SUPPORT
+		    emit_cddb_form(global.fname_base);
+#endif
+	    }
+    }
+#endif
+    if (have_multisession) {
+	/* set start of track to beginning of lead-out */
+	patch_cd_extra(j, real_end);
+#if	defined CD_EXTRA && defined DEBUG_XTRA
+	fprintf(stderr, "setting end of session (track %d) to %u\n", j, real_end);
+#endif
+    }
+    return offset;
+}
+
+static int cddb_sum(int n)
+{
+  int ret;
+
+  for (ret = 0; n > 0; n /= 10) {
+    ret += (n % 10);
+  }
+
+  return ret;
+}
+
+void calc_cddb_id(void)
+{
+  UINT4 i;
+  UINT4 t = 0;
+  UINT4 n = 0;
+
+  for (i = 1; i <= cdtracks; i++) {
+    n += cddb_sum(Get_StartSector(i)/75 + 2);
+  }
+
+  t = Get_StartSector(i)/75 - Get_StartSector(1)/75;
+
+  global.cddb_id = (n % 0xff) << 24 | (t << 8) | cdtracks;
+}
+
+
+#undef TESTCDINDEX
+#ifdef	TESTCDINDEX
+void TestGenerateId(void)
+{
+   SHA_INFO       sha;
+   unsigned char  digest[20], *base64;
+   unsigned long  size;
+
+   sha_init(&sha);
+   sha_update(&sha, (unsigned char *)"0123456789", 10);
+   sha_final(digest, &sha);
+
+   base64 = rfc822_binary((char *)digest, 20, &size);
+   if (strncmp((char*) base64, "h6zsF82dzSCnFsws9nQXtxyKcBY-", size))
+   {
+       free(base64);
+
+       fprintf(stderr, "The SHA-1 hash function failed to properly generate the\n");
+       fprintf(stderr, "test key.\n");
+       exit(INTERNAL_ERROR);
+   }
+   free(base64);
+}
+#endif
+
+void calc_cdindex_id()
+{
+	SHA_INFO 	sha;
+	unsigned char	digest[20], *base64;
+	unsigned long	size;
+	unsigned	i;
+	char		temp[9];
+
+#ifdef	TESTCDINDEX
+	TestGenerateId();
+	g_toc[1].bTrack = 1;
+	cdtracks = 15;
+	g_toc[cdtracks].bTrack = 15;
+	i = 1;
+	g_toc[i++].dwStartSector = 0U;
+	g_toc[i++].dwStartSector = 18641U;
+	g_toc[i++].dwStartSector = 34667U;
+	g_toc[i++].dwStartSector = 56350U;
+	g_toc[i++].dwStartSector = 77006U;
+	g_toc[i++].dwStartSector = 106094U;
+	g_toc[i++].dwStartSector = 125729U;
+	g_toc[i++].dwStartSector = 149785U;
+	g_toc[i++].dwStartSector = 168885U;
+	g_toc[i++].dwStartSector = 185910U;
+	g_toc[i++].dwStartSector = 205829U;
+	g_toc[i++].dwStartSector = 230142U;
+	g_toc[i++].dwStartSector = 246659U;
+	g_toc[i++].dwStartSector = 265614U;
+	g_toc[i++].dwStartSector = 289479U;
+	g_toc[i++].dwStartSector = 325732U;
+#endif
+	sha_init(&sha);
+	sprintf(temp, "%02X", Get_Tracknumber(1));
+	sha_update(&sha, (unsigned char *)temp, 2);
+	sprintf(temp, "%02X", Get_Tracknumber(cdtracks));
+	sha_update(&sha, (unsigned char *)temp, 2);
+
+	/* the position of the leadout comes first. */
+	sprintf(temp, "%08lX", 150 + Get_StartSector(CDROM_LEADOUT));
+	sha_update(&sha, (unsigned char *)temp, 8);
+
+	/* now 99 tracks follow with their positions. */
+	for (i = 1; i <= cdtracks; i++) {
+		sprintf(temp, "%08lX", 150+Get_StartSector(i));
+		sha_update(&sha, (unsigned char *)temp, 8);
+	}
+	for (i++  ; i <= 100; i++) {
+		sha_update(&sha, (unsigned char *)"00000000", 8);
+	}
+	sha_final(digest, &sha);
+
+	base64 = rfc822_binary((char *)digest, 20, &size);
+	global.cdindex_id = base64;
+}
+
+
+#if defined CDDB_SUPPORT
+
+#ifdef	PROTOTYPES
+static void escape_and_split(FILE *channel, const char *args, ...)
+#else
+/*VARARGS3*/
+static void escape_and_split(FILE *channel, const char *args, va_dcl va_alist)
+#endif
+{
+	va_list	marker;
+
+	int prefixlen;
+	int len;
+	char	*q;
+
+#ifdef	PROTOTYPES
+	va_start(marker, args);
+#else
+	va_start(marker);
+#endif
+
+	prefixlen = strlen(args);
+	len = prefixlen;
+	fputs(args, channel);
+
+	q = va_arg(marker, char *);
+	while (*q != '\0') {
+		while (*q != '\0') {
+			len += 2;
+			if (*q == '\\')
+				fputs("\\\\", channel);
+			else if (*q == '\t')
+				fputs("\\t", channel);
+			else if (*q == '\n')
+				fputs("\\n", channel);
+			else {
+				fputc(*q, channel);
+				len--;
+			}
+			if (len > 78) {
+				fputc('\n', channel);
+				fputs(args, channel);
+				len = prefixlen;
+			}
+			q++;
+		}
+		q = va_arg(marker, char *);
+	}
+	fputc('\n', channel);
+
+	va_end(marker);
+}
+
+static void emit_cddb_form(char *fname_baseval)
+{
+  static struct iterator i;
+  unsigned first_audio;
+  FILE *cddb_form;
+  char fname[200];
+  char *pp;
+
+  if (fname_baseval == NULL || fname_baseval[0] == 0)
+	return;
+
+  if (!strcmp(fname_baseval,"standard_output")) return;
+  InitIterator(&i, 1);
+
+  strncpy(fname, fname_baseval, sizeof(fname) -1);
+  fname[sizeof(fname) -1] = 0;
+  pp = strrchr(fname, '.');
+  if (pp == NULL) {
+    pp = fname + strlen(fname);
+  }
+  strncpy(pp, ".cddb", sizeof(fname) - 1 - (pp - fname));
+
+  cddb_form = fopen(fname, "w");
+  if (cddb_form == NULL) return;
+
+  first_audio = FirstAudioTrack();
+  fprintf( cddb_form, "# xmcd\n#\n");
+  fprintf( cddb_form, "# Track frame offsets:\n#\n");
+
+  while (i.hasNextTrack(&i)) {
+	  struct TOC *p = i.getNextTrack(&i);
+	  if (GETTRACK(p) == CDROM_LEADOUT) break;
+	  fprintf( cddb_form,
+		   "# %lu\n", 150 + Get_AudioStartSector(GETTRACK(p)));
+  }
+
+  fprintf( cddb_form, "#\n# Disc length: %lu seconds\n#\n", 
+           (150 + Get_StartSector(CDROM_LEADOUT)) / 75);
+  fprintf( cddb_form, "# Revision: %u\n", global.cddb_revision );
+  fprintf( cddb_form, "# Submitted via: icedax " VERSION "\n" );
+
+  fprintf( cddb_form, "DISCID=%08lx\n", (unsigned long)global.cddb_id);
+
+  if (global.disctitle == NULL && global.creator == NULL) {
+	fprintf( cddb_form, "DTITLE=\n");
+  } else {
+	if (global.creator == NULL) {
+		escape_and_split( cddb_form, "DTITLE=", global.disctitle, "");
+	} else if (global.disctitle == NULL) {
+		escape_and_split( cddb_form, "DTITLE=", global.creator, "");
+	} else {
+		escape_and_split( cddb_form, "DTITLE=", global.creator, " / ", global.disctitle, "");
+	}
+  }
+  if (global.cddb_year != 0)
+	fprintf( cddb_form, "DYEAR=%4u\n", global.cddb_year);
+  else
+	fprintf( cddb_form, "DYEAR=\n");
+  fprintf( cddb_form, "DGENRE=%s\n", global.cddb_genre);
+
+  i.reset(&i);
+  while (i.hasNextTrack(&i)) {
+	  struct TOC *p = i.getNextTrack(&i);
+	  int ii;
+
+	  ii = GETTRACK(p);
+	  if (ii == CDROM_LEADOUT) break;
+
+	  if (global.tracktitle[ii] != NULL) {
+		char prefix[10];
+		sprintf(prefix, "TTITLE%d=", ii-1);
+		  escape_and_split( cddb_form, prefix, global.tracktitle[ii], "");
+	  } else {
+		  fprintf( cddb_form, "TTITLE%d=\n", ii-1);
+	  }
+  }
+
+  if (global.copyright_message == NULL) {
+	fprintf( cddb_form, "EXTD=\n");
+  } else {
+	escape_and_split( cddb_form, "EXTD=", "Copyright ", global.copyright_message, "");
+  }
+
+  i.reset(&i);
+  while (i.hasNextTrack(&i)) {
+	  struct TOC *p = i.getNextTrack(&i);
+	  int ii;
+
+	  ii = GETTRACK(p);
+
+	  if (ii == CDROM_LEADOUT) break;
+
+	  fprintf( cddb_form, "EXTT%d=\n", ii-1);
+  }
+  fprintf( cddb_form, "PLAYORDER=\n");
+  fclose( cddb_form );
+}
+
+#if	defined	USE_REMOTE
+#include <pwd.h>
+
+static int readn(register int fd, register char *ptr, register int nbytes)
+{
+	int	nread;
+
+	nread = read(fd, ptr, nbytes);
+#ifdef	DEBUG_CDDBP
+	if (nread > 0) {
+		fprintf(stderr, "READ :(%d)", nread);
+		write(2, ptr, nread);
+	}
+#endif
+	if (nread < 0) {
+	   perror("socket read error: ");
+	   fprintf(stderr, "fd=%d, ptr=%p, nbytes=%d\n", fd, ptr, nbytes);
+	}
+
+	return nread;
+}
+
+static ssize_t writez(int fd, const char *ptr)
+{
+	size_t nleft, nbytes;
+
+	nleft = nbytes = strlen(ptr);
+
+	while (nleft > 0) {
+		ssize_t nwritten = write(fd, ptr, nleft);
+		if (nwritten <= 0) {
+			return nwritten;	/* return error */
+		}
+#ifdef	DEBUG_CDDBP
+		fprintf(stderr, "WRITE:%s\n", ptr);
+#endif
+
+		nleft -= nwritten;
+		ptr   += nwritten;
+	}
+
+	return nbytes - nleft;
+}
+
+#define	SOCKBUFF	2048
+  
+static void filter_nonprintable(char *c, size_t l)
+{
+	size_t i;
+	for(i = 0; i < l; ++i) {
+		if(!isprint(c[i]) && !isspace(c[i])) {
+			c[i] = '_';
+		}
+	}
+}
+
+
+int process_cddb_titles(int sock_fd, char *inbuff, int readbytes);
+int process_cddb_titles(int sock_fd, char *inbuff, int readbytes)
+{
+	int	finished = 0;
+	char	*p = inbuff;
+	int	ind = 0;
+	unsigned char **	target = &global.creator;
+
+	do {
+		while (readbytes > 0) {
+			/* do we have a complete line in the buffer? */
+			p = (char *)memchr(inbuff+ind, '\n', readbytes);
+			if (p == NULL) break;
+
+			/* look for the terminator first */
+			if (!strncmp(".\r\n", inbuff+ind, 3)) {
+				finished = 1;
+				break;
+			}
+			/* kill carriage return */
+			if (p > inbuff+ind && *(p-1) == '\r') {
+				*(p-1) = '\0';
+			}
+			/* kill line feed */
+			*p = '\0';
+
+			/* handle escaped characters */
+
+			{
+				char *q = inbuff+ind;
+				while (*q) {
+					if (*q++ == '\\' && *q != '\0') {
+						if (*q == '\\') {
+							readbytes--;
+							p--;
+							memmove(q, q+1, readbytes - (q-inbuff-ind));
+						} else if (*q == 'n') {
+							*(q-1) = '\n';
+							readbytes--;
+							p--;
+							memmove(q, q+1, readbytes - (q-inbuff-ind));
+						} else if (*q == 't') {
+							*(q-1) = '\t';
+							readbytes--;
+							p--;
+							memmove(q, q+1, readbytes - (q-inbuff-ind));
+						}
+					}
+				}
+						
+			}
+
+			/* handle multi line entries concatenate fields */
+
+/* TODO if the delimiter is split into two lines, it is not recognized. */
+			if (!strncmp(inbuff+ind, "DTITLE=", 7)) {
+				char *res = strstr(inbuff+ind+7, " / ");
+				int clen;
+				char *q;
+
+				if (res == NULL) {
+					/* no limiter found yet */
+					/* copy until the end */
+					q = p;
+				} else {
+					/* limiter found */
+					/* copy until the limiter */
+					q = res;
+					*q = '\0';
+				}
+
+				clen = q - (inbuff+ind+7);
+				if (*target == NULL) {
+					*target = malloc(clen+1);
+					if (*target != NULL)
+						**target = '\0';
+				} else {
+				        *target = realloc(*target, strlen((char *)*target) + clen - 1);
+				}
+				if (*target != NULL) {
+					strcat((char *)*target, inbuff+ind+7);
+				}
+
+				/* handle part after the delimiter, if present */
+				if (res != NULL) {
+					target = (unsigned char **)&global.disctitle;
+					/* skip the delimiter */
+					q += 3;
+					clen = p - q;
+					if (*target == NULL) {
+						*target = malloc(clen+1);
+						if (*target != NULL)
+							**target = '\0';
+					}
+					if (*target != NULL) {
+						strcat((char *)*target, q);
+					}
+				}
+			} else if (!strncmp(inbuff+ind, "TTITLE", 6)) {
+				char	*q = (char *)memchr(inbuff+ind, '=', readbytes);
+				unsigned tno;
+
+				if (q != NULL) {
+					*q = '\0';
+					tno = (unsigned)atoi(inbuff+ind+6);
+					tno++;
+					if (tno < 100) {
+						if (global.tracktitle[tno] == NULL) {
+							global.tracktitle[tno] = malloc( p - q + 1 );
+							if (global.tracktitle[tno] != NULL)
+								*(global.tracktitle[tno]) = '\0';
+						} else {
+							global.tracktitle[tno] = realloc(global.tracktitle[tno], strlen((char *)global.tracktitle[tno]) + p - q + 1 );
+						}
+						if (global.tracktitle[tno] != NULL) {
+							strcat((char *)global.tracktitle[tno], q+1);
+						}
+					}
+				}
+			} else if (!strncmp(inbuff+ind, "DYEAR", 5)) {
+				char	*q = (char *)memchr(inbuff+ind, '=', readbytes);
+				if (q++ != NULL) {
+					sscanf(q, "%d", &global.cddb_year);
+				}
+			} else if (!strncmp(inbuff+ind, "DGENRE", 6)) {
+				char	*q = (char *)memchr(inbuff+ind, '=', readbytes);
+				if (q++ != NULL) {
+					/* patch from Joe Nuzman, thanks */
+					/* might have significant whitespace */
+					strncpy(global.cddb_genre, q, sizeof(global.cddb_genre)-1);
+					/* always have a terminator */
+					global.cddb_genre[sizeof(global.cddb_genre)-1] = '\0';
+				}
+			} else if (!strncmp(inbuff+ind, "# Revision: ", 12)) {
+				char	*q = inbuff+ind+11;
+				sscanf(q, "%d", &global.cddb_revision);
+				global.cddb_revision++;
+			}
+			readbytes -= (p - inbuff -ind) + 1;
+			ind = (p - inbuff) + 1;
+		}
+		if (!finished) {
+			int	newbytes;
+			memmove(inbuff, inbuff+ind, readbytes);
+			newbytes = readn(sock_fd, inbuff+readbytes, SOCKBUFF-readbytes);
+			if (newbytes < 0) {
+				fprintf(stderr, "Could not read from socket.\n");
+				return 0; /* Caller checks for != 1 */
+			}
+			filter_nonprintable(inbuff+readbytes, newbytes);
+			if (newbytes <= 0)
+				break;
+			readbytes += newbytes;
+			ind = 0;
+		}
+	} while (!(finished || readbytes == 0));
+	return finished;
+}
+
+static int handle_userchoice(char *p, unsigned size);
+
+static int handle_userchoice(char *p, unsigned size)
+{
+	unsigned	nr = 0;
+	unsigned	user_choice;
+	int		i;
+	char		*q;
+	char		*o;
+
+	/* count lines. */
+	q = p;
+	while ((q = (char *)memchr(q, '\n', size - (q-p))) != NULL) {
+		nr++;
+		q++;
+	}
+	if (nr > 1) nr--;
+
+	/* handle escaped characters */
+
+	{
+		char *r = p;
+		while (*r) {
+			if (*r++ == '\\' && *r != '\0') {
+				if (*r == '\\') {
+					size--;
+					memmove(r, r+1, size - (r-p));
+				} else if (*r == 'n') {
+					*(r-1) = '\n';
+					size--;
+					memmove(r, r+1, size - (r-p));
+				} else if (*r == 't') {
+					*(r-1) = '\t';
+					size--;
+					memmove(r, r+1, size - (r-p));
+				}
+			}
+		}
+	}
+
+	/* list entries. */
+	q = p;
+	fprintf(stderr, "%u entries found:\n", nr);
+	for (q = (char *)memchr(q, '\n', size - (q-p)), o = p, i = 0; i < nr; i++) {
+		*q = '\0';
+		fprintf(stderr, "%02u: %s\n", i, o);
+		o = q+1;
+		q = (char *)memchr(q, '\n', size - (q-p));
+	}
+	fprintf(stderr, "%02u: ignore\n", i);
+
+	/* get user response. */
+	do {
+		fprintf(stderr, "please choose one (0-%u): ", nr);
+		scanf("%u", &user_choice); /* FIXME: check return value */
+	} while (user_choice > nr);
+
+	if (user_choice == nr)
+		return -1;
+
+	/* skip to choice. */
+	q = p;
+	for (i = 0; i <= (int)user_choice - 1; i++) {
+		q = (char *)memchr(q, '\0', size - (q-p)) + 1;
+	}
+	return	q-p;
+}
+
+/* request disc and track titles from a cddbp server.
+ *
+ * return values:
+ *	0	titles have been found exactly (success)
+ *	-1	some communication error happened.
+ *	1	titles have not been found.
+ *	2	multiple fuzzy matches have been found.
+ */
+int
+request_titles(void)
+{
+	int		retval = 0;
+	int		sock_fd;
+	struct sockaddr_in sa;
+	struct hostent *he;
+	struct servent *se;
+	struct passwd *pw = getpwuid(getuid());
+	char		hostname[HOST_NAME_MAX];
+	char		inbuff[SOCKBUFF];
+	char		outbuff[SOCKBUFF];
+	int		i;
+	char		category[64];
+	unsigned	cat_offset;
+	unsigned	disc_id;
+	ssize_t		readbytes;
+
+	sock_fd = socket(AF_INET, SOCK_STREAM, 0);
+	if (sock_fd < 0) {
+		perror("cddb socket failed: ");
+		retval = -1;
+		goto errout;
+	}
+
+	/* TODO fallbacks
+	 * freedb.freedb.org
+	 * de.freedb.org
+	 * at.freedb.org
+	 */
+	if (global.cddbp_server != NULL)
+		he = gethostbyname(global.cddbp_server);
+	else
+		he = gethostbyname(CDDBHOST /*"freedb.freedb.org"*/);
+
+	if (he == NULL) {
+		perror("cddb cannot resolve freedb host: ");
+		he = malloc(sizeof(struct hostent));
+		memset(he, 0 , sizeof(struct hostent));
+		he->h_length = 4;
+		he->h_addrtype = AF_INET;
+		he->h_addr_list = malloc(4);
+		he->h_addr_list[0] = malloc(4);
+		((struct in_addr *)(he->h_addr_list[0]))->s_addr =
+			/* kingfisher.berlios.de          freedb.freedb.de */
+			 htonl(UINT_C(0xc3254d85));	/*0xc2610412*/
+		he->h_name = "freedb.freedb.org";
+#if	0
+		retval = -1;
+		goto errout;
+#endif
+	}
+
+	/* save result data IMMEDIATELY!! */
+	memset(&sa, 0 , sizeof(struct sockaddr_in));
+	sa.sin_family 	   = he->h_addrtype;	/* AF_INET; */
+	sa.sin_addr.s_addr = ((struct in_addr *)((he->h_addr_list)[0]))->s_addr;
+
+	se = NULL;
+	if (global.cddbp_port == NULL)
+		se = getservbyname("cddbp-alt", "tcp");
+
+	if (se == NULL) {
+		if (global.cddbp_port == NULL) {
+			se = getservbyname("cddbp", "tcp");
+		}
+		if (se == NULL) {
+			se = malloc(sizeof(struct servent));
+			memset(se, 0 , sizeof(struct servent));
+			se->s_port = htons(CDDBPORT /*8880*/);
+#if	0	
+			perror("cddb cannot resolve cddbp or cddbp-alt port:\n "); 
+			retval = -1;
+			goto errout;
+#endif
+		}
+	}
+	if (global.cddbp_port != NULL) {
+		se->s_port = htons(atoi(global.cddbp_port));
+	}
+
+	sa.sin_port        = se->s_port;
+
+/* TODO timeout */
+	if (0 > connect(sock_fd, (struct sockaddr *)&sa, 
+			sizeof(struct sockaddr_in))) {
+		perror("cddb connect failed: ");
+		retval = -1;
+		goto errout;
+	}
+
+	/* read banner */
+	readbytes = readn(sock_fd, inbuff, sizeof(inbuff));
+	if (readbytes < 0) {
+		fprintf(stderr, "Could not read from socket\n");
+		retval = -1;
+		goto errout;
+	}
+
+	if (strncmp(inbuff, "200 ", 4) && strncmp(inbuff, "201 ", 4)) {
+		if(readbytes == sizeof(inbuff))
+			--readbytes;
+		inbuff[readbytes] = '\0';
+		filter_nonprintable(inbuff, readbytes);
+		fprintf(stderr, "bad status from freedb server during sign-on banner: %s\n", inbuff);
+		retval = -1;
+		goto errout;
+	}
+
+	/* say hello */
+	hostname[0] = '\0'; 
+	if (0 > gethostname(hostname, sizeof(hostname)))
+		strcpy(hostname, "unknown_host"); 
+	hostname[sizeof(hostname)-1] = '\0';
+	writez(sock_fd, "cddb hello ");
+	if (pw != NULL) {
+		BOOL	space_err = FALSE;
+		BOOL	ascii_err = FALSE;
+		/* change spaces to underscores */
+		char *q = pw->pw_name;
+		while (*q != '\0') {
+			if (*q == ' ') {
+				if (!space_err) {
+					space_err = TRUE;
+					errmsgno(EX_BAD,
+					"Warning: Space in user name '%s'.\n",
+					pw->pw_name);
+				}
+				*q = '_';
+			}
+			if (*q < ' ' || *q > '~') {
+				if (!ascii_err) {
+					ascii_err = TRUE;
+					errmsgno(EX_BAD,
+					"Warning: Nonascii character in user name '%s'.\n",
+					pw->pw_name);
+				}
+				*q = '_';
+			}
+			q++;
+		}
+		writez(sock_fd, pw->pw_name);
+		writez(sock_fd, " ");
+	} else {
+		writez(sock_fd, "unknown ");
+	}
+
+	/* change spaces to underscores */
+	{
+		char *q = hostname;
+		BOOL	space_err = FALSE;
+		BOOL	ascii_err = FALSE;
+
+		while (*q != '\0') {
+			if (*q == ' ') {
+				if (!space_err) {
+					space_err = TRUE;
+					errmsgno(EX_BAD,
+					"Warning: Space in hostname '%s'.\n",
+					hostname);
+				}
+				*q = '_';
+			}
+			if (*q < ' ' || *q > '~') {
+				if (!ascii_err) {
+					ascii_err = TRUE;
+					errmsgno(EX_BAD,
+					"Warning: Nonascii character in hostname '%s'.\n",
+					hostname);
+				}
+				*q = '_';
+			}
+			q++;
+		}
+	}
+
+	writez(sock_fd, hostname);
+	writez(sock_fd, " icedax " VERSION "\n");
+
+	readbytes = readn(sock_fd, inbuff, sizeof(inbuff));
+	if (readbytes < 0) {
+		fprintf(stderr, "Could not read from socket\n");
+		retval = -1;
+		goto errout;
+	}
+	if (strncmp(inbuff, "200 ", 4)) {
+		if(readbytes == sizeof(inbuff))
+			--readbytes;
+		inbuff[readbytes] = '\0';
+		filter_nonprintable(inbuff, readbytes);
+		fprintf(stderr, "bad status from freedb server during hello: %s\n", inbuff);
+		retval = -1;
+		goto signoff;
+	}
+
+	/* enable new protocol variant. Weird command here, no cddb prefix ?!?! */
+	writez(sock_fd, "proto\n");
+	readbytes = readn(sock_fd, inbuff, sizeof(inbuff));
+	if (readbytes < 0) {
+		fprintf(stderr, "Could not read from socket\n");
+		retval = -1;
+		goto errout;
+	}
+	/* check for errors and maximum supported protocol level */
+	if (strncmp(inbuff, "201 ", 4) > 0) {
+		if(readbytes == sizeof(inbuff))
+			--readbytes;
+		inbuff[readbytes] = '\0';
+		filter_nonprintable(inbuff, readbytes);
+		fprintf(stderr, "bad status from freedb server during proto command: %s\n", inbuff);
+		retval = -1;
+		goto signoff;
+	}
+	
+	/* check the supported protocol level */
+	if (!memcmp(inbuff, "200 CDDB protocol level: current 1, supported ", 46)) {
+		char *q = strstr(inbuff, " supported ");
+		unsigned	pr_level;
+
+		if (q != NULL) {
+			q += 11;
+			sscanf(q, "%u\n", &pr_level);
+			if (pr_level > 1) {
+				if (pr_level > 5)
+					pr_level = 5;
+				sprintf(inbuff, "proto %1u\n", pr_level);
+				writez(sock_fd, inbuff);
+				readbytes = readn(sock_fd, inbuff, sizeof(inbuff));
+				if (readbytes < 0) {
+					fprintf(stderr, "Could not read from socket\n");
+					retval = -1;
+					goto errout;
+				}
+				/* check for errors and maximum supported protocol level */
+				if (strncmp(inbuff, "201 ", 4) > 0) {
+					if(readbytes == sizeof(inbuff))
+						--readbytes;
+					inbuff[readbytes] = '\0';
+					filter_nonprintable(inbuff,
+					  readbytes);
+					fprintf(stderr, "bad status from freedb server during proto x: %s\n", inbuff);
+					retval = -1;
+					goto signoff;
+				}
+			}
+		}
+	}
+
+	/* format query string */
+	/* query */
+#define	CDDPB_INCLUDING_DATATRACKS
+#ifdef	CDDPB_INCLUDING_DATATRACKS
+	sprintf(outbuff, "cddb query %08lx %ld ", (unsigned long)global.cddb_id, LastTrack() - FirstTrack() + 1);
+	/* first all leading datatracks */
+  	{
+		int j = FirstAudioTrack();
+		if (j < 0)
+			j = LastTrack() +1;
+  		for (i = FirstTrack(); i < j; i++) {
+			sprintf(outbuff + strlen(outbuff), "%ld ", 150 + Get_StartSector(i));
+		}
+	}
+#else
+	sprintf(outbuff, "cddb query %08lx %ld ", global.cddb_id, LastAudioTrack() - FirstAudioTrack() + 1);
+#endif
+	/* all audio tracks */
+  	for (i = FirstAudioTrack(); i != -1 && i <= LastAudioTrack(); i++) {
+		sprintf(outbuff + strlen(outbuff), "%ld ", 150 + Get_AudioStartSector(i));
+	}
+#ifdef	CDDPB_INCLUDING_DATATRACKS
+	/* now all trailing datatracks */
+  	for (; i != -1 && i <= LastTrack(); i++) {
+		sprintf(outbuff + strlen(outbuff), "%ld ", 150 + Get_StartSector(i));
+	}
+	sprintf(outbuff + strlen(outbuff), "%lu\n",
+           (150 + Get_StartSector(CDROM_LEADOUT)) / 75);
+#else
+	sprintf(outbuff + strlen(outbuff), "%lu\n",
+           (150 + Get_LastSectorOnCd(FirstAudioTrack())) / 75);
+#endif
+/*	strcpy(outbuff, "cddb query 9709210c 12 150 12010 33557 50765 65380 81467 93235 109115 124135 137732 152575 166742 2339\n"); */
+/*	strcpy(outbuff, "cddb query 03015501 1 296 344\n"); */
+	writez(sock_fd, outbuff);
+
+	readbytes = readn(sock_fd, inbuff, sizeof(inbuff) - 1);
+	if (readbytes < 0) {
+		fprintf(stderr, "Could not read from socket\n");
+		retval = -1;
+		goto errout;
+	}
+	inbuff[readbytes] = '\0';
+	filter_nonprintable(inbuff, readbytes);
+	cat_offset = 4;
+	if (!strncmp(inbuff, "210 ", 4)
+	   || !strncmp(inbuff, "211 ", 4)) {
+		/* Check if there are really multiple entries. */
+		char *p = (char *)memchr(inbuff, '\n', readbytes-1);
+
+		if (p != NULL) cat_offset = p+1 - inbuff;
+		/* first entry */
+		if (p) p = (char *)memchr(p+1, '\n', inbuff+readbytes - p);
+		/* second entry */
+		if (p) p = (char *)memchr(p+1, '\n', inbuff+readbytes - p);
+		/* . */
+		if (p) p = (char *)memchr(p+1, '\n', inbuff+readbytes - p);
+		if (p) {
+			/* multiple entries */
+			switch (global.cddbp) {
+				case	2:	/* take the first entry */
+				break;
+				case	1:	/* ask user */
+					if (!global.gui) {
+						int userret = handle_userchoice(inbuff+cat_offset, readbytes - cat_offset);
+						if (userret == -1) {
+							/* ignore any selection */
+							retval = -1;
+							goto signoff;
+						}
+						cat_offset += userret;
+					}
+				break;
+				default:
+					fprintf(stderr, "multiple entries found: %s\n", inbuff);
+					retval = 2;
+					goto signoff;
+			}
+		}
+
+	} else if (strncmp(inbuff, "200 ", 4)) {
+		if (!strncmp(inbuff, "202 ", 4)) {
+			fprintf(stderr, "no cddb entry found: %s\n", inbuff);
+			retval = 1;
+		} else {
+			fprintf(stderr, "bad status from freedb server during query: %s\n%s", inbuff, outbuff);
+			retval = -1;
+		}
+		goto signoff;
+	}
+	sscanf(inbuff + cat_offset, "%s %x", category, &disc_id );
+
+
+	/* read */
+	sprintf(inbuff, "cddb read %s %08x\n", category, disc_id);
+	writez(sock_fd, inbuff);
+
+	/* read status and first buffer size. */
+	readbytes = readn(sock_fd, inbuff, sizeof(inbuff));
+	if (readbytes < 0) {
+		fprintf(stderr, "Could not read from socket\n");
+		retval = -1;
+		goto errout;
+	}
+	filter_nonprintable(inbuff, readbytes);
+	if (strncmp(inbuff, "210 ", 4)) {
+		if(readbytes == sizeof(inbuff))
+			--readbytes;
+		inbuff[readbytes] = '\0';
+		fprintf(stderr, "bad status from freedb server during read: %s\n", inbuff);
+		retval = -1;
+		goto signoff;
+	}
+
+	if (1 != process_cddb_titles(sock_fd, inbuff, readbytes)) {
+		fprintf(stderr, "cddb read finished not correctly!\n");
+	}
+
+signoff:
+	/* sign-off */
+	writez(sock_fd, "quit\n");
+	readbytes = readn(sock_fd, inbuff, sizeof(inbuff));
+	if (readbytes < 0) {
+		fprintf(stderr, "Could not read from socket\n");
+		retval = -1;
+		goto errout;
+	}
+	if (strncmp(inbuff, "230 ", 4)) {
+		if(readbytes == sizeof(inbuff))
+			--readbytes;
+		inbuff[readbytes] = '\0';
+		filter_nonprintable(inbuff, readbytes);
+		fprintf(stderr, "bad status from freedb server during quit: %s\n", inbuff);
+		goto errout;
+	}
+
+errout:
+	close(sock_fd);
+	return retval;
+}
+#endif
+#endif
+
+#if	defined CDINDEX_SUPPORT
+
+static int IsSingleArtist(void);
+
+/* check, if there are more than one track creators */
+static int IsSingleArtist(void)
+{
+	static struct iterator i;
+	InitIterator(&i, 1);
+
+	while (i.hasNextTrack(&i)) {
+		struct TOC *p = i.getNextTrack(&i);
+		int ii;
+
+		if (IS__DATA(p) || GETTRACK(p) == CDROM_LEADOUT) continue;
+
+		ii = GETTRACK(p);
+		if (global.creator && global.trackcreator[ii]
+			&& strcmp((char *) global.creator,
+				  (char *) global.trackcreator[ii]) != 0)
+			return 0;
+	}
+	return 1;
+}
+
+static const char *a2h[255-191] = {
+"&Agrave;",
+"&Aacute;",
+"&Acirc;",
+"&Atilde;",
+"&Auml;",
+"&Aring;",
+"&AElig;",
+"&Ccedil;",
+"&Egrave;",
+"&Eacute;",
+"&Ecirc;",
+"&Euml;",
+"&Igrave;",
+"&Iacute;",
+"&Icirc;",
+"&Iuml;",
+"&ETH;",
+"&Ntilde;",
+"&Ograve;",
+"&Oacute;",
+"&Ocirc;",
+"&Otilde;",
+"&Ouml;",
+"&times;",
+"&Oslash;",
+"&Ugrave;",
+"&Uacute;",
+"&Ucirc;",
+"&Uuml;",
+"&Yacute;",
+"&THORN;",
+"&szlig;",
+"&agrave;",
+"&aacute;",
+"&acirc;",
+"&atilde;",
+"&auml;",
+"&aring;",
+"&aelig;",
+"&ccedil;",
+"&egrave;",
+"&eacute;",
+"&ecirc;",
+"&euml;",
+"&igrave;",
+"&iacute;",
+"&icirc;",
+"&iuml;",
+"&eth;",
+"&ntilde;",
+"&ograve;",
+"&oacute;",
+"&ocirc;",
+"&otilde;",
+"&ouml;",
+"&divide;",
+"&oslash;",
+"&ugrave;",
+"&uacute;",
+"&ucirc;",
+"&uuml;",
+"&yacute;",
+"&thorn;",
+"&yuml;",
+};
+
+static char *ascii2html(unsigned char *inp)
+{
+	static size_t buflen = 256;
+	static char *outline = 0;
+	size_t pos = 0;
+    size_t l=0;
+
+	/* init */
+	if(!outline) {
+		outline = malloc(buflen);
+		if(outline == 0) {
+			fprintf(stderr, "error: memory exhausted\n");
+			_exit(EXIT_FAILURE);
+		}
+	}
+
+	outline[pos] = '\0';
+
+	while (*inp != '\0') {
+
+		/* Pick the sequence to insert */
+		const char *insert;
+		char b[2];
+		const int c = (unsigned char)*inp;
+		switch(c) {
+			case '"':	insert = "&quot;";	break;
+			case '&':	insert = "&amp;";	break;
+			case '<':	insert = "&lt;";	break;
+			case '>':	insert = "&gt;";	break;
+			case 160:	insert = "&nbsp;";	break;
+			default: {
+					 if(c < 192) {
+						 b[0] = c;
+						 b[1] = '\0';
+						 insert = b;
+					 } else {
+						 insert = a2h[c - 192];
+					 }
+				 }
+		};
+
+		/* Resize buffer */
+		l = strlen(insert);
+		while(pos + l + 1 >= buflen) {
+			outline = realloc(outline, buflen *= 2);
+			if(outline == 0) {
+				fprintf(stderr, "error: memory exhausted\n");
+				_exit(EXIT_FAILURE);
+			}
+		}
+
+		/* Copy in */
+		strcpy(&outline[pos], insert);
+		pos += l;
+
+		++inp;
+	}
+
+	return outline;
+}
+
+static void emit_cdindex_form(char *fname_baseval)
+{
+  FILE *cdindex_form;
+  char fname[200];
+  char *pp;
+
+  if (fname_baseval == NULL || fname_baseval[0] == 0)
+	return;
+
+  strncpy(fname, fname_baseval, sizeof(fname) -1);
+  fname[sizeof(fname) -1] = 0;
+  pp = strrchr(fname, '.');
+  if (pp == NULL) {
+    pp = fname + strlen(fname);
+  }
+  strncpy(pp, ".cdindex", sizeof(fname) - 1 - (pp - fname));
+
+  cdindex_form = fopen(fname, "w");
+  if (cdindex_form == NULL) return;
+
+#define	CDINDEX_URL	"http://www.musicbrainz.org/dtd/CDInfo.dtd"
+
+  /* format XML page according to cdindex DTD (see www.musicbrainz.org) */
+  fprintf( cdindex_form, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<!DOCTYPE CDInfo SYSTEM \"%s\">\n\n<CDInfo>\n",
+		  CDINDEX_URL);
+
+  fprintf( cdindex_form, "   <Title>%s</Title>\n",
+	 global.disctitle ? ascii2html(global.disctitle) : "");
+  /* 
+   * In case of mixed mode and Extra-CD, nonaudio tracks are included!
+   */
+  fprintf( cdindex_form, "   <NumTracks>%d</NumTracks>\n\n", cdtracks);
+  fprintf( cdindex_form, "   <IdInfo>\n      <DiskId>\n         <Id>%s</Id>\n      </DiskId>\n", global.cdindex_id); 
+
+  fprintf( cdindex_form, "   </IdInfo>\n\n");
+
+  if (IsSingleArtist()) {
+    static struct iterator i;
+    InitIterator(&i, 1);
+
+    fprintf( cdindex_form, "   <SingleArtistCD>\n      <Artist>%s</Artist>\n",
+	 global.creator ? ascii2html(global.creator) : "");
+
+    while (i.hasNextTrack(&i)) {
+	    struct TOC *p = i.getNextTrack(&i);
+	    int ii = GETTRACK(p);
+
+	    if (ii == CDROM_LEADOUT) break;
+	    if (IS__AUDIO(p)) {
+		    fprintf( cdindex_form,
+			     "      <Track Num=\"%d\">\n         <Name>%s</Name>\n      </Track>\n",
+			     ii, global.tracktitle[ii] ? ascii2html(global.tracktitle[ii]) : "");
+	    } else {
+		    fprintf( cdindex_form,
+			     "      <Track Num=\"%d\">\n         <Name>data track</Name>\n      </Track>\n",
+			     ii );
+	    }
+    }
+    fprintf( cdindex_form, "   </SingleArtistCD>\n");
+  } else {
+    static struct iterator i;
+    InitIterator(&i, 1);
+
+    fprintf( cdindex_form, "   <MultipleArtistCD>\n");
+
+    while (i.hasNextTrack(&i)) {
+	    struct TOC *p = i.getNextTrack(&i);
+	    int ii = GETTRACK(p);
+
+	    if (ii == CDROM_LEADOUT) break;
+	    if (IS__AUDIO(p)) {
+		    fprintf( cdindex_form, "         <Artist>%s</Artist>\n",
+			     global.trackcreator[ii] ? ascii2html(global.trackcreator[ii]) : "");
+		    fprintf( cdindex_form, "         <Name>%s</Name>\n      </Track>\n",
+		  global.tracktitle[ii] ? ascii2html(global.tracktitle[ii]) : "");
+	    } else {
+		    fprintf( cdindex_form,
+			     "         <Artist>data track</Artist>\n         <Name>data track</Name>\n      </Track>\n");
+	    }
+    }
+    fprintf( cdindex_form, "   </MultipleArtistCD>\n");
+  }
+  fprintf( cdindex_form, "</CDInfo>\n");
+
+  fclose( cdindex_form );
+}
+#endif
+
+static void dump_cdtext_info(void)
+{
+#ifdef CD_TEXT
+  /* interpret the contents of CD Text information based on an early draft
+     of SCSI-3 mmc version 2 from jan 2, 1998
+     CD Text information consists of a text group containing up to
+     8 language blocks containing up to
+     255 Pack data chunks of
+     18 bytes each.
+     So we have at most 36720 bytes to cope with.
+   */
+  {
+    short int datalength;
+    unsigned char *p = bufferTOC;
+    unsigned char lastline[255*12];
+    int		lastitem = -1;
+    int		itemcount = 0;
+    int		inlinecount = 0;
+    int		outlinecount = 0;
+
+    lastline[0] = '\0';
+    datalength = ((p[0] << 8) + p[1]) - 2;
+    datalength = min(datalength, 2048-4);
+    p += 4;
+    for (;datalength > 0;
+	datalength -= sizeof (cdtextpackdata),
+	p += sizeof (cdtextpackdata)) {
+      unsigned char *zeroposition;
+
+      /* handle one packet of CD Text Information Descriptor Pack Data */
+      /* this is raw R-W subchannel data converted to 8 bit values. */
+      cdtextpackdata *c = (cdtextpackdata *)p;
+      int dbcc;
+      int crc_error;
+      unsigned tracknr;
+
+#ifdef DEBUG_CDTEXT
+      fprintf(stderr, "datalength =%d\n", datalength);
+#endif
+      crc_error = !cdtext_crc_ok(c);
+
+      if (lastitem != c->headerfield[0]) {
+	itemcount = 0;
+	lastitem = c->headerfield[0];
+      }
+
+      tracknr = c->headerfield[1] & 0x7f;
+      dbcc = ((unsigned)(c->headerfield[3] & 0x80)) >> 7; /* double byte character code */
+
+#if defined DEBUG_CDTEXT
+	{
+      int extension_flag;
+      int sequence_number;
+      int block_number;
+      int character_position;
+
+      extension_flag = ((unsigned)(c->headerfield[1] & 0x80)) >> 7;
+      sequence_number = c->headerfield[2];
+      block_number = ((unsigned)(c->headerfield[3] & 0x30)) >> 4; /* language */
+      character_position = c->headerfield[3] & 0x0f;
+
+      fprintf(stderr, "CDText: ext_fl=%d, trnr=%u, seq_nr=%d, dbcc=%d, block_nr=%d, char_pos=%d\n",
+             extension_flag, tracknr, sequence_number, dbcc, block_number, character_position);
+	}
+#endif
+
+      /* print ASCII information */
+      memcpy(lastline+inlinecount, c->textdatafield, 12);
+      inlinecount += 12;
+      zeroposition = (unsigned char *)memchr(lastline+outlinecount, '\0', inlinecount-outlinecount);
+      while (zeroposition != NULL) {
+	  process_header(c, tracknr, dbcc, lastline+outlinecount);
+	  outlinecount += zeroposition - (lastline+outlinecount) + 1;
+
+#if defined DEBUG_CDTEXT
+	  fprintf(stderr, "\tin=%d, out=%d, items=%d, trcknum=%u\n", inlinecount, outlinecount, itemcount, tracknr);
+{ int q; for (q= outlinecount; q < inlinecount; q++) fprintf (stderr, "%c", lastline[q] ? lastline[q] : 'ß'); fputs("\n", stderr); }
+#else
+	  if (DETAILED) {
+	    if (crc_error) fputs(" ! uncorr. CRC-Error", stderr);
+	    fputs("\n", stderr);
+	  }
+#endif
+
+	  itemcount++;
+	  if (itemcount > (int)cdtracks
+	      	|| (c->headerfield[0] == 0x8f
+		|| (c->headerfield[0] <= 0x8d && c->headerfield[0] >= 0x86))) {
+	    outlinecount = inlinecount;
+	    break;
+	  }
+	  tracknr++;
+	  zeroposition = (unsigned char *)memchr(lastline+outlinecount, '\0', inlinecount-outlinecount);
+      }
+    }
+  }
+#endif
+}
+
+
+
+static void dump_extra_info(unsigned int from)
+{
+#ifdef CD_EXTRA
+  unsigned char *p;
+  unsigned pos, length;
+
+  if (from == 0) return;
+
+  p = Extra_buffer + 48;
+  while (*p != '\0') {
+    pos    = GET_BE_UINT_FROM_CHARP(p+2);
+    length = GET_BE_UINT_FROM_CHARP(p+6);
+    if (pos == (unsigned)-1) {
+      pos = from+1;
+    } else {
+      pos += session_start;
+    }
+
+#ifdef DEBUG_XTRA
+    if (global.gui == 0 && global.verbose != 0) {
+	fprintf(stderr, "Language: %c%c (as defined by ISO 639)", *p, *(p+1));
+	fprintf(stderr, " at sector %u, len=%u (sessionstart=%u)", pos, length, session_start);
+	fputs("\n", stderr);
+    }
+#endif
+    /* dump this entry */
+    Read_Subinfo(pos, length);
+    p += 10;
+
+    if (p + 9 > (Extra_buffer + CD_FRAMESIZE))
+      break;
+  }
+#endif
+}
+
+static char *quote(unsigned char *string);
+
+static char *quote(unsigned char *string)
+{
+  static char result[200];
+  unsigned char *p = (unsigned char *)result;
+
+  while (*string) {
+    if (*string == '\'' || *string == '\\') {
+	*p++ = '\\';
+    }
+    *p++ = *string++;
+  }
+  *p = '\0';
+
+  return result;
+}
+
+
+
+static void DisplayToc_with_gui(unsigned long dw);
+
+static void DisplayToc_with_gui(unsigned long dw)
+{
+	unsigned mins;
+	unsigned secnds;
+	unsigned frames;
+	int count_audio_trks;
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, 1);
+	else i.reset(&i);
+
+	mins	=   dw / ( 60*75 );
+	secnds  = ( dw % ( 60*75 ) ) / 75;
+	frames  = ( dw %      75   );
+
+	/* summary */
+	count_audio_trks = 0;
+
+	if ((global.verbose & SHOW_STARTPOSITIONS) != 0) {
+		if (global.illleadout_cd != 0 && have_CD_extra == 0) {
+			fprintf( stderr, "Tracks:%u > %u:%02u.%02u\n", cdtracks, mins, secnds, frames );
+		} else {
+			fprintf( stderr, "Tracks:%u %u:%02u.%02u\n", cdtracks, mins, secnds, frames );
+		}
+	}
+
+	if (global.quiet == 0) {
+		fprintf( stderr, "CDINDEX discid: %s\n", global.cdindex_id);
+		fprintf( stderr, "CDDB discid: 0x%08lx", (unsigned long) global.cddb_id);
+
+		if (have_CDDB != 0) {
+			fprintf(stderr, " CDDBP titles: resolved\n");
+		} else {
+			fprintf(stderr, "\n");
+		}
+		if (have_CD_text != 0) {
+			fprintf(stderr, "CD-Text: detected\n");
+			dump_cdtext_info();
+		} else {
+			fprintf(stderr, "CD-Text: not detected\n");
+		}
+		if (have_CD_extra != 0) {
+			fprintf(stderr, "CD-Extra: detected\n");
+			dump_extra_info(have_CD_extra);
+		} else {
+			fprintf(stderr, "CD-Extra: not detected\n");
+		}
+ 
+		fprintf( stderr, 
+			 "Album title: '%s'", (void *)global.disctitle != NULL
+			 ? quote(global.disctitle) : "");
+
+		fprintf( stderr, " from '%s'\n", (void *)global.creator != NULL 
+			 ? quote(global.creator) : "");
+	}
+	count_audio_trks = 0;
+
+
+	if ((global.verbose & (SHOW_TOC | SHOW_STARTPOSITIONS | SHOW_SUMMARY | SHOW_TITLES)) != 0
+	    && i.hasNextTrack(&i)) {
+		TOC *o = i.getNextTrack(&i);
+		while (i.hasNextTrack(&i)) {
+			TOC *p = i.getNextTrack(&i);
+			int from;
+			from = GETTRACK(o);
+
+			fprintf(stderr,	"T%02d:", from);
+
+			if (IS__DATA(o)) {
+				/*
+				 * Special case of cd extra
+				 */
+				unsigned int real_start = have_CD_extra
+					? have_CD_extra	: GETSTART(o);
+
+
+				dw = (unsigned long) (GETSTART(p) - real_start);
+
+				mins   =   dw / ( 60*75 );
+				secnds = ( dw % ( 60*75 )) / 75;
+				frames = ( dw %      75   );
+
+				if ( global.verbose & SHOW_STARTPOSITIONS )
+					fprintf(stderr,
+						" %7u",
+						real_start
+					);
+
+				if ( global.verbose & SHOW_TOC )
+					fprintf(stderr,
+						" %2u:%02u.%02u",
+						mins, secnds, frames
+					);
+
+				if ( global.verbose & SHOW_SUMMARY )
+					fprintf(stderr,
+						" data %s %s N/A",
+						
+						/* how recorded */
+						IS__INCREMENTAL(o)
+						? "incremental" : "uninterrupted",
+
+						/* copy-permission */
+						IS__COPYRIGHTED(o)
+						? "copydenied" : "copyallowed"
+					);
+				fputs("\n", stderr);
+			} else {
+				dw = (unsigned long) (GETSTART(p) - GETSTART(o));
+				mins   =   dw / ( 60*75 );
+				secnds = ( dw % ( 60*75 )) / 75;
+				frames = ( dw %      75   );
+					
+				if ( global.verbose & SHOW_STARTPOSITIONS )
+					fprintf(stderr,
+						" %7u",
+						GETSTART(o)
+					);
+
+				if ( global.verbose & SHOW_TOC )
+					fprintf(stderr,
+						" %2u:%02u.%02u",
+						mins, secnds, frames
+					);
+
+				if ( global.verbose & SHOW_SUMMARY )
+					fprintf(stderr,
+						" audio %s %s %s",
+
+					/* how recorded */
+					IS__PREEMPHASIZED(o)
+					? "pre-emphasized" : "linear",
+						
+					/* copy-permission */
+					IS__COPYRIGHTED(o)
+					? "copydenied" : "copyallowed",
+
+					/* channels */
+					IS__QUADRO(o)
+						? "quadro" : "stereo");
+
+				/* Title */
+				if ( global.verbose & SHOW_TITLES ) {
+					fprintf(stderr,
+						" title '%s' from ",
+
+						(void *) global.tracktitle[GETTRACK(o)] != NULL
+						? quote(global.tracktitle[GETTRACK(o)]) : ""
+					);
+					
+					fprintf(stderr,
+						"'%s'",
+
+						(void *) global.trackcreator[GETTRACK(o)] != NULL
+						? quote(global.trackcreator[GETTRACK(o)]) : ""
+					);
+				}
+				fputs("\n", stderr);
+				count_audio_trks++;
+			}
+			o = p;
+		} /* while */
+		if ( global.verbose & SHOW_STARTPOSITIONS )
+			if (GETTRACK(o) == CDROM_LEADOUT) {
+				fprintf(stderr, "Leadout: %7u\n", GETSTART(o));
+			}
+	} /* if */
+}
+
+static void DisplayToc_no_gui(unsigned long dw);
+
+static void DisplayToc_no_gui(unsigned long dw)
+{
+	unsigned mins;
+	unsigned secnds;
+	unsigned frames;
+	int count_audio_trks;
+	unsigned ii = 0;
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, 1);
+	else i.reset(&i);
+
+	mins	=   dw / ( 60*75 );
+	secnds  = ( dw % ( 60*75 ) ) / 75;
+	frames  = ( dw %      75   );
+
+	/* summary */
+	count_audio_trks = 0;
+
+	if (i.hasNextTrack(&i)) {
+		TOC *o = i.getNextTrack(&i);
+		while (i.hasNextTrack(&i)) {
+			TOC *p = i.getNextTrack(&i);
+			int from;
+			from = GETTRACK(o);
+
+
+			while ( p != NULL && GETTRACK(p) != CDROM_LEADOUT
+				&& GETFLAGS(o) == GETFLAGS(p) ) {
+				o = p;
+				p = i.getNextTrack(&i);
+			}
+			if ((global.verbose & SHOW_SUMMARY) == 0) continue;
+
+			if (IS__DATA(o)) {
+				fputs( " DATAtrack recorded      copy-permitted tracktype\n" , stderr);
+				fprintf(stderr,
+					"     %2d-%2d %13.13s %14.14s      data\n",
+					from,
+					GETTRACK(o),
+					/* how recorded */
+					IS__INCREMENTAL(o) 
+					 ? "incremental" : "uninterrupted",
+
+					/* copy-perm */
+					IS__COPYRIGHTED(o) ? "no" : "yes"
+					);
+			} else { 
+				fputs( "AUDIOtrack pre-emphasis  copy-permitted tracktype channels\n" , stderr);
+				fprintf(stderr,
+					"     %2d-%2d %12.12s  %14.14s     audio    %1c\n",
+					from,
+					GETTRACK(o),
+					IS__PREEMPHASIZED(o) 
+					 ? "yes" : "no",
+					IS__COPYRIGHTED(o) ? "no" : "yes",
+					IS__QUADRO(o) ? '4' : '2'
+					);
+				count_audio_trks++;
+			}
+			o = p;
+		}
+	}
+	if ((global.verbose & SHOW_STARTPOSITIONS) != 0) {
+		if (global.illleadout_cd != 0 && have_multisession == 0) {
+
+			fprintf ( stderr, 
+				  "Table of Contents: total tracks:%u, (total time more than %u:%02u.%02u)\n",
+				  cdtracks, mins, secnds, frames );
+		} else {
+			fprintf ( stderr, 
+				  "Table of Contents: total tracks:%u, (total time %u:%02u.%02u)\n",
+				  cdtracks, mins, secnds, frames );
+		}
+	}
+
+	i.reset(&i);
+	if ((global.verbose & SHOW_TOC) != 0 &&
+		i.hasNextTrack(&i)) {
+		TOC *o = i.getNextTrack(&i);
+
+		for (; i.hasNextTrack(&i);) {
+			TOC *p = i.getNextTrack(&i);
+
+			if ( GETTRACK(o) <= MAXTRK ) {
+				unsigned char brace1, brace2;
+				unsigned trackbeg;
+				trackbeg = have_multisession && IS__DATA(o) ? have_multisession : GETSTART(o);
+			
+				dw = (unsigned long) (GETSTART(p) - trackbeg);
+				mins   =   dw / ( 60*75 );
+				secnds = ( dw % ( 60*75 )) / 75;
+				frames = ( dw %      75   );
+
+				if ( IS__DATA(o) ) {
+					/* data track display */
+					brace1 = '[';
+					brace2 = ']';
+				} else if (have_multisession
+					   && GETTRACK(o) == LastAudioTrack()) {
+					/* corrected length of
+					 * last audio track in cd extra
+					 */
+					brace1 = '|';
+					brace2 = '|';
+				} else {
+					/* audio track display */
+					brace1 = '(';
+					brace2 = ')';
+				}
+				fprintf ( stderr,
+					  " %2u.%c%2u:%02u.%02u%c",
+					  GETTRACK(o),
+					  brace1,
+					  mins, secnds, frames,
+					  brace2
+					);
+				ii++;
+			
+				if ( ii % 5 == 0 )
+					fputs( ",\n", stderr );
+				else if (ii != cdtracks)
+					fputc ( ',', stderr );
+			}
+			o = p;
+		} /* for */
+		if ( (ii % 5) != 0 )
+			fputs( "\n", stderr );
+	
+	} /* if */
+
+	if ((global.verbose & SHOW_STARTPOSITIONS) != 0) {
+		fputs ("\nTable of Contents: starting sectors\n", stderr);
+
+		ii = 0;
+		i.reset(&i);
+		if (i.hasNextTrack(&i)) {
+			TOC *o = i.getNextTrack(&i);
+			for ( ; i.hasNextTrack(&i);) {
+				TOC *p = i.getNextTrack(&i);
+				fprintf ( stderr,
+					  " %2u.(%8u)",
+					  GETTRACK(o),
+					  have_multisession
+					   && GETTRACK(o) == FirstDataTrack()
+					    ? have_multisession
+					    : GETSTART(o)
+#ifdef DEBUG_CDDB
+					  +150
+#endif
+					);
+
+				ii++;
+				if ( (ii) % 5 == 0 )
+					fputs( ",\n", stderr );
+				else
+					fputc ( ',', stderr );
+				o = p;
+			}
+			fprintf ( stderr, " lead-out(%8u)", GETSTART(o));
+			fputs ("\n", stderr);
+		}
+	}
+	if (global.quiet == 0) {
+		fprintf(stderr, "CDINDEX discid: %s\n", global.cdindex_id);
+		fprintf( stderr, "CDDB discid: 0x%08lx", (unsigned long) global.cddb_id);
+
+		if (have_CDDB != 0) {
+			fprintf(stderr, " CDDBP titles: resolved\n");
+		} else {
+			fprintf(stderr, "\n");
+		}
+		if (have_CD_text != 0) {
+			fprintf(stderr, "CD-Text: detected\n");
+		} else {
+			fprintf(stderr, "CD-Text: not detected\n");
+		}
+		if (have_CD_extra != 0) {
+			fprintf(stderr, "CD-Extra: detected\n");
+		} else {
+			fprintf(stderr, "CD-Extra: not detected\n");
+		}
+	}
+	if ((global.verbose & SHOW_TITLES) != 0) {
+		int maxlen = 0;
+		
+		if ( global.disctitle != NULL ) {
+			fprintf( stderr, "Album title: '%s'", global.disctitle);
+			if ( global.creator != NULL ) {
+				fprintf( stderr, "\t[from %s]", global.creator);
+			}
+			fputs("\n", stderr);
+		}
+
+		i.reset(&i);
+		for ( ; i.hasNextTrack(&i);) {
+			TOC *p = i.getNextTrack(&i);
+			int jj = GETTRACK(p);
+
+			if ( global.tracktitle[jj] != NULL ) {
+				int len = strlen((char *)global.tracktitle[jj]);
+				maxlen = max(maxlen, len);
+			}
+		}
+		maxlen = (maxlen + 12 + 8 + 7)/8;
+		
+		i.reset(&i);
+		for ( ; i.hasNextTrack(&i); ) {
+			TOC *p = i.getNextTrack(&i);
+			int jj;
+
+			if (IS__DATA(p))
+				continue;
+
+			jj = GETTRACK(p);
+
+			if (jj == CDROM_LEADOUT)
+				break;
+			
+			if ( maxlen != 3 ) {
+				if ( global.tracktitle[jj] != NULL ) {
+					fprintf( stderr, "Track %2u: '%s'", jj, global.tracktitle[jj]);
+				} else {
+					fprintf( stderr, "Track %2u: '%s'", jj, "");
+				}
+				if ( global.trackcreator[jj] != NULL
+				     && global.trackcreator[jj][0] != '\0'
+#if 1
+				     && (global.creator == NULL
+					 || 0 != strcmp((char *)global.creator,(char *)global.trackcreator[jj]))
+#endif
+					) {
+					int j;
+					char *o = global.tracktitle[jj] != NULL
+						? (char *)global.tracktitle[jj]
+						: "";
+					for ( j = 0;
+					      j < (maxlen - ((int)strlen(o) + 12)/8);
+					      j++)
+						fprintf(stderr, "\t");
+					fprintf( stderr, "[from %s]", global.trackcreator[jj]);
+				}
+				fputs("\n", stderr);
+			}
+		}
+	}
+}
+
+void DisplayToc(void)
+{
+	unsigned long dw;
+
+	/* special handling of pseudo-red-book-audio cds */
+	if (cdtracks > 1
+	    && Get_StartSector(CDROM_LEADOUT) < Get_StartSector(cdtracks)) {
+		global.illleadout_cd = 1;
+		can_read_illleadout();
+	}
+
+
+	/* get total time */
+	if (global.illleadout_cd == 0)
+		dw = (unsigned long) Get_StartSector(CDROM_LEADOUT) - Get_StartSector(1);
+	else
+		dw = (unsigned long) Get_StartSector(cdtracks     ) - Get_StartSector(1);
+
+	if ( global.gui == 0 ) {
+		/* table formatting when in cmdline mode */
+		DisplayToc_no_gui( dw );
+	} else if (global.gui == 1) {
+		/* line formatting when in gui mode */
+		DisplayToc_with_gui( dw );
+	}
+
+	if (global.illleadout_cd != 0) {
+		if (global.quiet == 0) {
+			fprintf(stderr, "CD with illegal leadout position detected!\n");
+		}
+
+		if (global.reads_illleadout == 0) {
+			/* limit accessible tracks 
+			 * to lowered leadout position
+			 */
+			restrict_tracks_illleadout();
+
+			if (global.quiet == 0) {
+				fprintf(stderr,
+					"The cdrom drive firmware does not permit access beyond the leadout position!\n");
+			}
+			if (global.verbose & (SHOW_ISRC | SHOW_INDICES)) {
+				global.verbose &= ~(SHOW_ISRC | SHOW_INDICES);
+				fprintf(stderr, "Switching index scan and ISRC scan off!\n");
+			}
+
+			if (global.quiet == 0) {
+				fprintf(stderr,
+					"Audio extraction will be limited to track %ld with maximal %ld sectors...\n",
+					LastTrack(),
+					Get_EndSector(LastTrack())+1
+					);
+			}
+		} else {
+			/* The cdrom drive can read beyond the
+			 * indicated leadout. We patch a new leadout
+			 * position to the maximum:
+			 *   99 minutes, 59 seconds, 74 frames
+			 */
+			patch_real_end(150 + (99*60+59)*75 + 74);
+			if (global.quiet == 0) {
+				fprintf(stderr,
+					"Restrictions apply, since the size of the last track is unknown!\n");
+			}
+		}
+	}
+}
+
+static void Read_MCN_toshiba(subq_chnl **sub_ch);
+
+static void Read_MCN_toshiba(subq_chnl **sub_ch)
+{
+	if (Toshiba3401() != 0 && global.quiet == 0
+	    && ((*sub_ch) != 0
+		|| (((subq_catalog *)(*sub_ch)->data)->mc_valid & 0x80))) {
+		/* no valid MCN yet. do more searching */
+		long h = Get_AudioStartSector(1);
+		
+		while (h <= Get_AudioStartSector(1) + 100) {
+			if (Toshiba3401())
+				ReadCdRom(get_scsi_p(), RB_BASE->data, h, global.nsectors);
+			(*sub_ch) = ReadSubQ(get_scsi_p(), GET_CATALOGNUMBER,0);
+			if ((*sub_ch) != NULL) {
+				subq_catalog *subq_cat;
+
+				subq_cat = (subq_catalog *) (*sub_ch)->data;
+				if ((subq_cat->mc_valid & 0x80) != 0) {
+					break;
+				}
+			}
+			h += global.nsectors;
+		}
+	}
+}
+
+static void Get_Set_MCN(void);
+
+static void Get_Set_MCN(void)
+{
+	subq_chnl *sub_ch;
+	subq_catalog *subq_cat = NULL;
+	fprintf(stderr, "scanning for MCN...");
+    
+	sub_ch = ReadSubQ(get_scsi_p(), GET_CATALOGNUMBER,0);
+
+#define EXPLICIT_READ_MCN_ISRC 1
+#if EXPLICIT_READ_MCN_ISRC == 1 /* TOSHIBA HACK */
+	Read_MCN_toshiba( &sub_ch );
+#endif
+
+	if (sub_ch != NULL)
+		subq_cat = (subq_catalog *)sub_ch->data;
+			
+	if (sub_ch != NULL
+	    && (subq_cat->mc_valid & 0x80) != 0
+	    && global.quiet == 0) {
+
+		/* unified format guesser:
+		 * format MCN all digits in bcd
+		 *     1                                  13
+		 * A: ab cd ef gh ij kl m0  0  0  0  0  0  0  Plextor 6x Rel. 1.02
+		 * B: 0a 0b 0c 0d 0e 0f 0g 0h 0i 0j 0k 0l 0m  Toshiba 3401
+		 * C: AS AS AS AS AS AS AS AS AS AS AS AS AS  ASCII SCSI-2 Plextor 4.5x and 6x Rel. 1.06
+		 */
+		unsigned char *cp = subq_cat->media_catalog_number;
+		if (!(cp[8] | cp[9] | cp[10] | cp[11] | cp[12])
+		    && ((cp[0] & 0xf0) | (cp[1] & 0xf0)
+			| (cp[2] & 0xf0) | (cp[3] & 0xf0)
+			| (cp[4] & 0xf0) | (cp[5] & 0xf0)
+			| (cp[6] & 0xf0))) {
+			/* reformat A: to B: */
+			cp[12] = cp[6] >> 4; cp[11] = cp[5] & 0xf;
+			cp[10] = cp[5] >> 4; cp[ 9] = cp[4] & 0xf;
+			cp[ 8] = cp[4] >> 4; cp[ 7] = cp[3] & 0xf;
+			cp[ 6] = cp[3] >> 4; cp[ 5] = cp[2] & 0xf;
+			cp[ 4] = cp[2] >> 4; cp[ 3] = cp[1] & 0xf;
+			cp[ 2] = cp[1] >> 4; cp[ 1] = cp[0] & 0xf;
+			cp[ 0] = cp[0] >> 4;
+		}
+
+		if (!isdigit(cp[0])
+		    && (memcmp(subq_cat->media_catalog_number,
+			       "\0\0\0\0\0\0\0\0\0\0\0\0\0", 13) != 0)) {
+			sprintf((char *)
+				subq_cat->media_catalog_number, 
+				"%1.1X%1.1X%1.1X%1.1X%1.1X%1.1X%1.1X%1.1X%1.1X%1.1X%1.1X%1.1X%1.1X", 
+				subq_cat->media_catalog_number [0],
+				subq_cat->media_catalog_number [1],
+				subq_cat->media_catalog_number [2],
+				subq_cat->media_catalog_number [3],
+				subq_cat->media_catalog_number [4],
+				subq_cat->media_catalog_number [5],
+				subq_cat->media_catalog_number [6],
+				subq_cat->media_catalog_number [7],
+				subq_cat->media_catalog_number [8],
+				subq_cat->media_catalog_number [9],
+				subq_cat->media_catalog_number [10],
+				subq_cat->media_catalog_number [11],
+				subq_cat->media_catalog_number [12]
+				);
+		}
+
+		if (memcmp(subq_cat->media_catalog_number,"0000000000000",13)
+		    != 0) {
+			Set_MCN(subq_cat->media_catalog_number);
+		}
+	}
+}
+
+
+static void Read_ISRC_toshiba(subq_chnl **sub_ch, unsigned tr);
+
+static void Read_ISRC_toshiba(subq_chnl **sub_ch, unsigned tr)
+{
+	if (Toshiba3401() != 0) {
+		int j;
+		j = (Get_AudioStartSector(tr)/100 + 1) * 100;
+		do {
+			ReadCdRom(get_scsi_p(), RB_BASE->data, j, global.nsectors);
+			*sub_ch = ReadSubQ(get_scsi_p(), GET_TRACK_ISRC, Get_Tracknumber(tr));
+			if (*sub_ch != NULL) {
+				subq_track_isrc * subq_tr;
+
+				subq_tr = (subq_track_isrc *) (*sub_ch)->data;
+				if (subq_tr != NULL && (subq_tr->tc_valid & 0x80) != 0)
+					break;
+			}
+			j += global.nsectors;
+		} while (j < (Get_AudioStartSector(tr)/100 + 1) * 100 + 100);
+	}
+}
+
+
+static void Get_Set_ISRC(unsigned tr);
+
+static void Get_Set_ISRC(unsigned tr)
+{
+	subq_chnl *sub_ch;
+	subq_track_isrc * subq_tr;
+
+	fprintf(stderr, "\rscanning for ISRCs: %d ...", tr);
+
+	subq_tr = NULL;
+	sub_ch = ReadSubQ(get_scsi_p(), GET_TRACK_ISRC, tr);
+
+#if EXPLICIT_READ_MCN_ISRC == 1 /* TOSHIBA HACK */
+	Read_ISRC_toshiba( &sub_ch, tr );
+#endif
+    
+	if (sub_ch != NULL)
+		subq_tr = (subq_track_isrc *)sub_ch->data;
+	
+	if (sub_ch != NULL && (subq_tr->tc_valid & 0x80)
+	    && global.quiet == 0) {
+		unsigned char p_start[16];
+		unsigned char *p = p_start;
+		unsigned char *cp = subq_tr->track_isrc;
+
+		/* unified format guesser:
+		 * there are 60 bits and 15 bytes available.
+		 * 5 * 6bit-items + two zero fill bits + 7 * 4bit-items
+		 *
+		 * A: ab cd ef gh ij kl mn o0 0  0  0  0  0  0  0  Plextor 6x Rel. 1.02
+		 * B: 0a 0b 0c 0d 0e 0f 0g 0h 0i 0j 0k 0l 0m 0n 0o Toshiba 3401
+		 * C: AS AS AS AS AS AS AS AS AS AS AS AS AS AS AS ASCII SCSI-2
+		 * eg 'G''B''-''A''0''7''-''6''8''-''0''0''2''7''0' makes most sense
+		 * D: 'G''B''A''0''7''6''8''0''0''2''7''0'0  0  0  Plextor 6x Rel. 1.06 and 4.5x R. 1.01 and 1.04
+		 */
+
+		/* Check for format A: */
+		if (!(cp[8] | cp[9] | cp[10] | cp[11] | cp[12] | cp[13] | cp[14]) &&
+		    ((cp[0] & 0xf0) | (cp[1] & 0xf0) | (cp[2] & 0xf0) | 
+		     (cp[3] & 0xf0) | (cp[4] & 0xf0) | (cp[5] & 0xf0) | 
+		     (cp[6] & 0xf0) | (cp[7] & 0xf0))) {
+#if DEBUG_ISRC
+	fprintf(stderr, "a!\t");
+#endif
+			/* reformat A: to B: */
+			cp[14] = cp[7] >> 4; cp[13] = cp[6] & 0xf;
+			cp[12] = cp[6] >> 4; cp[11] = cp[5] & 0xf;
+			cp[10] = cp[5] >> 4; cp[ 9] = cp[4] & 0xf;
+			cp[ 8] = cp[4] >> 4; cp[ 7] = cp[3] & 0xf;
+			cp[ 6] = cp[3] >> 4; cp[ 5] = cp[2] & 0xf;
+			cp[ 4] = cp[2] >> 4; cp[ 3] = cp[1] & 0xf;
+			cp[ 2] = cp[1] >> 4; cp[ 1] = cp[0] & 0xf;
+			cp[ 0] = cp[0] >> 4;
+#if DEBUG_ISRC
+	fprintf(stderr, "a->b: %15.15s\n", cp);
+#endif
+		}
+      
+		/* Check for format B:
+		 * If not yet in ASCII format, do the conversion
+		 */
+		if (cp[0] < '0' && cp[1] < '0') {
+			/* coding table for International Standard Recording Code */
+			static char bin2ISRC[] = {
+			 '0','1','2','3','4','5','6','7','8','9',      /* 10 */
+			 ':',';','<','=','>','?','@',		       /* 17 */
+			 'A','B','C','D','E','F','G','H','I','J','K',  /* 28 */
+			 'L','M','N','O','P','Q','R','S','T','U','V',  /* 39 */
+			 'W','X','Y','Z',			       /* 43 */
+#if 1
+			 '[','\\',']','^','_','`',		       /* 49 */
+			 'a','b','c','d','e','f','g','h','i','j','k',  /* 60 */
+			 'l','m','n','o'			       /* 64 */
+#endif
+			};
+	
+			/* build 6-bit vector of coded values */
+			unsigned ind;
+			int bits;
+	
+#if DEBUG_ISRC
+	fprintf(stderr, "b!\n");
+#endif
+			ind =   (cp[0] << 26) +
+				(cp[1] << 22) +
+				(cp[2] << 18) + 
+				(cp[3] << 14) +
+				(cp[4] << 10) +
+				(cp[5] << 6) +
+				(cp[6] << 2) +
+				(cp[7] >> 2);
+
+			if ((cp[7] & 3) == 3) {
+				if (global.verbose) {
+					fprintf(stderr,
+						"Recorder-ID encountered: ");
+					for (bits = 0; bits < 30; bits +=6) {
+						unsigned binval = (ind & (ULONG_C(0x3f) << (24-bits)))
+											>> (24-bits);
+						if ((binval < sizeof(bin2ISRC)) &&
+						    (binval <= 9 || binval >= 16)) {
+							fprintf(stderr, "%X", bin2ISRC[binval]);
+						}
+					}
+
+					fprintf(stderr, "%.1X%.1X%.1X%.1X%.1X%.1X%.1X",
+					    subq_tr->track_isrc [8] & 0x0f,
+					    subq_tr->track_isrc [9] & 0x0f,
+					    subq_tr->track_isrc [10] & 0x0f,
+					    subq_tr->track_isrc [11] & 0x0f,
+					    subq_tr->track_isrc [12] & 0x0f,
+					    subq_tr->track_isrc [13] & 0x0f,
+					    subq_tr->track_isrc [14] & 0x0f
+					    );
+					fprintf(stderr, "\n");
+				}
+				return;
+			}
+			if ((cp[7] & 3) != 0) {
+				fprintf(stderr, "unknown mode 3 entry C1=0x%02x, C2=0x%02x\n",
+					(cp[7] >> 1) & 1, cp[7] & 1);
+				return;
+			}
+	  
+			/* decode ISRC due to IEC 908 */
+			for (bits = 0; bits < 30; bits +=6) {
+				unsigned binval = (ind & ((unsigned long) 0x3fL << (24L-bits))) >> (24L-bits);
+				if ((binval >= sizeof(bin2ISRC)) ||
+				    (binval > 9 && binval < 16)) {
+					/* Illegal ISRC, dump and skip */
+					int y;
+						    
+					Get_ISRC(tr)[0] = '\0';
+					fprintf(stderr, "\nIllegal ISRC for track %d, skipped: ", tr);
+					for (y = 0; y < 15; y++) {
+						fprintf(stderr, "%02x ", cp[y]);
+					}
+					fputs("\n", stderr);
+					return;
+				}
+				*p++ = bin2ISRC[binval];
+				
+				/* insert a dash after two country characters for legibility */
+				if (bits == 6)
+					*p++ = '-';
+			}
+			
+			/* format year and serial number */
+			sprintf ((char *)p, "-%.1X%.1X-%.1X%.1X%.1X%.1X%.1X",
+				 subq_tr->track_isrc [8] & 0x0f,
+				 subq_tr->track_isrc [9] & 0x0f,
+				 subq_tr->track_isrc [10] & 0x0f,
+				 subq_tr->track_isrc [11] & 0x0f,
+				 subq_tr->track_isrc [12] & 0x0f,
+				 subq_tr->track_isrc [13] & 0x0f,
+				 subq_tr->track_isrc [14] & 0x0f
+				); 
+#if DEBUG_ISRC
+	fprintf(stderr, "b: %15.15s!\n", p_start);
+#endif
+		} else {
+			/* It might be in ASCII, surprise */
+			int ii;
+			for (ii = 0; ii < 12; ii++) {
+				if (cp[ii] < '0' || cp[ii] > 'Z') {
+					break;
+				}
+			}
+			if (ii != 12) {
+				int y;
+				
+				Get_ISRC(ii)[0] = '\0';
+				fprintf(stderr, "\nIllegal ISRC for track %d, skipped: ", ii+1);
+				for (y = 0; y < 15; y++) {
+					fprintf(stderr, "%02x ", cp[y]);
+				}
+				fputs("\n", stderr);
+				return;
+			}
+			
+#if DEBUG_ISRC
+	fprintf(stderr, "ascii: %15.15s!\n", cp);
+#endif
+			for (ii = 0; ii < 12; ii++) {
+#if 1
+				if ((ii == 2 || ii == 5 || ii == 7) && cp[ii] != ' ')
+					*p++ = '-';
+#endif
+				*p++ = cp[ii];
+			}
+			if (p - p_start >= 16)
+				*(p_start + 15) = '\0';
+			else
+				*p = '\0';
+		}
+
+		if (memcmp(p_start,"00-000-00-00000",15) != 0) {
+			Set_ISRC(tr, p_start);
+		}
+	}
+}
+
+/* get and display Media Catalog Number ( one per disc )
+ *  and Track International Standard Recording Codes (for each track)
+ */
+void Read_MCN_ISRC(void)
+{
+	if ((global.verbose & SHOW_MCN) != 0) {
+
+		if (Get_MCN()[0] == '\0') {
+			Get_Set_MCN();
+		}
+
+		if (Get_MCN()[0] != '\0')
+			fprintf(stderr, "\rMedia catalog number: %13.13s\n", Get_MCN());
+		else
+			fprintf(stderr, "\rNo media catalog number present.\n");
+	}
+
+
+
+	if ((global.verbose & SHOW_ISRC) != 0) {
+		static struct iterator i;
+
+		InitIterator(&i, 1);
+
+		while (i.hasNextTrack(&i)) {
+			struct TOC *p = i.getNextTrack(&i);
+			unsigned ii = GETTRACK(p);
+			
+			if (ii == CDROM_LEADOUT) break;
+			
+			if (!IS__AUDIO(p))
+				continue;
+
+			if (GETISRC(p)[0] == '\0') {
+				Get_Set_ISRC(ii);
+			}
+
+			if (GETISRC(p)[0] != '\0') {
+				fprintf (stderr, "\rT: %2d ISRC: %15.15s\n", ii, GETISRC(p));
+				fflush(stderr); 
+			}
+		} /* for all tracks */
+
+		fputs("\n", stderr);
+	} /* if SHOW_ISRC */
+}
+
+static int playing = 0;
+
+static subq_chnl *ReadSubChannel(unsigned sec);
+
+static subq_chnl *ReadSubChannel(unsigned sec)
+{
+	subq_chnl *sub_ch;
+
+	/*
+	 * For modern drives implement a direct method. If the drive supports
+	 * reading of subchannel data, do direct reads.
+	 */
+	if (ReadSubChannels != NULL) {
+		get_scsi_p()->silent++;
+		sub_ch = ReadSubChannels(get_scsi_p(), sec);
+		get_scsi_p()->silent--;
+		if (sub_ch == NULL /*&& (usal_sense_key(get_scsi_p()) == 5)*/) {
+			/* command is not implemented */
+			ReadSubChannels = NULL;
+#if	defined DEBUG_SUB
+fprintf(stderr, "\nCommand not implemented: switching ReadSubChannels off !\n");
+#endif
+			goto fallback;
+		}
+
+		/* check the adress mode field */
+		if ((sub_ch->control_adr & 0x0f) == 0) {
+			/* no Q mode information present at all, weird */
+			sub_ch->control_adr = 0xAA;
+		}
+
+		if ((int)(sub_ch->control_adr & 0x0f) > 0x01) {
+			/* this sector just has no position information.
+			 * we try the one before and then the one after.
+			 */
+			if (sec > 1) {
+				sec -= 1;
+				sub_ch = ReadSubChannels(get_scsi_p(), sec);
+				if (sub_ch == NULL) return NULL;
+				sec += 1;
+			}
+			if ((sub_ch->control_adr & 0x0f) != 0x01) {
+				sec += 2;
+				sub_ch = ReadSubChannels(get_scsi_p(), sec);
+				if (sub_ch == NULL) return NULL;
+				sec -= 2;
+			}
+		}
+
+		/* check adress mode field for position information */
+		if ((sub_ch->control_adr & 0x0f) == 0x01) {
+			return sub_ch;
+		}
+		ReadSubChannels = NULL;
+fprintf(stderr, "\nCould not get position information (%02x) for sectors %d, %d, %d: switching ReadSubChannels off !\n", sub_ch->control_adr &0x0f, sec-1, sec, sec+2);
+	}
+
+	/*
+	 * We rely on audio sectors here!!!
+	 * The only method that worked even with my antique Toshiba 3401,
+	 * is playing the sector and then request the subchannel afterwards.
+	 */
+fallback:
+	/* We need a conformed audio track here! */
+
+	/* Fallback to ancient method */
+	if (-1 == Play_at(get_scsi_p(), sec, 1)) {
+		return NULL;
+	}
+	playing = 1;
+	sub_ch = ReadSubQ(get_scsi_p(), GET_POSITIONDATA,0);
+	return sub_ch;
+}
+
+static int ReadSubControl(unsigned sec);
+static int ReadSubControl(unsigned sec)
+{
+	subq_chnl *sub_ch = ReadSubChannel(sec);
+	if (sub_ch == NULL) return -1;
+
+	return	sub_ch->control_adr & 0xf0;
+}
+
+static int HaveSCMS(unsigned StartSector);
+static int HaveSCMS(unsigned StartSector)
+{
+	int i;
+	int	cr;
+	int	copy_bits_set = 0;
+
+	for (i = 0; i < 8; i++) {
+		cr = ReadSubControl(StartSector + i);
+		if (cr == -1) continue;
+		(cr & 0x20) ? copy_bits_set++ : 0;
+	}
+	return (copy_bits_set >= 1 && copy_bits_set < 8);
+}
+
+void Check_Toc(void)
+{
+	/* detect layout */
+	
+	/* detect tracks */
+}
+
+static int GetIndexOfSector(unsigned sec, unsigned track)
+{
+	subq_chnl *sub_ch = ReadSubChannel(sec);
+	if (sub_ch == NULL) {
+		if ((long)sec == Get_EndSector(track)) {
+			fprintf(stderr, "Driver and/or firmware bug detected! Drive cannot play the very last sector (%u)!\n", sec);
+		}
+		return -1;
+	}
+
+	/* can we trust that these values are hex and NOT bcd? */
+	if ((sub_ch->track >= 0x10) && (sub_ch->track - track > 5)) {
+		/* change all values from bcd to hex */
+		sub_ch->track = (sub_ch->track >> 4)*10 + (sub_ch->track & 0x0f);
+		sub_ch->index = (sub_ch->index >> 4)*10 + (sub_ch->index & 0x0f);
+	}
+
+#if 1
+    /* compare tracks */
+    if (sub_ch->index != 0 && track != sub_ch->track) {
+	if (global.verbose) fprintf(stderr, "\ntrack mismatch: %1d, in-track subchannel: %1d (index %1d, sector %1d)\n",
+		track, sub_ch->track, sub_ch->index, sec);
+    }
+#endif
+
+    /* compare control field with the one from the TOC */
+    if ((Get_Flags(track) & 0xf0) != (sub_ch->control_adr & 0xf0)) {
+	int	diffbits = (Get_Flags(track) & 0xf0) ^ (sub_ch->control_adr & 0xf0);
+	if ((diffbits & 0x80) == 0x80) {
+		/* broadcast difference */
+		if (global.verbose) fprintf(stderr, "broadcast type conflict detected -> TOC:%s, subchannel:%s\n",
+		(sub_ch->control_adr & 0x80) == 0 ? "broadcast" : "nonbroadcast"
+		,(sub_ch->control_adr & 0x80) != 0 ? "broadcast" : "nonbroadcast"
+		);
+	}
+	if ((diffbits & 0x40) == 0x40) {
+		/* track type difference */
+		if (global.verbose) fprintf(stderr, "track type conflict detected -> TOC:%s, subchannel:%s\n",
+		(sub_ch->control_adr & 0x40) == 0 ? "data" : "audio"
+		,(sub_ch->control_adr & 0x40) != 0 ? "data" : "audio"
+		);
+	}
+	if ((diffbits & 0x20) == 0x20 && !Get_SCMS(track)) {
+		/* copy permission difference is a sign for SCMS
+		 * and is treated elsewhere. */
+		if (global.verbose) fprintf(stderr, "difference: TOC:%s, subchannel:%s\ncorrecting TOC...\n",
+		(sub_ch->control_adr & 0x20) == 0 ? "unprotected" : "copyright protected",
+		(sub_ch->control_adr & 0x20) != 0 ? "unprotected" : "copyright protected"
+		);
+		toc_entry(track, 
+		  (Get_Flags(track) & 0xDF) | (sub_ch->control_adr & 0x20),
+		  Get_Tracknumber(track),
+		  Get_ISRC(track),
+		  Get_AudioStartSector(track),
+		  Get_Mins(track),
+		  Get_Secs(track),
+		  Get_Frames(track)
+		  );
+	}
+	if ((diffbits & 0x10) == 0x10) {
+		/* preemphasis difference */
+		if (global.verbose) fprintf(stderr, "difference: TOC:%s, subchannel:%s preemphasis\ncorrecting TOC...\n",
+		(sub_ch->control_adr & 0x10) == 0 ? "with" : "without",
+		(sub_ch->control_adr & 0x10) != 0 ? "with" : "without"
+		);
+		toc_entry(track, 
+		  (Get_Flags(track) & 0xEF) | (sub_ch->control_adr & 0x10),
+		  Get_Tracknumber(track),
+		  Get_ISRC(track),
+		  Get_AudioStartSector(track),
+		  Get_Mins(track),
+		  Get_Secs(track),
+		  Get_Frames(track)
+		  );
+	}
+
+    }
+
+    return sub_ch ? sub_ch->index == 244 ? 1 : sub_ch->index : -1;
+}
+
+static int ScanBackwardFrom(unsigned sec, unsigned limit, int *where, 
+									 unsigned track);
+
+static int ScanBackwardFrom(unsigned sec, unsigned limit, int *where, 
+									 unsigned track)
+{
+	unsigned lastindex = 0;
+	unsigned mysec = sec;
+
+	/* try to find the transition of index n to index 0,
+	 * if the track ends with an index 0.
+	 */
+	while ((lastindex = GetIndexOfSector(mysec, track)) == 0) {
+		if (mysec < limit+75) {
+			break;
+		}
+		mysec -= 75;
+	}
+	if (mysec == sec) {
+		/* there is no pre-gap in this track */
+		if (where != NULL) *where = -1;
+	} else {
+		/* we have a pre-gap in this track */
+
+		if (lastindex == 0) {
+			/* we did not cross the transition yet -> search backward */
+			do {
+				if (mysec < limit+1) {
+					break;
+				}
+				mysec --;
+			} while ((lastindex = GetIndexOfSector(mysec,track)) == 0);
+			if (lastindex != 0) {
+				/* successful */
+				mysec ++;
+				/* register mysec as transition */
+				if (where != NULL) *where = (int) mysec;
+			} else {
+				/* could not find transition */
+				if (!global.quiet)
+					fprintf(stderr,
+					 "Could not find index transition for pre-gap.\n");
+				if (where != NULL) *where = -1;
+			}
+		} else {
+			int myindex = -1;
+			/* we have crossed the transition -> search forward */
+			do {
+				if (mysec >= sec) {
+					break;
+				}
+				mysec ++;
+			} while ((myindex = GetIndexOfSector(mysec,track)) != 0);
+			if (myindex == 0) {
+				/* successful */
+				/* register mysec as transition */
+				if (where != NULL) *where = (int) mysec;
+			} else {
+				/* could not find transition */
+				if (!global.quiet)
+					fprintf(stderr,
+					 "Could not find index transition for pre-gap.\n");
+				if (where != NULL) *where = -1;
+			}
+		}
+	}
+	return lastindex;
+}
+
+#ifdef	USE_LINEAR_SEARCH
+static int linear_search(int searchInd, unsigned int Start, unsigned int End, 
+								 unsigned track);
+
+static int linear_search(int searchInd, unsigned int Start, unsigned int End, 
+								 unsigned track)
+{
+      int l = Start;
+      int r = End;
+
+      for (; l <= r; l++ ) {
+          int ind;
+
+	  ind = GetIndexOfSector(l, track);
+	  if ( searchInd == ind ) {
+	      break;
+	  }
+      }
+      if ( l <= r ) {
+        /* Index found. */
+	return l;
+      }
+
+      return -1;
+}
+#endif
+
+#ifndef	USE_LINEAR_SEARCH
+#undef DEBUG_BINSEARCH
+static int binary_search(int searchInd, unsigned int Start, unsigned int End, 
+								 unsigned track);
+
+static int binary_search(int searchInd, unsigned Start, unsigned End, 
+								 unsigned track)
+{
+      int l = Start;
+      int r = End;
+      int x = 0;
+      int ind;
+
+      while ( l <= r ) {
+	  x = ( l + r ) / 2;
+	  /* try to avoid seeking */
+	  ind = GetIndexOfSector(x, track);
+	  if ( searchInd == ind ) {
+	      break;
+	  } else {
+	      if ( searchInd < ind ) r = x - 1;
+	      else	     	     l = x + 1;
+	  }
+      }
+#ifdef DEBUG_BINSEARCH
+fprintf(stderr, "(%d,%d,%d > ",l,x,r);
+#endif
+      if ( l <= r ) {
+        /* Index found. Now find the first position of this index */
+	/* l=LastPos	x=found		r=NextPos */
+        r = x;
+	while ( l < r-1 ) {
+	  x = ( l + r ) / 2;
+	  /* try to avoid seeking */
+	  ind = GetIndexOfSector(x, track);
+	  if ( searchInd == ind ) {
+	      r = x;
+	  } else {
+	      l = x;
+	  }
+#ifdef DEBUG_BINSEARCH
+fprintf(stderr, "%d -> ",x);
+#endif
+        }
+#ifdef DEBUG_BINSEARCH
+fprintf(stderr, "%d,%d)\n",l,r);
+#endif
+	if (searchInd == GetIndexOfSector(l, track))
+	  return l;
+	else
+	  return r;
+      }
+
+      return -1;
+}
+#endif
+
+
+static void register_index_position(int IndexOffset, 
+												index_list **last_index_entry);
+
+static void register_index_position(int IndexOffset, 
+												index_list **last_index_entry)
+{
+      index_list *indexentry;
+
+      /* register higher index entries */
+      if (*last_index_entry != NULL) {
+        indexentry = (index_list *) malloc( sizeof(index_list) );
+      } else {
+        indexentry = NULL;
+      }
+      if (indexentry != NULL) {
+        indexentry->next = NULL;
+        (*last_index_entry)->next = indexentry;
+        *last_index_entry = indexentry;
+        indexentry->frameoffset = IndexOffset;
+#if defined INFOFILES
+      } else {
+        fprintf( stderr, "No memory for index lists. Index positions\nwill not be written in info file!\n");
+#endif
+      }
+}
+
+static void Set_SCMS(unsigned long p_track);
+
+#undef DEBUG_INDLIST
+/* experimental code */
+/* search for indices (audio mode required) */
+unsigned ScanIndices(unsigned track, unsigned cd_index, int bulk)
+{
+  /* scan for indices. */
+  /* look at last sector of track. */
+  /* when the index is not equal 1 scan by bipartition 
+   * for offsets of all indices */
+
+  unsigned starttrack, endtrack;
+  unsigned startindex, endindex;
+
+  unsigned j;
+  int LastIndex=0;
+  int n_0_transition;
+  unsigned StartSector;
+  unsigned retval = 0;
+
+  index_list *baseindex_pool;
+  index_list *last_index_entry;
+
+  SCSI *usalp = get_scsi_p();
+
+  static struct iterator i;
+  InitIterator(&i, 1);
+  
+  EnableCdda(usalp, 0, 0);
+  EnableCdda(usalp, 1, CD_FRAMESIZE_RAW + 16);
+
+  if (!global.quiet && !(global.verbose & SHOW_INDICES))
+    fprintf(stderr, "seeking index start ...");
+
+  if (bulk != 1) {
+    starttrack = track; endtrack = track;
+  } else {
+    starttrack = 1; endtrack = cdtracks;
+  }
+  baseindex_pool = (index_list *) malloc( sizeof(index_list) * (endtrack - starttrack + 1));
+#ifdef DEBUG_INDLIST
+  fprintf(stderr, "index0-mem-pool %p\n", baseindex_pool);
+#endif
+
+
+  while (i.hasNextTrack(&i)) {
+	  struct TOC *p = i.getNextTrack(&i);
+	  unsigned ii = GETTRACK(p);
+
+	  if ( ii < starttrack || IS__DATA(p) )
+		  continue;	/* skip nonaudio tracks */
+
+	  if ( ii > endtrack )
+		  break;
+
+	  if ( global.verbose & SHOW_INDICES ) { 
+		  if (global.illleadout_cd && global.reads_illleadout && ii == endtrack) {
+			  fprintf(stderr, "Analysis of track %d skipped due to unknown length\n", ii);
+		  }
+	  }
+	  if (global.illleadout_cd && global.reads_illleadout 
+	      && ii == endtrack) continue;
+
+	  StartSector = Get_AudioStartSector(ii);
+	  if (HaveSCMS(StartSector)) {
+		Set_SCMS(ii);
+	  }
+	  if ( global.verbose & SHOW_INDICES ) { 
+		  fprintf( stderr, "\rindex scan: %d...", ii ); 
+		  fflush (stderr);
+	  }
+	  LastIndex = ScanBackwardFrom(Get_EndSector(ii), StartSector, &n_0_transition, ii);
+	  if (LastIndex > 99) continue;
+
+	  if (baseindex_pool != NULL) {
+#ifdef DEBUG_INDLIST
+#endif
+		  /* register first index entry for this track */
+		  baseindex_pool[ii - starttrack].next = NULL;
+		  baseindex_pool[ii - starttrack].frameoffset = StartSector;
+		  global.trackindexlist[ii] = &baseindex_pool[ii - starttrack];
+#ifdef DEBUG_INDLIST
+#endif
+	  } else {
+		  global.trackindexlist[ii] = NULL;
+	  }
+	  last_index_entry = global.trackindexlist[ii];
+
+	  if (LastIndex < 2) {
+		  register_index_position(n_0_transition, &last_index_entry);
+		  continue;
+	  }
+
+	  if ((global.verbose & SHOW_INDICES) && LastIndex > 1)
+		  fprintf(stderr, "\rtrack %2d has %d indices, index table (pairs of 'index: frame offset')\n", ii, LastIndex);
+	  
+	  startindex = 0;
+	  endindex = LastIndex;
+
+	  for (j = startindex; j <= endindex; j++) {
+		  int IndexOffset;
+		  
+		  /* this track has indices */
+
+#ifdef	USE_LINEAR_SEARCH
+		  /* do a linear search */
+		  IndexOffset = linear_search(j, StartSector, Get_EndSector(ii), ii);
+#else
+		  /* do a binary search */
+		  IndexOffset = binary_search(j, StartSector, Get_EndSector(ii), ii);
+#endif
+
+		  if (IndexOffset != -1) {
+			  StartSector = IndexOffset;
+		  }
+
+		  if (j == 1)
+			  last_index_entry->frameoffset = IndexOffset;
+		  else if (j > 1)
+			  register_index_position(IndexOffset, &last_index_entry);
+
+		  if ( IndexOffset == -1 ) {
+			  if (global.verbose & SHOW_INDICES) {
+				  if (global.gui == 0) {
+					  fprintf(stderr, "%2u: N/A   ",j);
+					  if (((j + 1) % 8) == 0) fputs("\n", stderr);
+				  } else {
+					  fprintf(stderr, "\rT%02d I%02u N/A\n",ii,j);
+				  }
+			  }
+		  } else {
+			  if (global.verbose & SHOW_INDICES) {
+				  if (global.gui == 0) {
+					  fprintf(stderr, 
+						"%2u:%6lu ",
+						j,
+						IndexOffset-Get_AudioStartSector(ii)
+						 );
+					  if (((j + 1) % 8) == 0) fputs("\n", stderr);
+				  } else {
+					  fprintf(stderr,
+						"\rT%02d I%02u %06lu\n",
+						ii,
+						j,
+						IndexOffset-Get_AudioStartSector(ii)
+						 );
+				  }
+			  }
+
+			  if (track == ii && cd_index == j) {
+				  retval = IndexOffset-Get_AudioStartSector(ii);
+			  }
+		  } /* if IndexOffset */
+	  } /* for index */
+	  register_index_position(n_0_transition, &last_index_entry);
+
+	  /* sanity check. clear all consecutive nonindex entries (frameoffset -1) from the end. */
+	  {
+	  	index_list *ip = global.trackindexlist[ii];
+		index_list *iq = NULL;
+		index_list *lastgood = iq;
+
+		while (ip != NULL)
+		{
+			if (ip->frameoffset == -1)
+			{
+				/* no index available */
+				if (lastgood == NULL)
+				{
+					/* if this is the first one in a sequence, store predecessor */
+					lastgood = iq;
+				}
+			} else {
+				/* this is a valid index, reset marker */
+				lastgood = NULL;
+			}
+
+			iq = ip;
+			ip = ip->next;
+		}
+		/* terminate chain at the last well defined entry. */
+		if (lastgood != NULL)
+			lastgood->next = NULL;
+	  }
+
+	  if (global.gui == 0 && (global.verbose & SHOW_INDICES)
+	      && ii != endtrack)
+		  fputs("\n", stderr);
+  } /* for tracks */
+  if (global.gui == 0 && (global.verbose & SHOW_INDICES))
+	  fputs("\n", stderr);
+  if (playing != 0) StopPlay(get_scsi_p());
+
+  EnableCdda(usalp, 0, 0);
+  EnableCdda(usalp, 1, CD_FRAMESIZE_RAW);
+
+  return retval;
+}
+
+static unsigned char MCN[14];
+
+static void Set_MCN(unsigned char *MCN_arg)
+{
+	memcpy(MCN, MCN_arg, 14);
+	MCN[13] = '\0';
+}
+
+unsigned char *Get_MCN(void)
+{
+	return MCN;
+}
+
+
+static TOC g_toc [MAXTRK+1]; /* hidden track + 100 regular tracks */
+
+/*#define IS_AUDIO(i) (!(g_toc[i].bFlags & 0x40))*/
+
+int 
+TOC_entries(unsigned tracks, unsigned char *a, unsigned char *b, int binvalid)
+{
+	int i;
+	for (i = 1; i <= (int)tracks; i++) {
+		unsigned char *p;
+		unsigned long dwStartSector;
+
+		if (binvalid) {
+			p = a + 8*(i-1);
+
+			g_toc[i].bFlags = p[1];
+			g_toc[i].bTrack = p[2];
+			g_toc[i].ISRC[0] = 0;
+			dwStartSector = a_to_u_4_byte(p+4);
+			g_toc[i].dwStartSector = dwStartSector;
+			lba_2_msf((long)dwStartSector,
+				  &g_toc[i].mins,
+				  &g_toc[i].secs,
+				  &g_toc[i].frms);
+		} else {
+			p = b + 8*(i-1);
+			g_toc[i].bFlags = p[1];
+			g_toc[i].bTrack = p[2];
+			g_toc[i].ISRC[0] = 0;
+			if ((int)((p[5]*60 + p[6])*75 + p[7]) >= 150) {
+				g_toc[i].dwStartSector = (p[5]*60 + p[6])*75 + p[7] -150;
+			} else {
+				g_toc[i].dwStartSector = 0;
+			}
+			g_toc[i].mins = p[5];
+			g_toc[i].secs = p[6];
+			g_toc[i].frms = p[7];
+		}
+	}
+	return 0;
+}
+
+void toc_entry(unsigned nr, unsigned flag, unsigned tr, unsigned char *ISRC, 
+               unsigned long lba, int m, int s, int f)
+{
+	if (nr > MAXTRK) return;
+
+	g_toc[nr].bFlags = flag;
+	g_toc[nr].bTrack = tr;
+	if (ISRC) {
+		strncpy((char *)g_toc[nr].ISRC, (char *)ISRC,
+			sizeof(g_toc[nr].ISRC) -1);
+		g_toc[nr].ISRC[sizeof(g_toc[nr].ISRC) -1] = '\0';
+	}
+	g_toc[nr].dwStartSector = lba;
+	g_toc[nr].mins = m;
+	g_toc[nr].secs = s;
+	g_toc[nr].frms = f;
+}
+
+int patch_real_end(unsigned long sector)
+{
+	g_toc[cdtracks+1].dwStartSector = sector;
+	return 0;
+}
+
+static int patch_cd_extra(unsigned track, unsigned long sector)
+{
+	if (track <= cdtracks)
+		g_toc[track].dwStartSector = sector;
+	return 0;
+}
+
+static int restrict_tracks_illleadout(void)
+{
+	struct TOC *o = &g_toc[cdtracks+1];
+	int i;
+	for (i = cdtracks; i >= 0; i--) {
+		struct TOC *p = &g_toc[i];
+		if (GETSTART(o) > GETSTART(p)) break;
+	}
+	patch_cd_extra(i+1, GETSTART(o));
+	cdtracks = i;
+
+	return 0;
+}
+
+static void Set_ISRC(int track, const unsigned char *ISRC_arg)
+{
+	if (track <= (int)cdtracks) {
+		memcpy(Get_ISRC(track), ISRC_arg, 16);
+	}
+}
+
+
+unsigned char *Get_ISRC(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].ISRC;
+	return NULL;
+}
+
+static void patch_to_audio(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		g_toc[p_track].bFlags &= ~0x40;
+}
+
+int Get_Flags(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].bFlags;
+	return -1;
+}
+
+int Get_Mins(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].mins;
+	return -1;
+}
+
+int Get_Secs(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].secs;
+	return -1;
+}
+
+int Get_Frames(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].frms;
+	return -1;
+}
+
+int Get_Preemphasis(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].bFlags & 0x10;
+	return -1;
+}
+
+static void Set_SCMS(unsigned long p_track)
+{
+	g_toc[p_track].SCMS = 1;
+}
+
+int Get_SCMS(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].SCMS;
+	return -1;
+}
+
+int Get_Copyright(unsigned long p_track)
+{
+	if (p_track <= cdtracks) {
+		if (g_toc[p_track].SCMS) return 1;
+		return ((int)g_toc[p_track].bFlags & 0x20) >> 4;
+	}
+	return -1;
+}
+
+int Get_Datatrack(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].bFlags & 0x40;
+	return -1;
+}
+
+int Get_Channels(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].bFlags & 0x80;
+	return -1;
+}
+
+int Get_Tracknumber(unsigned long p_track)
+{
+	if (p_track <= cdtracks)
+		return g_toc[p_track].bTrack;
+	return -1;
+}
+
+static int useHiddenTrack(void)
+{
+	return 0;
+}
+
+
+
+static void it_reset(struct iterator *this);
+
+static void it_reset(struct iterator *this)
+{
+	this->index = this->startindex;
+}
+
+
+static int it_hasNextTrack(struct iterator *this);
+static struct TOC *it_getNextTrack(struct iterator *this);
+
+static int it_hasNextTrack(struct iterator *this)
+{
+	return this->index <= (int)cdtracks+1;
+}
+
+
+
+static struct TOC *it_getNextTrack(struct iterator *this)
+{
+	/* if ( (*this->hasNextTrack)(this) == 0 ) return NULL; */
+	if ( this->index > (int)cdtracks+1 ) return NULL;
+
+	return &g_toc[ this->index++ ];
+}
+
+
+static void InitIterator(struct iterator *iter, unsigned long p_track)
+{
+	if (iter == NULL) return;
+
+	iter->index = iter->startindex = useHiddenTrack() ? 0 : p_track;
+	iter->reset = it_reset;
+	iter->getNextTrack = it_getNextTrack;
+	iter->hasNextTrack = it_hasNextTrack;
+}
+
+#if	0
+static struct iterator *NewIterator(void);
+
+static struct iterator *NewIterator ()
+{
+	struct iterator *retval;
+
+	retval = malloc (sizeof(struct iterator));
+	if (retval != NULL) {
+		InitIterator(retval, 1);
+	}
+	return retval;
+}
+#endif
+
+long Get_AudioStartSector(unsigned long p_track)
+{
+#if	1
+	if (p_track == CDROM_LEADOUT)
+		p_track = cdtracks + 1;
+
+	if (p_track <= cdtracks +1
+		&& IS__AUDIO(&g_toc[p_track]))
+		return GETSTART(&g_toc[p_track]);
+#else
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, p_track);
+	else i.reset(&i);
+
+	if (p_track == cdtracks + 1) p_track = CDROM_LEADOUT;
+
+	while (i.hasNextTrack(&i)) {
+		TOC *p = i.getNextTrack(&i);
+
+		if (GETTRACK(p) == p_track) {
+			if (IS__DATA(p)) {
+				return -1;
+			}
+			return GETSTART(p);
+		}
+	}
+#endif
+	return -1;
+}
+
+
+long Get_StartSector(unsigned long p_track)
+{
+#if	1
+	if (p_track == CDROM_LEADOUT)
+		p_track = cdtracks + 1;
+
+	if (p_track <= cdtracks +1)
+		return GETSTART(&g_toc[p_track]);
+#else
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, p_track);
+	else i.reset(&i);
+
+	if (p_track == cdtracks + 1) p_track = CDROM_LEADOUT;
+
+	while (i.hasNextTrack(&i)) {
+		TOC *p = i.getNextTrack(&i);
+
+		if (GETTRACK(p) == p_track) {
+			return GETSTART(p);
+		}
+	}
+#endif
+	return -1;
+}
+
+
+long Get_EndSector(unsigned long p_track)
+{
+#if	1
+	if (p_track <= cdtracks)
+		return GETSTART(&g_toc[p_track+1])-1;
+#else
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, p_track);
+	else i.reset(&i);
+
+	if (p_track == cdtracks + 1) p_track = CDROM_LEADOUT;
+
+	while (i.hasNextTrack(&i)) {
+		TOC *p = i.getNextTrack(&i);
+		if (GETTRACK(p) == p_track) {
+			p = i.getNextTrack(&i);
+			if (p == NULL) {
+				return -1;
+			}
+			return GETSTART(p)-1;
+		}
+	}
+#endif
+	return -1;
+}
+
+long FirstTrack(void)
+{
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, 1);
+	else i.reset(&i);
+
+	if (i.hasNextTrack(&i)) {
+		return GETTRACK(i.getNextTrack(&i));
+	}
+	return -1;
+}
+
+long FirstAudioTrack(void)
+{
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, 1);
+	else i.reset(&i);
+
+	while (i.hasNextTrack(&i)) {
+		TOC *p = i.getNextTrack(&i);
+		unsigned ii = GETTRACK(p);
+
+		if (ii == CDROM_LEADOUT) break;
+		if (IS__AUDIO(p)) {
+			return ii;
+		}
+	}
+	return -1;
+}
+
+long FirstDataTrack(void)
+{
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, 1);
+	else i.reset(&i);
+
+	while (i.hasNextTrack(&i)) {
+		TOC *p = i.getNextTrack(&i);
+		if (IS__DATA(p)) {
+			return GETTRACK(p);
+		}
+	}
+	return -1;
+}
+
+long LastTrack(void)
+{
+	return g_toc[cdtracks].bTrack;
+}
+
+long LastAudioTrack(void)
+{
+	long j = -1;
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, 1);
+	else i.reset(&i);
+
+	while (i.hasNextTrack(&i)) {
+		TOC *p = i.getNextTrack(&i);
+		if (IS__AUDIO(p) && (GETTRACK(p) != CDROM_LEADOUT)) {
+			j = GETTRACK(p);
+		}
+	}
+	return j;
+}
+
+long Get_LastSectorOnCd(unsigned long p_track)
+{
+	long LastSec = 0;
+	static struct iterator i;
+
+	if (global.illleadout_cd && global.reads_illleadout)
+		return 150+(99*60+59)*75+74;
+
+	if (i.reset == NULL) InitIterator(&i, p_track);
+	else i.reset(&i);
+
+	if (p_track == cdtracks + 1) p_track = CDROM_LEADOUT;
+
+	while (i.hasNextTrack(&i)) {
+		TOC *p = i.getNextTrack(&i);
+
+		if (GETTRACK(p) < p_track)
+			continue;
+
+		LastSec = GETSTART(p);
+
+		if (IS__DATA(p)) break;
+	}
+	return LastSec;
+}
+
+int Get_Track(unsigned long sector)
+{
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, 1);
+	else i.reset(&i);
+
+	if (i.hasNextTrack(&i)) {
+		TOC *o = i.getNextTrack(&i);
+		while (i.hasNextTrack(&i)) {
+			TOC *p = i.getNextTrack(&i);
+			if ((GETSTART(o) <= sector) && (GETSTART(p) > sector)) {
+				if (IS__DATA(o)) {
+					return -1;
+				} else {
+					return GETTRACK(o);
+				}
+			}
+			o = p;
+		}
+	}
+	return -1;
+}
+
+int CheckTrackrange(unsigned long from, unsigned long upto)
+{
+	static struct iterator i;
+	if (i.reset == NULL) InitIterator(&i, from);
+	else i.reset(&i);
+
+	while (i.hasNextTrack(&i)) {
+		TOC *p = i.getNextTrack(&i);
+
+		if (GETTRACK(p) < from)
+			continue;
+
+		if (GETTRACK(p) == upto)
+			return 1;
+
+		/* data tracks terminate the search */
+		if (IS__DATA(p))
+			return 0;
+	}
+	/* track not found */
+	return 0;
+}
+
+#ifdef	USE_PARANOIA
+long cdda_disc_firstsector(void *d);
+
+long cdda_disc_firstsector(void *d)
+{
+	return Get_StartSector(FirstAudioTrack());
+}
+
+int cdda_tracks(void *d);
+
+int cdda_tracks(void *d)
+{
+	return LastAudioTrack() - FirstAudioTrack() +1;
+}
+
+int cdda_track_audiop(void *d, int track);
+
+int cdda_track_audiop(void *d, int track)
+{
+	return Get_Datatrack(track) == 0;
+}
+
+long cdda_track_firstsector(void *d, int track);
+
+long cdda_track_firstsector(void *d, int track)
+{
+	return Get_AudioStartSector(track);
+}
+
+long cdda_track_lastsector(void *d, int track);
+
+long cdda_track_lastsector(void *d, int track)
+{
+	return Get_EndSector(track);
+}
+
+long cdda_disc_lastsector(void *d);
+
+long cdda_disc_lastsector(void *d)
+{
+	return Get_LastSectorOnCd(cdtracks) - 1;
+}
+
+int cdda_sector_gettrack(void *d,long sector);
+
+int cdda_sector_gettrack(void *d, long sector)
+{
+	return Get_Track(sector);
+}
+
+#endif