Imported Upstream version 1.1.11upstream/1.1.11upstream

1 files changed, 3059 insertions, 0 deletions

diff --git a/icedax/icedax.c b/icedax/icedax.c
new file mode 100644
index 0000000..9ac5ee0
--- /dev/null
+++ b/icedax/icedax.c
@@ -0,0 +1,3059 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)cdda2wav.c	1.64 06/02/19 Copyright 1998-2004 Heiko Eissfeldt, Copyright 2004-2006 J. Schilling */
+#undef DEBUG_BUFFER_ADDRESSES
+#undef GPROF
+#undef DEBUG_FORKED
+#undef DEBUG_CLEANUP
+#undef DEBUG_DYN_OVERLAP
+#undef DEBUG_READS
+#define DEBUG_ILLLEADOUT	0	/* 0 disables, 1 enables */
+/*
+ * 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.
+ *
+ */
+/*
+ * parts    (C) Peter Widow
+ * parts    (C) Thomas Niederreiter
+ * parts    (C) RSA Data Security, Inc.
+ *
+ * last changes:
+ *   18.12.93 - first version,	OK
+ *   01.01.94 - generalized & clean up HE
+ *   10.06.94 - first linux version HE
+ *   12.06.94 - wav header alignment problem fixed HE
+ *   12.08.94 - open the cdrom device O_RDONLY makes more sense :-)
+ *		no more floating point math
+ *		change to sector size 2352 which is more common
+ *		sub-q-channel information per kernel ioctl requested
+ *		doesn't work as well as before
+ *		some new options (-max -i)
+ *   01.02.95 - async i/o via semaphores and shared memory
+ *   03.02.95 - overlapped reading on sectors
+ *   03.02.95 - generalized sample rates. all integral divisors are legal
+ *   04.02.95 - sun format added
+ *              more divisors: all integral halves >= 1 allowed
+ *		floating point math needed again
+ *   06.02.95 - bugfix for last track and not d0
+ *              tested with photo-cd with audio tracks
+ *		tested with xa disk 
+ *   29.01.96 - new options for bulk transfer
+ *   01.06.96 - tested with enhanced cd
+ *   01.06.96 - tested with cd-plus
+ *   02.06.96 - support pipes
+ *   02.06.96 - support raw format
+ *   04.02.96 - security hole fixed
+ *   22.04.97 - large parts rewritten
+ *   28.04.97 - make file names DOS compatible
+ *   01.09.97 - add speed control
+ *   20.10.97 - add find mono option
+ *   Jan/Feb 98 - conversion to use Joerg Schillings SCSI library
+ *   see ChangeLog
+ */
+
+#include "config.h"
+
+#include <unixstd.h>
+#include <stdio.h>
+#include <standard.h>
+#include <stdxlib.h>
+#include <strdefs.h>
+#include <schily.h>
+#include <signal.h>
+#include <math.h>
+#include <fctldefs.h>
+#include <timedefs.h>
+#if defined (HAVE_LIMITS_H)
+#include <limits.h>
+#endif
+#if defined (HAVE_SYS_IOCTL_H)
+#include <sys/ioctl.h>
+#endif
+#include <errno.h>
+#include <statdefs.h>
+#include <waitdefs.h>
+#if defined (HAVE_SETPRIORITY)
+#include <sys/resource.h>
+#endif
+#include <vadefs.h>
+
+#include <usal/scsitransp.h>
+
+#ifdef	HAVE_AREAS
+#include <be/kernel/OS.h>
+#endif
+
+#include "mytype.h"
+#include "sndconfig.h"
+
+#include "semshm.h"	/* semaphore functions */
+#include "sndfile.h"
+#include "wav.h"	/* wav file header structures */
+#include "sun.h"	/* sun audio file header structures */
+#include "raw.h"	/* raw file handling */
+#include "aiff.h"	/* aiff file handling */
+#include "aifc.h"	/* aifc file handling */
+#ifdef	USE_LAME
+#include "mp3.h"	/* mp3 file handling */
+#endif
+#include "interface.h"  /* low level cdrom interfacing */
+#include "icedax.h"
+#include "resample.h"
+#include "toc.h"
+#include "setuid.h"
+#include "ringbuff.h"
+#include "global.h"
+#include "exitcodes.h"
+#ifdef	USE_PARANOIA
+#include "cdda_paranoia.h"
+#endif
+#include "defaults.h"
+
+static void RestrictPlaybackRate(long newrate);
+static void output_indices(FILE *fp, index_list *p, unsigned trackstart);
+static int 	write_info_file(char *fname_baseval, unsigned int track, 
+									 unsigned long SamplesDone, int numbered);
+static void CloseAudio(int channels_val, unsigned long nSamples, 
+							  struct soundfile *audio_out);
+static void CloseAll(void);
+static void OpenAudio(char *fname, double rate, long nBitsPerSample, 
+							 long channels_val, unsigned long expected_bytes, 
+							 struct soundfile*audio_out);
+static void set_offset(myringbuff *p, int offset);
+static int 	get_offset(myringbuff *p);
+static void usage(void);
+static void init_globals(void);
+static int	is_fifo(char *filename);
+
+
+/* Rules:
+ * unique parameterless options first,
+ * unique parametrized option names next,
+ * ambigious parameterless option names next,
+ * ambigious string parametrized option names last
+ */
+static const char *opts = "paranoia,paraopts&,version,help,h,\
+no-write,N,dump-rates,R,bulk,B,alltracks,verbose-scsi+,V+,\
+find-extremes,F,find-mono,G,no-infofile,H,\
+deemphasize,T,info-only,J,silent-scsi,Q,\
+cddbp-server*,cddbp-port*,\
+scanbus,devices,device*,dev*,D*,auxdevice*,A*,interface*,I*,output-format*,O*,\
+output-endianess*,E*,cdrom-endianess*,C*,speed#,S#,\
+playback-realtime#L,p#L,md5#,M#,set-overlap#,P#,sound-device*,K*,\
+cddb#,L#,channels*,c*,bits-per-sample#,b#,rate#,r#,gui,g,\
+divider*,a*,track*,t*,index#,i#,duration*,d*,offset#,o#,\
+sectors-per-request#,n#,verbose-level&,v&,buffers-in-ring#,l#,\
+stereo,s,mono,m,wait,w,echo,e,quiet,q,max,x\
+";
+
+
+#ifdef	NEED_O_BINARY
+#include <io.h>		/* for setmode() prototype */
+#endif
+
+/* global variables */
+global_t global;
+
+/* static variables */
+static unsigned long nSamplesDone = 0;
+
+static	int child_pid = -2;
+
+static unsigned long *nSamplesToDo;
+static unsigned int current_track;
+static int bulk = 0;
+
+unsigned int get_current_track(void);
+
+unsigned int get_current_track()
+{
+	return current_track;
+}
+
+static void RestrictPlaybackRate(long  newrate)
+{
+       global.playback_rate = newrate;
+
+       if ( global.playback_rate < 25 ) global.playback_rate = 25;   /* filter out insane values */
+       if ( global.playback_rate > 250 ) global.playback_rate = 250;
+
+       if ( global.playback_rate < 100 )
+               global.nsectors = (global.nsectors*global.playback_rate)/100;
+}
+
+
+long SamplesNeeded(long amount, long undersampling_val)
+{
+  long retval = ((undersampling_val * 2 + Halved)*amount)/2;
+  if (Halved && (*nSamplesToDo & 1))
+    retval += 2;
+  return retval;
+}
+
+static int argc2;
+static int argc3;
+static char **argv2;
+
+static void reset_name_iterator(void);
+static void reset_name_iterator()
+{
+	argv2 -= argc3 - argc2;
+	argc2 = argc3;
+}
+
+static char *get_next_name(void);
+static char *get_next_name()
+{
+	if (argc2 > 0) {
+		argc2--;
+		return (*argv2++);
+	} else {
+		return NULL;
+	}
+}
+
+static char *cut_extension(char *fname);
+
+static char *cut_extension(char *fname)
+{
+	char *pp;
+
+	pp = strrchr(fname, '.');
+
+	if (pp == NULL) {
+		pp = fname + strlen(fname);
+	}
+	*pp = '\0';
+
+	return pp;
+}
+
+#ifdef INFOFILES
+static void output_indices(FILE *fp, index_list *p, unsigned trackstart)
+{
+  int ci;
+
+  fprintf(fp, "Index=\t\t");
+
+  if (p == NULL) {
+    fprintf(fp, "0\n");
+    return;
+  }
+
+  for (ci = 1; p != NULL; ci++, p = p->next) {
+    int frameoff = p->frameoffset;
+
+    if (p->next == NULL)
+	 fputs("\nIndex0=\t\t", fp);
+#if 0
+    else if ( ci > 8 && (ci % 8) == 1)
+	 fputs("\nIndex =\t\t", fp);
+#endif
+    if (frameoff != -1)
+         fprintf(fp, "%d ", frameoff - trackstart);
+    else
+         fprintf(fp, "-1 ");
+  }
+  fputs("\n", fp);
+}
+
+/*
+ * write information before the start of the sampling process
+ *
+ *
+ * uglyfied for Joerg Schillings ultra dumb line parser
+ */
+static int write_info_file(char *fname_baseval, unsigned int track, 
+                           unsigned long int SamplesDone, int numbered)
+{
+  FILE *info_fp;
+  char fname[200];
+  char datetime[30];
+  time_t utc_time;
+  struct tm *tmptr;
+
+  /* write info file */
+  if (!strcmp(fname_baseval,"-")) return 0;
+
+  strncpy(fname, fname_baseval, sizeof(fname) -1);
+  fname[sizeof(fname) -1] = 0;
+  if (numbered)
+    sprintf(cut_extension(fname), "_%02u.inf", track);
+  else
+    strcpy(cut_extension(fname), ".inf");
+
+  info_fp = fopen (fname, "w");
+  if (!info_fp)
+    return -1;
+
+#if 0
+#ifdef MD5_SIGNATURES
+  if (global.md5blocksize)
+    MD5Final (global.MD5_result, &global.context);
+#endif
+#endif
+
+  utc_time = time(NULL);
+  tmptr = localtime(&utc_time);
+  if (tmptr) {
+    strftime(datetime, sizeof(datetime), "%x %X", tmptr);
+  } else {
+    strncpy(datetime, "unknown", sizeof(datetime));
+  }
+  fprintf(info_fp, "#created by icedax %s %s\n#\n", VERSION
+	  , datetime
+	  );
+  fprintf(info_fp,
+"CDINDEX_DISCID=\t'%s'\n" , global.cdindex_id);
+  fprintf(info_fp,
+"CDDB_DISCID=\t0x%08lx\n\
+MCN=\t\t%s\n\
+ISRC=\t\t%15.15s\n\
+#\n\
+Albumperformer=\t'%s'\n\
+Performer=\t'%s'\n\
+Albumtitle=\t'%s'\n"
+	  , (unsigned long) global.cddb_id
+	  , Get_MCN()
+	  , Get_ISRC(track)
+	  , global.creator != NULL ? global.creator : (const unsigned char *)""
+	  , global.trackcreator[track] != NULL ? global.trackcreator[track] :
+		(global.creator != NULL ? global.creator : (const unsigned char *)"")
+	  , global.disctitle != NULL ? global.disctitle : (const unsigned char *)""
+	  );
+  fprintf(info_fp,
+	  "Tracktitle=\t'%s'\n"
+	  , global.tracktitle[track] ? global.tracktitle[track] : (const unsigned char *)""
+	  );
+  fprintf(info_fp, "Tracknumber=\t%u\n"
+	  , track
+	  );
+  fprintf(info_fp, 
+	  "Trackstart=\t%ld\n"
+	  , Get_AudioStartSector(track)
+	  );
+  fprintf(info_fp, 
+	  "# track length in sectors (1/75 seconds each), rest samples\nTracklength=\t%ld, %d\n"
+	  , SamplesDone/588L,(int)(SamplesDone%588));
+  fprintf(info_fp, 
+	  "Pre-emphasis=\t%s\n"
+	  , Get_Preemphasis(track) && (global.deemphasize == 0) ? "yes" : "no");
+  fprintf(info_fp, 
+	  "Channels=\t%d\n"
+	  , Get_Channels(track) ? 4 : global.channels == 2 ? 2 : 1);
+	{ int cr = Get_Copyright(track);
+		fputs("Copy_permitted=\t", info_fp);
+		switch (cr) {
+			case 0:
+				fputs("once (copyright protected)\n", info_fp);
+			break;
+			case 1:
+				fputs("no (SCMS first copy)\n", info_fp);
+			break;
+			case 2:
+				fputs("yes (not copyright protected)\n", info_fp);
+			break;
+			default:
+				fputs("unknown\n", info_fp);
+		}
+	}
+  fprintf(info_fp, 
+	  "Endianess=\t%s\n"
+	  , global.need_big_endian ? "big" : "little"
+	  );
+  fprintf(info_fp, "# index list\n");
+  output_indices(info_fp, global.trackindexlist[track],
+		 Get_AudioStartSector(track));
+#if 0
+/* MD5 checksums in info files are currently broken.
+ *  for on-the-fly-recording the generation of info files has been shifted
+ *  before the recording starts, so there is no checksum at that point.
+ */
+#ifdef MD5_SIGNATURES
+  fprintf(info_fp, 
+	  "#(blocksize) checksum\nMD-5=\t\t(%d) %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n"
+	  , global.md5blocksize
+	  , global.MD5_result[0]
+	  , global.MD5_result[1]
+	  , global.MD5_result[2]
+	  , global.MD5_result[3]
+	  , global.MD5_result[4]
+	  , global.MD5_result[5]
+	  , global.MD5_result[6]
+	  , global.MD5_result[7]
+	  , global.MD5_result[8]
+	  , global.MD5_result[9]
+	  , global.MD5_result[10]
+	  , global.MD5_result[11]
+	  , global.MD5_result[12]
+	  , global.MD5_result[13]
+	  , global.MD5_result[14]
+	  , global.MD5_result[15]);
+#endif
+#endif
+  fclose(info_fp);
+  return 0;
+}
+#endif
+
+static void CloseAudio(int channels_val, unsigned long nSamples, 
+                       struct soundfile *audio_out)
+{
+      /* define length */
+      audio_out->ExitSound( global.audio, (nSamples-global.SkippedSamples)*global.OutSampleSize*channels_val );
+
+      close (global.audio);
+      global.audio = -1;
+}
+
+static unsigned int track = 1;
+
+/* On terminating:
+ * define size-related entries in audio file header, update and close file */
+static void CloseAll()
+{
+	WAIT_T chld_return_status;
+	int amiparent;
+
+	/* terminate child process first */
+	amiparent = child_pid > 0;
+
+	if (global.iloop > 0) {
+		/* set to zero */
+		global.iloop = 0;
+	}
+
+#if	defined	HAVE_FORK_AND_SHAREDMEM
+# ifdef DEBUG_CLEANUP
+	fprintf(stderr, "%s terminating, \n", amiparent ? 
+		"Parent (READER)" : "Child (WRITER)");
+#endif
+#else
+# ifdef DEBUG_CLEANUP
+	fprintf(stderr, "icedax single process terminating, \n");
+# endif
+#endif
+
+	if (amiparent || child_pid < 0) {
+		/* switch to original mode and close device */
+		EnableCdda (get_scsi_p(), 0, 0);
+	}
+
+	if (!amiparent) {
+		/* do general clean up */
+
+		if (global.audio>=0) {
+			if (bulk) {
+				/* finish sample file for this track */
+				CloseAudio(global.channels,
+				 global.nSamplesDoneInTrack, global.audio_out);
+			} else {
+				/* finish sample file for this track */
+				CloseAudio(global.channels,
+				 (unsigned int) *nSamplesToDo, global.audio_out);
+			}
+		}
+
+		/* tell minimum and maximum amplitudes, if required */
+		if (global.findminmax) {
+			fprintf(stderr,
+			"Right channel: minimum amplitude :%d/-32768, maximum amplitude :%d/32767\n", 
+			global.minamp[0], global.maxamp[0]);
+			fprintf(stderr,
+			"Left  channel: minimum amplitude :%d/-32768, maximum amplitude :%d/32767\n", 
+			global.minamp[1], global.maxamp[1]);
+		}
+
+		/* tell mono or stereo recording, if required */
+		if (global.findmono) {
+			fprintf(stderr, "Audio samples are originally %s.\n", global.ismono ? "mono" : "stereo");
+		}
+
+		return;	/* end of child or single process */
+	}
+
+
+	if (global.have_forked == 1) {
+#ifdef DEBUG_CLEANUP
+		fprintf(stderr, "Parent wait for child death, \n");
+#endif
+
+		/* wait for child to terminate */
+		if (0 > wait(&chld_return_status)) {
+			perror("");
+		} else {
+			if (WIFEXITED(chld_return_status)) {
+				if (WEXITSTATUS(chld_return_status)) {
+					fprintf(stderr, "\nW Child exited with %d\n", WEXITSTATUS(chld_return_status));
+				}
+			}
+			if (WIFSIGNALED(chld_return_status)) {
+				fprintf(stderr, "\nW Child exited due to signal %d\n", WTERMSIG(chld_return_status));
+			}
+			if (WIFSTOPPED(chld_return_status)) {
+				fprintf(stderr, "\nW Child is stopped due to signal %d\n", WSTOPSIG(chld_return_status));
+			}
+		}
+
+#ifdef DEBUG_CLEANUP
+		fprintf(stderr, "\nW Parent child death, state:%d\n", chld_return_status);
+#endif
+	}
+
+#ifdef GPROF
+	rename("gmon.out", "gmon.child");
+#endif
+}
+
+
+/* report a usage error and exit */
+#ifdef  PROTOTYPES
+static void usage2 (const char *szMessage, ...)
+#else
+static void usage2(const char *szMessage, va_dcl va_alist)
+#endif
+{
+	va_list marker;
+
+#ifdef  PROTOTYPES
+	va_start(marker, szMessage);
+#else
+	va_start(marker);
+#endif
+
+	vfprintf(stderr, szMessage, marker);
+
+	va_end(marker);
+	fprintf(stderr, "\nPlease use -help or consult the man page for help.\n");
+
+	exit (1);
+}
+
+
+/* report a fatal error, clean up and exit */
+#ifdef  PROTOTYPES
+void FatalError (const char *szMessage, ...)
+#else
+void FatalError(const char *szMessage, va_dcl va_alist)
+#endif
+{
+	va_list marker;
+
+#ifdef  PROTOTYPES
+	va_start(marker, szMessage);
+#else
+	va_start(marker);
+#endif
+
+	vfprintf(stderr, szMessage, marker);
+
+	va_end(marker);
+
+	if (child_pid >= 0) {
+		if (child_pid == 0) {
+			pid_t	ppid;
+			/*
+			 * Kill the parent too if we are not orphaned.
+			 */
+			ppid = getppid();
+			if (ppid > 1)
+				kill(ppid, SIGINT);
+		} else {
+			kill(child_pid, SIGINT);
+		}
+	}
+	exit (1);
+}
+
+
+/* open the audio output file and prepare the header. 
+ * the header will be defined on terminating (when the size
+ * is known). So hitting the interrupt key leaves an intact
+ * file.
+ */
+static void OpenAudio(char *fname, double rate, long nBitsPerSample, 
+                      long channels_val, unsigned long expected_bytes, 
+                      struct soundfile *audio_out)
+{
+  if (global.audio == -1) {
+
+    global.audio = open (fname, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY
+#ifdef SYNCHRONOUS_WRITE
+			 | O_SYNC
+#endif
+		  , 0666);
+    if (global.audio == -1) {
+      if (errno == EAGAIN && is_fifo(fname)) {
+        FatalError ("Could not open fifo %s. Probably no fifo reader present.\n", fname);
+      }
+      perror("open audio sample file");
+      FatalError ("Could not open file %s\n", fname);
+    }
+  }
+  global.SkippedSamples = 0;
+  any_signal = 0;
+  audio_out->InitSound( global.audio, channels_val, (unsigned long)rate, nBitsPerSample, expected_bytes );
+
+#ifdef MD5_SIGNATURES
+  if (global.md5blocksize)
+    MD5Init (&global.context);
+  global.md5count = global.md5blocksize;
+#endif
+}
+
+#include "scsi_cmds.h"
+
+static int RealEnd(SCSI *usalp, UINT4 *buff);
+
+static int RealEnd(SCSI *usalp, UINT4 *buff)
+{
+	if (usal_cmd_err(usalp) != 0) {
+		int c,k,q;
+
+		k = usal_sense_key(usalp);
+		c = usal_sense_code(usalp);
+		q = usal_sense_qual(usalp);
+		if ((k == 0x05 /* ILLEGAL_REQUEST */ &&
+		     c == 0x21 /* lba out of range */ &&
+		     q == 0x00) ||
+		    (k == 0x05 /* ILLEGAL_REQUEST */ &&
+		     c == 0x63 /*end of user area encountered on this track*/ &&
+		     q == 0x00) ||
+		    (k == 0x08 /* BLANK_CHECK */ &&
+		     c == 0x64 /* illegal mode for this track */ &&
+		     q == 0x00)) {
+			return 1;
+		}
+	}
+
+	if (usal_getresid(usalp) > 16) return 1;
+
+	{
+		unsigned char *p;
+		/* Look into the subchannel data */
+		buff += CD_FRAMESAMPLES;
+		p = (unsigned char *)buff;
+		if (p[0] == 0x21 && p[1] == 0xaa) {
+			return 1;
+		}
+	}
+	return 0;
+}
+
+static void set_offset(myringbuff *p, int offset)
+{
+#ifdef DEBUG_SHM
+  fprintf(stderr, "Write offset %d at %p\n", offset, &p->offset);
+#endif
+  p->offset = offset;
+}
+
+
+static int get_offset(myringbuff *p)
+{
+#ifdef DEBUG_SHM
+  fprintf(stderr, "Read offset %d from %p\n", p->offset, &p->offset);
+#endif
+  return p->offset;
+}
+
+
+static void usage()
+{
+  fputs(
+"usage: icedax [OPTIONS ...] [trackfilenames ...]\n\
+OPTIONS:\n\
+        [-c chans] [-s] [-m] [-b bits] [-r rate] [-a divider] [-S speed] [-x]\n\
+        [-t track[+endtrack]] [-i index] [-o offset] [-d duration] [-F] [-G]\n\
+        [-q] [-w] [-v vopts] [-R] [-P overlap] [-B] [-T] [-C input-endianess]\n\
+        [-e] [-n sectors] [-N] [-J] [-L cddbp-mode] [-H] [-g] [-l buffers] [-D cd-device]\n\
+        [-I interface] [-K sound-device] [-O audiotype] [-E output-endianess]\n\
+        [-A auxdevice] [-paranoia] [-cddbp-server=name] [-cddbp-port=port] [-version]\n", stderr);
+  fputs("\
+  (-D) dev=device		set the cdrom or scsi device (as Bus,Id,Lun).\n\
+  (-A) auxdevice=device		set the aux device (typically /dev/cdrom).\n\
+  (-K) sound-device=device	set the sound device to use for -e (typically /dev/dsp).\n\
+  (-I) interface=interface	specify the interface for cdrom access.\n\
+        (generic_scsi or cooked_ioctl).\n\
+  (-c) channels=channels	set 1 for mono, 2 or s for stereo (s: channels swapped).\n\
+  (-s) -stereo			select stereo recording.\n\
+  (-m) -mono			select mono recording.\n\
+  (-x) -max			select maximum quality (stereo/16-bit/44.1 KHz).\n\
+  (-b) bits=bits		set bits per sample per channel (8, 12 or 16 bits).\n\
+  (-r) rate=rate		set rate in samples per second. -R gives all rates\n\
+  (-a) divider=divider		set rate to 44100Hz / divider. -R gives all rates\n\
+  (-R) -dump-rates		dump a table with all available sample rates\n\
+  (-S) speed=speedfactor	set the cdrom drive to a given speed during reading\n\
+  (-P) set-overlap=sectors	set amount of overlap sampling (default is 0)\n\
+  (-n) sectors-per-request=secs	read 'sectors' sectors per request.\n\
+  (-l) buffers-in-ring=buffers	use a ring buffer with 'buffers' elements.\n\
+  (-t) track=track[+end track]	select start track (option. end track).\n\
+  (-i) index=index		select start index.\n\
+  (-o) offset=offset		start at 'offset' sectors behind start track/index.\n\
+        one sector equivalents 1/75 second.\n\
+  (-O) output-format=audiotype	set to wav, au (sun), cdr (raw), aiff or aifc format.\n\
+  (-C) cdrom-endianess=endian	set little, big or guess input sample endianess.\n\
+  (-E) output-endianess=endian	set little or big output sample endianess.\n\
+  (-d) duration=seconds		set recording time in seconds or 0 for whole track.\n\
+  (-w) -wait			wait for audio signal, then start recording.\n\
+  (-F) -find-extremes		find extrem amplitudes in samples.\n\
+  (-G) -find-mono		find if input samples are mono.\n\
+  (-T) -deemphasize		undo pre-emphasis in input samples.\n\
+  (-e) -echo			echo audio data to sound device (see -K) SOUND_DEV.\n\
+  (-v) verbose-level=optlist	controls verbosity (for a list use -vhelp).\n\
+  (-N) -no-write		do not create audio sample files.\n\
+  (-J) -info-only		give disc information only.\n\
+  (-L) cddb=cddbpmode		do cddbp title lookups.\n\
+        resolve multiple entries according to cddbpmode: 0=interactive, 1=first entry\n\
+  (-H) -no-infofile		no info file generation.\n\
+  (-g) -gui			generate special output suitable for gui frontends.\n\
+  (-Q) -silent-scsi		do not print status of erreneous scsi-commands.\n\
+       -scanbus			scan the SCSI bus and exit\n\
+       --devices		scan for system devices and print with native names\n\
+  (-M) md5=count		calculate MD-5 checksum for blocks of 'count' bytes.\n\
+  (-q) -quiet			quiet operation, no screen output.\n\
+  (-p) playback-realtime=perc	play (echo) audio pitched at perc percent (50%-200%).\n\
+  (-V) -verbose-scsi		each option increases verbosity for SCSI commands.\n\
+  (-h) -help			show this help screen.\n\
+  (-B) -alltracks, -bulk	record each track into a seperate file.\n\
+       -paranoia		use the lib paranoia for reading.\n\
+       -paraopts=opts		set options for lib paranoia (see -paraopts=help).\n\
+       -cddbp-server=servername	set the cddbp server to use for title lookups.\n\
+       -cddbp-port=portnumber	set the cddbp port to use for title lookups.\n\
+       -version			print version information.\n\
+\n\
+Please note: some short options will be phased out soon (disappear)!\n\
+\n\
+parameters: (optional) one or more file names or - for standard output.\n\
+", stderr);
+  fputs("Version ", stderr);
+  fputs(VERSION, stderr);
+  fprintf(stderr, "\n\
+defaults	%s, %d bit, %d.%02d Hz, track 1, no offset, one track,\n",
+	  CHANNELS-1?"stereo":"mono", BITS_P_S,
+	 44100 / UNDERSAMPLING,
+	 (4410000 / UNDERSAMPLING) % 100);
+  fprintf(stderr, "\
+          type %s '%s', don't wait for signal, not quiet,\n",
+          AUDIOTYPE, FILENAME);
+  fprintf(stderr, "\
+          use %s, device %s, aux %s\n",
+	  DEF_INTERFACE, CD_DEVICE, AUX_DEVICE);
+  exit( SYNTAX_ERROR );
+}
+
+static void init_globals()
+{
+#ifdef	HISTORICAL_JUNK
+  global.dev_name = CD_DEVICE;	/* device name */
+#endif
+  global.aux_name = AUX_DEVICE;/* auxiliary cdrom device */
+  strncpy(global.fname_base, FILENAME, sizeof(global.fname_base));/* auxiliary cdrom device */
+  global.have_forked = 0;	/* state variable for clean up */
+  global.parent_died = 0;	/* state variable for clean up */
+  global.audio    = -1;		/* audio file desc */
+  global.cooked_fd  = -1;	/* cdrom file desc */
+  global.no_file  =  0;		/* flag no_file */
+  global.no_infofile  =  0;	/* flag no_infofile */
+  global.no_cddbfile  =  0;	/* flag no_cddbfile */
+  global.quiet	  =  0;		/* flag quiet */
+  global.verbose  =  SHOW_TOC + SHOW_SUMMARY + SHOW_STARTPOSITIONS + SHOW_TITLES;	/* verbose level */
+  global.scsi_silent = 0;
+  global.scsi_verbose = 0;		/* SCSI verbose level */
+  global.scanbus = 0;
+  global.scandevs = 0;
+  global.multiname = 0;		/* multiple file names given */
+  global.sh_bits  =  0;		/* sh_bits: sample bit shift */
+  global.Remainder=  0;		/* remainder */
+  global.iloop    =  0;		/* todo counter */
+  global.SkippedSamples =  0;	/* skipped samples */
+  global.OutSampleSize  =  0;	/* output sample size */
+  global.channels = CHANNELS;	/* output sound channels */
+  global.nSamplesDoneInTrack = 0; /* written samples in current track */
+  global.buffers = 4;           /* buffers to use */
+  global.nsectors = NSECTORS;   /* sectors to read in one request */
+  global.overlap = 1;           /* amount of overlapping sectors */
+  global.useroverlap = -1;      /* amount of overlapping sectors user override */
+  global.need_hostorder = 0;	/* processing needs samples in host endianess */
+  global.in_lendian = -1;	/* input endianess from SetupSCSI() */
+  global.outputendianess = NONE; /* user specified output endianess */
+  global.findminmax  =  0;	/* flag find extrem amplitudes */
+#ifdef HAVE_LIMITS_H
+  global.maxamp[0] = INT_MIN;	/* maximum amplitude */
+  global.maxamp[1] = INT_MIN;	/* maximum amplitude */
+  global.minamp[0] = INT_MAX;	/* minimum amplitude */
+  global.minamp[1] = INT_MAX;	/* minimum amplitude */
+#else
+  global.maxamp[0] = -32768;	/* maximum amplitude */
+  global.maxamp[1] = -32768;	/* maximum amplitude */
+  global.minamp[0] = 32767;	/* minimum amplitude */
+  global.minamp[1] = 32767;	/* minimum amplitude */
+#endif
+  global.speed = DEFAULT_SPEED; /* use default */ 
+  global.userspeed = -1;        /* speed user override */
+  global.findmono  =  0;	/* flag find if samples are mono */
+  global.ismono  =  1;		/* flag if samples are mono */
+  global.swapchannels  =  0;	/* flag if channels shall be swapped */
+  global.deemphasize  =  0;	/* flag undo pre-emphasis in samples */
+  global.playback_rate = 100;   /* new fancy selectable sound output rate */
+  global.gui  =  0;		/* flag plain formatting for guis */
+  global.cddb_id = 0;           /* disc identifying id for CDDB database */
+  global.cddb_revision = 0;     /* entry revision for CDDB database */
+  global.cddb_year = 0;         /* disc identifying year for CDDB database */
+  global.cddb_genre[0] = '\0';  /* disc identifying genre for CDDB database */
+  global.cddbp = 0;             /* flag if titles shall be looked up from CDDBP */
+  global.cddbp_server = 0;      /* user supplied CDDBP server */
+  global.cddbp_port = 0;        /* user supplied CDDBP port */
+  global.illleadout_cd = 0;     /* flag if illegal leadout is present */
+  global.reads_illleadout = 0;  /* flag if cdrom drive reads cds with illegal leadouts */
+  global.disctitle = NULL;
+  global.creator = NULL;
+  global.copyright_message = NULL;
+  memset(global.tracktitle, 0, sizeof(global.tracktitle));
+  memset(global.trackindexlist, 0, sizeof(global.trackindexlist));
+
+  global.just_the_toc = 0;
+#ifdef	USE_PARANOIA
+	global.paranoia_parms.disable_paranoia = 
+	global.paranoia_parms.disable_extra_paranoia = 
+	global.paranoia_parms.disable_scratch_detect =
+	global.paranoia_parms.disable_scratch_repair = 0;
+	global.paranoia_parms.retries = 20;
+	global.paranoia_parms.overlap = -1;
+	global.paranoia_parms.mindynoverlap = -1;
+	global.paranoia_parms.maxdynoverlap = -1;
+#endif
+}
+
+#if !defined (HAVE_STRCASECMP) || (HAVE_STRCASECMP != 1)
+#include <ctype.h>
+static int strcasecmp(const char *s1, const char *s2);
+static int strcasecmp(const char *s1, const char *s2)
+{
+  if (s1 && s2) {
+    while (*s1 && *s2 && (tolower(*s1) - tolower(*s2) == 0)) {
+      s1++;
+      s2++;
+    }
+    if (*s1 == '\0' && *s2 == '\0') return 0;
+    if (*s1 == '\0') return -1;
+    if (*s2 == '\0') return +1;
+    return tolower(*s1) - tolower(*s2);
+  }
+  return -1;
+}
+#endif
+
+static int is_fifo(char *filename)
+{
+#if	defined S_ISFIFO
+  struct stat statstruct;
+
+  if (stat(filename, &statstruct)) {
+    /* maybe the output file does not exist. */
+    if (errno == ENOENT)
+	return 0;
+    else comerr("Error during stat for output file\n");
+  } else {
+    if (S_ISFIFO(statstruct.st_mode)) {
+	return 1;
+    }
+  }
+  return 0;
+#else
+  return 0;
+#endif
+}
+
+
+#if !defined (HAVE_STRTOUL) || (HAVE_STRTOUL != 1)
+static unsigned int strtoul(const char *s1, char **s2, int base);
+static unsigned int strtoul(const char *s1, char **s2, int base)
+{
+	long retval;
+
+	if (base == 10) {
+		/* strip zeros in front */
+		while (*s1 == '0')
+			s1++;
+	}
+	if (s2 != NULL) {
+		*s2 = astol(s1, &retval);
+	} else {
+		(void) astol(s1, &retval);
+	}
+
+	return (unsigned long) retval; 	
+}
+#endif
+
+static unsigned long SectorBurst;
+#if (SENTINEL > CD_FRAMESIZE_RAW)
+error block size for overlap check has to be < sector size
+#endif
+
+
+static void
+switch_to_realtime_priority(void);
+
+#ifdef  HAVE_SYS_PRIOCNTL_H
+
+#include <sys/priocntl.h>
+#include <sys/rtpriocntl.h>
+static void switch_to_realtime_priority()
+{
+        pcinfo_t        info;
+        pcparms_t       param;
+        rtinfo_t        rtinfo;
+        rtparms_t       rtparam;
+	int		pid;
+
+	pid = getpid();
+
+        /* get info */
+        strcpy(info.pc_clname, "RT");
+        if (-1 == priocntl(P_PID, pid, PC_GETCID, (void *)&info)) {
+                errmsg("Cannot get priority class id priocntl(PC_GETCID)\n");
+		goto prio_done;
+	}
+
+        memmove(&rtinfo, info.pc_clinfo, sizeof(rtinfo_t));
+
+        /* set priority not to the max */
+        rtparam.rt_pri = rtinfo.rt_maxpri - 2;
+        rtparam.rt_tqsecs = 0;
+        rtparam.rt_tqnsecs = RT_TQDEF;
+        param.pc_cid = info.pc_cid;
+        memmove(param.pc_clparms, &rtparam, sizeof(rtparms_t));
+	priv_on();
+	needroot(0);
+        if (-1 == priocntl(P_PID, pid, PC_SETPARMS, (void *)&param))
+                errmsg("Cannot set priority class parameters priocntl(PC_SETPARMS)\n");
+prio_done:
+	priv_off();
+	dontneedroot();
+}
+#else
+#if defined(_POSIX_PRIORITY_SCHEDULING) && _POSIX_PRIORITY_SCHEDULING -0 >= 0
+#define	USE_POSIX_PRIORITY_SCHEDULING
+#endif
+#ifdef	USE_POSIX_PRIORITY_SCHEDULING
+#include <sched.h>
+
+static void switch_to_realtime_priority()
+{
+#ifdef  _SC_PRIORITY_SCHEDULING
+	if (sysconf(_SC_PRIORITY_SCHEDULING) == -1) {
+		errmsg("WARNING: RR-scheduler not available, disabling.\n");
+	} else
+#endif
+	{
+	int sched_fifo_min, sched_fifo_max;
+	struct sched_param sched_parms;
+
+	sched_fifo_min = sched_get_priority_min(SCHED_FIFO);
+	sched_fifo_max = sched_get_priority_max(SCHED_FIFO);
+	sched_parms.sched_priority = sched_fifo_max - 1;
+	priv_on();
+	needroot(0);
+	if (-1 == sched_setscheduler(getpid(), SCHED_FIFO, &sched_parms)
+		&& global.quiet != 1)
+		errmsg("cannot set posix realtime scheduling policy\n");
+	priv_off();
+	dontneedroot();
+	}
+}
+#else
+#if defined(__CYGWIN32__)
+
+/*
+ * NOTE: Base.h from Cygwin-B20 has a second typedef for BOOL.
+ *	 We define BOOL to make all local code use BOOL
+ *	 from Windows.h and use the hidden __SBOOL for
+ *	 our global interfaces.
+ *
+ * NOTE: windows.h from Cygwin-1.x includes a structure field named sample,
+ *	 so me may not define our own 'sample' or need to #undef it now.
+ *	 With a few nasty exceptions, Microsoft assumes that any global
+ *	 defines or identifiers will begin with an Uppercase letter, so
+ *	 there may be more of these problems in the future.
+ *
+ * NOTE: windows.h defines interface as an alias for struct, this 
+ *	 is used by COM/OLE2, I guess it is class on C++
+ *	 We man need to #undef 'interface'
+ */
+#define	BOOL	WBOOL		/* This is the Win BOOL		*/
+#define	format	__format	/* Avoid format parameter hides global ... */
+#include <windows.h>
+#undef format
+#undef interface
+
+static void switch_to_realtime_priority()
+{
+   /* set priority class */
+   if (FALSE == SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS)) {
+     fprintf(stderr, "No realtime priority possible.\n");
+     return;
+   }
+
+   /* set thread priority */
+   if (FALSE == SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST)) {
+     fprintf(stderr, "Could not set realtime priority.\n");
+   }
+}
+#else
+static void switch_to_realtime_priority()
+{
+}
+#endif
+#endif
+#endif
+
+/* SCSI cleanup */
+int on_exitscsi(void *status);
+
+int on_exitscsi(void *status)
+{
+	exit((intptr_t)status);
+	return 0;
+}
+
+/* wrapper for signal handler exit needed for Mac-OS-X */
+static void exit_wrapper(int status);
+
+static void exit_wrapper(int status)
+{
+#if defined DEBUG_CLEANUP
+	fprintf( stderr, "Exit(%d) for %s\n", status, child_pid == 0 ? "Child" : "Parent");
+	fflush(stderr);
+#endif
+
+	if (child_pid != 0) {
+		SCSI *usalp = get_scsi_p();
+		if (usalp->running) {
+			usalp->cb_fun = on_exitscsi;
+			usalp->cb_arg = (void *) (uintptr_t) status;
+		} else {
+			on_exitscsi((void *) (intptr_t) status);
+		} 
+	} else {
+		exit(status);
+	}
+}
+
+/* signal handler for process communication */
+static void set_nonforked(int status);
+
+/* ARGSUSED */
+static void set_nonforked(int status)
+{
+	global.parent_died = 1;
+#if defined DEBUG_CLEANUP
+fprintf( stderr, "SIGPIPE received from %s\n.", child_pid == 0 ? "Child" : "Parent");
+#endif
+	if (child_pid == 0) {
+		pid_t	ppid;
+		/*
+		 * Kill the parent too if we are not orphaned.
+		 */
+		ppid = getppid();
+		if (ppid > 1)
+			kill(ppid, SIGINT);
+	} else {
+		kill(child_pid, SIGINT);
+	}
+	exit(SIGPIPE_ERROR);
+}
+
+
+
+#ifdef	USE_PARANOIA
+static struct paranoia_statistics
+{
+	long	c_sector;
+	long	v_sector;
+	int	last_heartbeatstate;
+	long	lasttime;
+	char	heartbeat;
+	int	minoverlap;
+	int	curoverlap;
+	int	maxoverlap;
+	int	slevel;
+	int	slastlevel;
+	int	stimeout;
+	int	rip_smile_level;
+	unsigned verifies;
+	unsigned reads;
+	unsigned fixup_edges;
+	unsigned fixup_atoms;
+	unsigned readerrs;
+	unsigned skips;
+	unsigned overlaps;
+	unsigned scratchs;
+	unsigned drifts;
+	unsigned fixup_droppeds;
+	unsigned fixup_dupeds;
+}	*para_stat;
+
+
+static void paranoia_reset(void);
+static void paranoia_reset()
+{
+	para_stat->c_sector = 0;
+	para_stat->v_sector = 0;
+	para_stat->last_heartbeatstate = 0;
+	para_stat->lasttime = 0;
+	para_stat->heartbeat = ' ';
+	para_stat->minoverlap = 0x7FFFFFFF;
+	para_stat->curoverlap = 0;
+	para_stat->maxoverlap = 0;
+	para_stat->slevel = 0;
+	para_stat->slastlevel = 0;
+	para_stat->stimeout = 0;
+	para_stat->rip_smile_level = 0;
+	para_stat->verifies = 0;
+	para_stat->reads = 0;
+	para_stat->readerrs = 0;
+	para_stat->fixup_edges = 0;
+	para_stat->fixup_atoms = 0;
+	para_stat->fixup_droppeds = 0;
+	para_stat->fixup_dupeds = 0;
+	para_stat->drifts = 0;
+	para_stat->scratchs = 0;
+	para_stat->overlaps = 0;
+	para_stat->skips = 0;
+}
+
+static void paranoia_callback(long inpos, int function);
+
+static void paranoia_callback(long inpos, int function)
+{
+	struct timeval thistime;
+	long	test;
+
+	switch (function) {
+		case	-2:
+			para_stat->v_sector = inpos / CD_FRAMEWORDS;
+			return;
+		case	-1:
+			para_stat->last_heartbeatstate = 8;
+			para_stat->heartbeat = '*';
+			para_stat->slevel = 0;
+			para_stat->v_sector = inpos / CD_FRAMEWORDS;
+		break;
+		case	PARANOIA_CB_VERIFY:
+			if (para_stat->stimeout >= 30) {
+				if (para_stat->curoverlap > CD_FRAMEWORDS) {
+					para_stat->slevel = 2;
+				} else {
+					para_stat->slevel = 1;
+				}
+			}
+			para_stat->verifies++;
+		break;
+		case	PARANOIA_CB_READ:
+			if (inpos / CD_FRAMEWORDS > para_stat->c_sector) {
+				para_stat->c_sector = inpos / CD_FRAMEWORDS;
+			}
+			para_stat->reads++;
+		break;
+		case	PARANOIA_CB_FIXUP_EDGE:
+			if (para_stat->stimeout >= 5) {
+				if (para_stat->curoverlap > CD_FRAMEWORDS) {
+					para_stat->slevel = 2;
+				} else {
+					para_stat->slevel = 1;
+				}
+			}
+			para_stat->fixup_edges++;
+		break;
+		case	PARANOIA_CB_FIXUP_ATOM:
+			if (para_stat->slevel < 3 || para_stat->stimeout > 5) {
+				para_stat->slevel = 3;
+			}
+			para_stat->fixup_atoms++;
+		break;
+		case	PARANOIA_CB_READERR:
+			para_stat->slevel = 6;
+			para_stat->readerrs++;
+		break;
+		case	PARANOIA_CB_SKIP:
+			para_stat->slevel = 8;
+			para_stat->skips++;
+		break;
+		case	PARANOIA_CB_OVERLAP:
+			para_stat->curoverlap = inpos;
+			if (inpos > para_stat->maxoverlap)
+				para_stat->maxoverlap = inpos;
+			if (inpos < para_stat->minoverlap)
+				para_stat->minoverlap = inpos;
+			para_stat->overlaps++;
+		break;
+		case	PARANOIA_CB_SCRATCH:
+			para_stat->slevel = 7;
+			para_stat->scratchs++;
+		break;
+		case	PARANOIA_CB_DRIFT:
+			if (para_stat->slevel < 4 || para_stat->stimeout > 5) {
+				para_stat->slevel = 4;
+			}
+			para_stat->drifts++;
+		break;
+		case	PARANOIA_CB_FIXUP_DROPPED:
+			para_stat->slevel = 5;
+			para_stat->fixup_droppeds++;
+		break;
+		case	PARANOIA_CB_FIXUP_DUPED:
+			para_stat->slevel = 5;
+			para_stat->fixup_dupeds++;
+		break;
+	}
+
+	gettimeofday(&thistime, NULL);
+	/* now in tenth of seconds. */
+	test = thistime.tv_sec * 10 + thistime.tv_usec / 100000;
+
+	if (para_stat->lasttime != test
+		|| function == -1
+		|| para_stat->slastlevel != para_stat->slevel) {
+
+		if (function == -1
+			|| para_stat->slastlevel != para_stat->slevel) {
+
+			static const char hstates[] = " .o0O0o.";
+
+			para_stat->lasttime = test;
+			para_stat->stimeout++;
+
+			para_stat->last_heartbeatstate++;
+			if (para_stat->last_heartbeatstate > 7) {
+				para_stat->last_heartbeatstate = 0;
+			}
+			para_stat->heartbeat = hstates[para_stat->last_heartbeatstate];
+
+			if (function == -1) {
+				para_stat->heartbeat = '*';
+			}
+		}
+
+		if (para_stat->slastlevel != para_stat->slevel) {
+			para_stat->stimeout = 0;
+		}
+		para_stat->slastlevel = para_stat->slevel;
+	}
+
+	if (para_stat->slevel < 8) {
+		para_stat->rip_smile_level = para_stat->slevel;
+	} else {
+		para_stat->rip_smile_level = 0;
+	}
+}
+#endif
+
+static long lSector;
+static long lSector_p2;
+static double rate = 44100.0 / UNDERSAMPLING;
+static int bits = BITS_P_S;
+static char fname[200];
+static const char *audio_type;
+static long BeginAtSample;
+static unsigned long SamplesToWrite; 
+static unsigned minover;
+static unsigned maxover;
+
+static unsigned long calc_SectorBurst(void);
+static unsigned long calc_SectorBurst()
+{
+	unsigned long SectorBurstVal;
+
+	SectorBurstVal = min(global.nsectors,
+		  (global.iloop + CD_FRAMESAMPLES-1) / CD_FRAMESAMPLES);
+	if ( lSector+(int)SectorBurst-1 >= lSector_p2 )
+		SectorBurstVal = lSector_p2 - lSector;
+	return SectorBurstVal;
+}
+
+/* if PERCENTAGE_PER_TRACK is defined, the percentage message will reach
+ * 100% every time a track end is reached or the time limit is reached.
+ *
+ * Otherwise if PERCENTAGE_PER_TRACK is not defined, the percentage message
+ * will reach 100% once at the very end of the last track.
+ */
+#define	PERCENTAGE_PER_TRACK
+
+static int do_read(myringbuff *p, unsigned *total_unsuccessful_retries);
+static int do_read(myringbuff *p, unsigned *total_unsuccessful_retries)
+{
+	unsigned char *newbuf;
+	int offset;
+	unsigned int added_size;
+
+	/* how many sectors should be read */
+	SectorBurst =  calc_SectorBurst();
+
+#ifdef	USE_PARANOIA
+	if (global.paranoia_selected) {
+		int i;
+
+		for (i = 0; i < SectorBurst; i++) {
+			void *dp;
+
+			dp = paranoia_read_limited(global.cdp, paranoia_callback,
+				global.paranoia_parms.retries);
+/*
+			{
+				char *err;
+				char *msg;
+				err = cdda_errors(global.cdp);
+				msg = cdda_messages(global.cdp);
+				if (err) {
+					fputs(err, stderr);
+					free(err);
+				}
+				if (msg) {
+					fputs(msg, stderr);
+					free(msg);
+				}
+			}
+*/
+			if (dp != NULL)	{
+				memcpy(p->data + i*CD_FRAMESAMPLES, dp,
+					CD_FRAMESIZE_RAW);
+			} else {
+				fputs("E unrecoverable error!", stderr);
+				exit(READ_ERROR);
+			}
+		}
+		newbuf = (unsigned char *)p->data;
+		offset = 0;
+        	set_offset(p,offset);
+		added_size = SectorBurst * CD_FRAMESAMPLES;
+		global.overlap = 0;
+		handle_inputendianess(p->data, added_size);
+	} else 
+#endif
+	{
+		unsigned int retry_count;
+#define MAX_READRETRY 12
+
+		retry_count = 0;
+		do {
+			SCSI *usalp = get_scsi_p();
+			int retval;
+#ifdef DEBUG_READS
+fprintf(stderr, "reading from %lu to %lu, overlap %u\n", lSector, lSector + SectorBurst -1, global.overlap);
+#endif
+
+#ifdef DEBUG_BUFFER_ADDRESSES
+fprintf(stderr, "%p %l\n", p->data, global.pagesize);
+if (((unsigned)p->data) & (global.pagesize -1) != 0) {
+  fprintf(stderr, "Address %p is NOT page aligned!!\n", p->data);
+}
+#endif
+
+			if (global.reads_illleadout != 0 && lSector > Get_StartSector(LastTrack())) {
+				int singles = 0;
+				UINT4 bufferSub[CD_FRAMESAMPLES + 24];
+
+				/* we switch to single sector reads,
+				 * in order to handle the remaining sectors. */
+				usalp->silent++;
+				do {
+					ReadCdRomSub( usalp, bufferSub, lSector+singles, 1 );
+					*eorecording = RealEnd( usalp, bufferSub );
+					if (*eorecording) {
+						break;
+					}
+					memcpy(p->data+singles*CD_FRAMESAMPLES, bufferSub, CD_FRAMESIZE_RAW);
+					singles++;
+				} while (singles < SectorBurst);
+				usalp->silent--;
+
+				if ( *eorecording ) {
+					patch_real_end(lSector+singles);
+					SectorBurst = singles;
+#if	DEBUG_ILLLEADOUT
+fprintf(stderr, "iloop=%11lu, nSamplesToDo=%11lu, end=%lu -->\n",
+global.iloop, *nSamplesToDo, lSector+singles);
+#endif
+
+					*nSamplesToDo -= global.iloop - SectorBurst*CD_FRAMESAMPLES;
+					global.iloop = SectorBurst*CD_FRAMESAMPLES;
+#if	DEBUG_ILLLEADOUT
+fprintf(stderr, "iloop=%11lu, nSamplesToDo=%11lu\n\n",
+global.iloop, *nSamplesToDo);
+#endif
+
+				}
+			} else {
+				retval = ReadCdRom( usalp, p->data, lSector, SectorBurst );
+			}
+			handle_inputendianess(p->data, SectorBurst * CD_FRAMESAMPLES);
+			if (NULL ==
+				(newbuf = synchronize( p->data, SectorBurst*CD_FRAMESAMPLES,
+                			*nSamplesToDo-global.iloop ))) {
+				/* could not synchronize!
+				 * Try to invalidate the cdrom cache.
+				 * Increase overlap setting, if possible.
+				 */	
+				/*trash_cache(p->data, lSector, SectorBurst);*/
+				if (global.overlap < global.nsectors - 1) {
+					global.overlap++;
+					lSector--;
+					SectorBurst = calc_SectorBurst();
+#ifdef DEBUG_DYN_OVERLAP
+fprintf(stderr, "using increased overlap of %u\n", global.overlap);
+#endif
+				} else {
+					lSector += global.overlap - 1;
+					global.overlap = 1;
+					SectorBurst =  calc_SectorBurst();
+				}
+			} else
+				break;
+		} while (++retry_count < MAX_READRETRY);
+
+		if (retry_count == MAX_READRETRY && newbuf == NULL && global.verbose != 0) {
+			(*total_unsuccessful_retries)++;
+		}
+
+		if (newbuf) {
+			offset = newbuf - ((unsigned char *)p->data);
+		} else {
+			offset = global.overlap * CD_FRAMESIZE_RAW;
+		}
+		set_offset(p,offset);
+
+		/* how much has been added? */
+		added_size = SectorBurst * CD_FRAMESAMPLES - offset/4;
+
+		if (newbuf && *nSamplesToDo != global.iloop) {
+			minover = min(global.overlap, minover);
+			maxover = max(global.overlap, maxover);
+
+
+			/* should we reduce the overlap setting ? */
+			if (offset > CD_FRAMESIZE_RAW && global.overlap > 1) {
+#ifdef DEBUG_DYN_OVERLAP
+fprintf(stderr, "decreasing overlap from %u to %u (jitter %d)\n", global.overlap, global.overlap-1, offset - (global.overlap)*CD_FRAMESIZE_RAW);
+#endif
+				global.overlap--;
+				SectorBurst =  calc_SectorBurst();
+			}
+		}
+	}
+	if (global.iloop >= added_size) {
+		global.iloop -= added_size;
+	} else {
+		global.iloop = 0;
+	}
+
+	lSector += SectorBurst - global.overlap;
+
+#if	defined	PERCENTAGE_PER_TRACK && defined HAVE_FORK_AND_SHAREDMEM
+	{
+		int as;
+		while ((as = Get_StartSector(current_track+1)) != -1
+			&& lSector >= as) {
+			current_track++;
+		}
+	}
+#endif
+
+	return offset;
+}
+
+static void
+print_percentage(unsigned *poper, int c_offset);
+
+static void print_percentage(unsigned *poper, int c_offset)
+{
+	unsigned per;
+#ifdef	PERCENTAGE_PER_TRACK
+	/* Thomas Niederreiter wants percentage per track */
+	unsigned start_in_track = max(BeginAtSample,
+		Get_AudioStartSector(current_track)*CD_FRAMESAMPLES);
+
+	per = min(BeginAtSample + (long)*nSamplesToDo,
+		Get_StartSector(current_track+1)*CD_FRAMESAMPLES)
+		- (long)start_in_track;
+
+	per = (BeginAtSample+nSamplesDone
+		- start_in_track
+		)/(per/100);
+
+#else
+	per = global.iloop ? (nSamplesDone)/(*nSamplesToDo/100) : 100;
+#endif
+
+	if (global.overlap > 0) {
+		fprintf(stderr, "\r%2d/%2d/%2d/%7d %3d%%",
+			minover, maxover, global.overlap,
+			c_offset - global.overlap*CD_FRAMESIZE_RAW,
+			per);
+	} else if (*poper != per) {
+		fprintf(stderr, "\r%3d%%", per);
+	}
+	*poper = per;
+	fflush(stderr);
+}
+
+static unsigned long do_write(myringbuff *p);
+static unsigned long do_write(myringbuff *p)
+{
+	int current_offset;
+	unsigned int InSamples;
+	static unsigned oper = 200;
+
+	current_offset = get_offset(p);
+
+	/* how many bytes are available? */
+	InSamples = global.nsectors*CD_FRAMESAMPLES - current_offset/4;
+	/* how many samples are wanted? */
+	InSamples = min((*nSamplesToDo-nSamplesDone),InSamples);
+
+	/* when track end is reached, close current file and start a new one */
+	while ((nSamplesDone < *nSamplesToDo) && (InSamples != 0)) {
+		long unsigned int how_much = InSamples;
+
+		long int left_in_track;
+		left_in_track  = Get_StartSector(current_track+1)*CD_FRAMESAMPLES
+				 - (int)(BeginAtSample+nSamplesDone);
+
+		if (*eorecording != 0 && current_track == cdtracks+1 &&
+       		    (*total_segments_read) == (*total_segments_written)+1) {
+			/* limit, if the actual end of the last track is
+			 * not known from the toc. */
+			left_in_track = InSamples;
+		}
+
+if (left_in_track < 0) {
+	fprintf(stderr, "internal error: negative left_in_track:%ld, current_track=%d\n",left_in_track, current_track);
+}
+
+		if (bulk) {
+			how_much = min(how_much, (unsigned long) left_in_track);
+		}
+
+#ifdef MD5_SIGNATURES
+		if (global.md5count) {
+			MD5Update (&global.context, ((unsigned char *)p->data) +current_offset, min(global.md5count,how_much));
+			global.md5count -= min(global.md5count,how_much);
+		}
+#endif
+		if ( SaveBuffer ( p->data + current_offset/4,
+			 how_much,
+			 &nSamplesDone) ) {
+			if (global.have_forked == 1) {
+				pid_t	ppid;
+				/*
+				 * Kill the parent too if we are not orphaned.
+				 */
+				ppid = getppid();
+				if (ppid > 1)
+					kill(ppid, SIGINT);
+			}
+			exit(WRITE_ERROR);
+		}
+
+		global.nSamplesDoneInTrack += how_much;
+		SamplesToWrite -= how_much;
+
+		/* move residual samples upto buffer start */
+		if (how_much < InSamples) {
+			memmove(
+			  (char *)(p->data) + current_offset,
+			  (char *)(p->data) + current_offset + how_much*4,
+			  (InSamples - how_much) * 4);
+		}
+
+		if ((unsigned long) left_in_track <= InSamples || SamplesToWrite == 0) {
+			/* the current portion to be handled is 
+			   the end of a track */
+
+			if (bulk) {
+				/* finish sample file for this track */
+				CloseAudio(global.channels,
+				  global.nSamplesDoneInTrack, global.audio_out);
+			} else if (SamplesToWrite == 0) {
+				/* finish sample file for this track */
+				CloseAudio(global.channels,
+				  (unsigned int) *nSamplesToDo, global.audio_out);
+			}
+
+			if (global.verbose) {
+#ifdef	USE_PARANOIA
+				double	f;
+#endif
+				print_percentage(&oper, current_offset);
+				fputc(' ', stderr);
+#ifndef	THOMAS_SCHAU_MAL
+				if ((unsigned long)left_in_track > InSamples) {
+					fputs(" incomplete", stderr);
+				}
+#endif
+				if (global.tracktitle[current_track] != NULL) {
+					fprintf( stderr,
+						" track %2u '%s' recorded", 
+						current_track,
+						global.tracktitle[current_track]);
+				} else {
+					fprintf( stderr,
+						" track %2u recorded",
+						current_track);
+				}
+#ifdef	USE_PARANOIA
+				oper = para_stat->readerrs + para_stat->skips +
+					  para_stat->fixup_edges + para_stat->fixup_atoms + 
+					  para_stat->fixup_droppeds + para_stat->fixup_dupeds + 
+					  para_stat->drifts;
+				f = (100.0 * oper) / (((double)global.nSamplesDoneInTrack)/588.0);
+
+				if (para_stat->readerrs) {
+					fprintf(stderr, " with audible hard errors");
+				} else if ((para_stat->skips) > 0) {
+					fprintf(stderr, " with %sretry/skip errors",
+							f < 2.0 ? "":"audible ");
+				} else if (oper > 0) {
+					oper = f;
+					
+					fprintf(stderr, " with ");
+					if (oper < 2)
+						fprintf(stderr, "minor");
+					else if (oper < 10)
+						fprintf(stderr, "medium");
+					else if (oper < 67)
+						fprintf(stderr, "noticable audible");
+					else if (oper < 100)
+						fprintf(stderr, "major audible");
+					else
+						fprintf(stderr, "extreme audible");
+					fprintf(stderr, " problems");
+				} else {
+					fprintf(stderr, " successfully");
+				}
+				if (f >= 0.1)
+					fprintf(stderr, " (%.1f%% problem sectors)", f);
+#else
+				fprintf(stderr, " successfully");
+#endif
+
+				if (waitforsignal == 1) {
+					fprintf(stderr, ". %d silent samples omitted", global.SkippedSamples);
+				}
+				fputs("\n", stderr);
+
+				if (global.reads_illleadout && *eorecording == 1) {
+					fprintf(stderr, "Real lead out at: %ld sectors\n", 
+					  (*nSamplesToDo+BeginAtSample)/CD_FRAMESAMPLES);
+				}
+#ifdef	USE_PARANOIA
+				if (global.paranoia_selected) {
+					oper = 200;	/* force new output */
+					print_percentage(&oper, current_offset);
+					if (para_stat->minoverlap == 0x7FFFFFFF)
+						para_stat->minoverlap = 0;
+					fprintf(stderr, "  %u rderr, %u skip, %u atom, %u edge, %u drop, %u dup, %u drift\n"
+						,para_stat->readerrs
+						,para_stat->skips
+						,para_stat->fixup_atoms
+						,para_stat->fixup_edges
+						,para_stat->fixup_droppeds
+						,para_stat->fixup_dupeds
+						,para_stat->drifts);
+					oper = 200;	/* force new output */
+					print_percentage(&oper, current_offset);
+					fprintf(stderr, "  %u overlap(%.4g .. %.4g)\n",
+						para_stat->overlaps,
+						(float)para_stat->minoverlap / (2352.0/2.0),
+						(float)para_stat->maxoverlap / (2352.0/2.0));
+					paranoia_reset();
+				}
+#endif
+			}
+
+			global.nSamplesDoneInTrack = 0;
+			if ( bulk && SamplesToWrite > 0 ) {
+				if ( !global.no_file ) {
+					char *tmp_fname;
+
+					/* build next filename */
+					tmp_fname = get_next_name();
+					if (tmp_fname != NULL) {
+						strncpy(global.fname_base,
+							tmp_fname,
+							sizeof global.fname_base);
+						global.fname_base[
+							sizeof(global.fname_base)-1] =
+							'\0';
+					}
+
+					tmp_fname = cut_extension(global.fname_base);
+					tmp_fname[0] = '\0';
+
+					if (global.multiname == 0) {
+						sprintf(fname, "%s_%02u.%s",
+							global.fname_base,
+							current_track+1,
+							audio_type);
+					} else {
+						sprintf(fname, "%s.%s",
+							global.fname_base,
+							audio_type);
+					}
+
+					OpenAudio( fname, rate, bits, global.channels,
+						(Get_AudioStartSector(current_track+1) -
+						 Get_AudioStartSector(current_track))
+							*CD_FRAMESIZE_RAW,
+						global.audio_out);
+				} /* global.nofile */
+			} /* if ( bulk && SamplesToWrite > 0 ) */
+			current_track++;
+
+		} /* left_in_track <= InSamples */
+		InSamples -= how_much;
+
+	}  /* end while */
+	if (!global.quiet && *nSamplesToDo != nSamplesDone) {
+		print_percentage(&oper, current_offset);
+	}
+	return nSamplesDone;
+}
+
+#define PRINT_OVERLAP_INIT \
+   if (global.verbose) { \
+	if (global.overlap > 0) \
+		fprintf(stderr, "overlap:min/max/cur, jitter, percent_done:\n  /  /  /          0%%"); \
+	else \
+		fputs("percent_done:\n  0%", stderr); \
+   }
+
+#if defined HAVE_FORK_AND_SHAREDMEM
+static void forked_read(void);
+
+/* This function does all audio cdrom reads
+ * until there is nothing more to do
+ */
+static void forked_read()
+{
+   unsigned total_unsuccessful_retries = 0;
+
+#if !defined(HAVE_SEMGET) || !defined(USE_SEMAPHORES)
+   init_child();
+#endif
+
+   minover = global.nsectors;
+
+   PRINT_OVERLAP_INIT
+   while (global.iloop) { 
+
+      do_read(get_next_buffer(), &total_unsuccessful_retries);
+
+      define_buffer();
+
+   } /* while (global.iloop) */
+
+   if (total_unsuccessful_retries) {
+      fprintf(stderr,"%u unsuccessful matches while reading\n",total_unsuccessful_retries);
+   }
+}
+
+static void forked_write(void);
+
+static void forked_write()
+{
+
+    /* don't need these anymore.  Good security policy says we get rid
+       of them ASAP */
+	priv_off();
+	neverneedroot();
+	neverneedgroup();
+
+#if defined(HAVE_SEMGET) && defined(USE_SEMAPHORES)
+#else
+    init_parent();
+#endif
+
+    for (;nSamplesDone < *nSamplesToDo;) {
+	if (*eorecording == 1 && (*total_segments_read) == (*total_segments_written)) break;
+
+	/* get oldest buffers */
+      
+	nSamplesDone = do_write(get_oldest_buffer());
+
+        drop_buffer();
+
+    } /* end for */
+
+}
+#endif
+
+/* This function implements the read and write calls in one loop (in case
+ * there is no fork/thread_create system call).
+ * This means reads and writes have to wait for each other to complete.
+ */
+static void nonforked_loop(void);
+
+static void nonforked_loop()
+{
+    unsigned total_unsuccessful_retries = 0;
+
+    minover = global.nsectors;
+
+    PRINT_OVERLAP_INIT
+    while (global.iloop) { 
+
+      do_read(get_next_buffer(), &total_unsuccessful_retries);
+
+      do_write(get_oldest_buffer());
+
+    }
+
+    if (total_unsuccessful_retries) {
+      fprintf(stderr,"%u unsuccessful matches while reading\n",total_unsuccessful_retries);
+    }
+
+}
+
+void verbose_usage(void);
+
+void verbose_usage()
+{
+	fputs("\
+	help		lists all verbose options.\n\
+	disable		disables verbose mode.\n\
+	all		enables all verbose options.\n\
+	toc		display the table of contents.\n\
+	summary		display a summary of track parameters.\n\
+	indices		retrieve/display index positions.\n\
+	catalog		retrieve/display media catalog number.\n\
+	trackid		retrieve/display international standard recording code.\n\
+	sectors		display the start sectors of each track.\n\
+	titles		display any known track titles.\n\
+", stderr);
+}
+
+#ifdef	USE_PARANOIA
+void paranoia_usage(void);
+
+void paranoia_usage()
+{
+	fputs("\
+	help		lists all paranoia options.\n\
+	disable		disables paranoia mode. Paranoia is still being used.\n\
+	no-verify	switches verify off, and overlap on.\n\
+	retries=amount	set the number of maximum retries per sector.\n\
+	overlap=amount	set the number of sectors used for statical paranoia overlap.\n\
+	minoverlap=amt	set the min. number of sectors used for dynamic paranoia overlap.\n\
+	maxoverlap=amt	set the max. number of sectors used for dynamic paranoia overlap.\n\
+", stderr);
+}
+#endif
+
+int
+handle_verbose_opts(char *optstr, long *flagp);
+
+int handle_verbose_opts(char *optstr, long *flagp)
+{
+	char	*ep;
+	char	*np;
+	int	optlen;
+
+	*flagp = 0;
+	while (*optstr) {
+		if ((ep = strchr(optstr, ',')) != NULL) {
+			optlen = ep - optstr;
+			np = ep + 1;
+		} else {
+			optlen = strlen(optstr);
+			np = optstr + optlen;
+		}
+		if (strncmp(optstr, "toc", optlen) == 0) {
+			*flagp |= SHOW_TOC;
+		}
+		else if (strncmp(optstr, "summary", optlen) == 0) {
+			*flagp |= SHOW_SUMMARY;
+		}
+		else if (strncmp(optstr, "indices", optlen) == 0) {
+			*flagp |= SHOW_INDICES;
+		}
+		else if (strncmp(optstr, "catalog", optlen) == 0) {
+			*flagp |= SHOW_MCN;
+		}
+		else if (strncmp(optstr, "trackid", optlen) == 0) {
+			*flagp |= SHOW_ISRC;
+		}
+		else if (strncmp(optstr, "sectors", optlen) == 0) {
+			*flagp |= SHOW_STARTPOSITIONS;
+		}
+		else if (strncmp(optstr, "titles", optlen) == 0) {
+			*flagp |= SHOW_TITLES;
+		}
+		else if (strncmp(optstr, "all", optlen) == 0) {
+			*flagp |= SHOW_MAX;
+		}
+		else if (strncmp(optstr, "disable", optlen) == 0) {
+			*flagp = 0;
+		}
+		else if (strncmp(optstr, "help", optlen) == 0) {
+			verbose_usage();
+			exit(NO_ERROR);
+		}
+		else {
+			char	*endptr;
+			unsigned arg = strtoul(optstr, &endptr, 10);
+			if (optstr != endptr
+				&& arg <= SHOW_MAX) {
+				*flagp |= arg;
+				fprintf(stderr, "Warning: numerical parameters for -v are no more supported in the next releases!\n");
+			}
+			else {
+				fprintf(stderr, "unknown option %s\n", optstr);
+				verbose_usage();
+				exit(SYNTAX_ERROR);
+			}
+		}
+		optstr = np;
+	}
+	return 1;
+}
+
+
+int
+handle_paranoia_opts(char *optstr, long *flagp);
+
+int handle_paranoia_opts(char *optstr, long *flagp)
+{
+#ifdef	USE_PARANOIA
+	char	*ep;
+	char	*np;
+	int	optlen;
+
+	while (*optstr) {
+		if ((ep = strchr(optstr, ',')) != NULL) {
+			optlen = ep - optstr;
+			np = ep + 1;
+		} else {
+			optlen = strlen(optstr);
+			np = optstr + optlen;
+		}
+		if (strncmp(optstr, "retries=", min(8,optlen)) == 0) {
+			char *eqp = strchr(optstr, '=');
+			int   rets;
+
+			astoi(eqp+1, &rets);
+			if (rets >= 0) {
+				global.paranoia_parms.retries = rets;
+			}
+		}
+		else if (strncmp(optstr, "overlap=", min(8, optlen)) == 0) {
+			char *eqp = strchr(optstr, '=');
+			int   rets;
+
+			astoi(eqp+1, &rets);
+			if (rets >= 0) {
+				global.paranoia_parms.overlap = rets;
+			}
+		}
+		else if (strncmp(optstr, "minoverlap=", min(11, optlen)) == 0) {
+			char *eqp = strchr(optstr, '=');
+			int   rets;
+
+			astoi(eqp+1, &rets);
+			if (rets >= 0) {
+				global.paranoia_parms.mindynoverlap = rets;
+			}
+		}
+		else if (strncmp(optstr, "maxoverlap=", min(11, optlen)) == 0) {
+			char *eqp = strchr(optstr, '=');
+			int   rets;
+
+			astoi(eqp+1, &rets);
+			if (rets >= 0) {
+				global.paranoia_parms.maxdynoverlap = rets;
+			}
+		}
+		else if (strncmp(optstr, "no-verify", optlen) == 0) {
+			global.paranoia_parms.disable_extra_paranoia = 1;
+		}
+		else if (strncmp(optstr, "disable", optlen) == 0) {
+			global.paranoia_parms.disable_paranoia = 1;
+		}
+		else if (strncmp(optstr, "help", optlen) == 0) {
+			paranoia_usage();
+			exit(NO_ERROR);
+		}
+		else {
+			fprintf(stderr, "unknown option %s\n", optstr);
+			paranoia_usage();
+			exit(SYNTAX_ERROR);
+		}
+		optstr = np;
+	}
+	return 1;
+#else
+	fputs("lib paranoia support is not configured!\n", stderr);
+	return 0;
+#endif
+}
+
+
+/* and finally: the MAIN program */
+int main(int argc, char *argv[])
+{
+  long lSector_p1;
+  long sector_offset = 0;
+  unsigned long endtrack = 1;
+  double rectime = DURATION;
+  int cd_index = -1;
+  double int_part;
+  int littleendian = -1;
+  char *int_name;
+  static char *user_sound_device = "";
+  char * env_p;
+  int tracks_included;
+	int	moreargs;
+
+  int_name = DEF_INTERFACE;
+  audio_type = AUDIOTYPE;
+  save_args(argc, argv);
+
+  /* init global variables */
+  init_globals();
+{
+  int am_i_cdda2wav;
+  /* When being invoked as list_audio_tracks, just dump a list of
+     audio tracks. */
+  am_i_cdda2wav = !(strlen(argv[0]) >= sizeof("list_audio_tracks")-1
+	&& !strcmp(argv[0]+strlen(argv[0])+1-sizeof("list_audio_tracks"),"list_audio_tracks"));
+  if (!am_i_cdda2wav) global.verbose = SHOW_JUSTAUDIOTRACKS;
+}
+  /* Control those set-id privileges... */
+  initsecurity();
+
+  env_p = getenv("CDDA_DEVICE");
+  if (env_p != NULL) {
+    global.dev_name = env_p;
+  }
+
+  env_p = getenv("CDDBP_SERVER");
+  if (env_p != NULL) {
+    global.cddbp_server = env_p;
+  }
+
+  env_p = getenv("CDDBP_PORT");
+  if (env_p != NULL) {
+    global.cddbp_port = env_p;
+  }
+
+{
+	int	cac;
+	char	*const*cav;
+
+	BOOL	version = FALSE;
+	BOOL	help = FALSE;
+	char	*channels = NULL;
+	int	irate = -1;
+	char	*divider = NULL;
+	char	*trackspec = NULL;
+	char	*duration = NULL;
+
+	char	*oendianess = NULL;
+	char	*cendianess = NULL;
+	int	cddbp = -1;
+	BOOL	stereo = FALSE;
+	BOOL	mono = FALSE;
+	BOOL	domax = FALSE;
+	BOOL	dump_rates = FALSE;
+	int	userverbose = -1;
+	long	paraopts = 0;
+
+	cac = argc;
+	cav = argv;
+	cac--;
+	cav++;
+	if (getargs(&cac, &cav, opts
+			, &global.paranoia_selected
+			, handle_paranoia_opts, &paraopts
+			, &version
+			, &help, &help
+
+			, &global.no_file, &global.no_file
+			, &dump_rates, &dump_rates
+			, &bulk, &bulk, &bulk
+			, &global.scsi_verbose, &global.scsi_verbose
+
+			, &global.findminmax, &global.findminmax
+			, &global.findmono, &global.findmono
+			, &global.no_infofile, &global.no_infofile
+
+			, &global.deemphasize, &global.deemphasize
+			, &global.just_the_toc, &global.just_the_toc
+			, &global.scsi_silent, &global.scsi_silent
+
+			, &global.cddbp_server, &global.cddbp_port
+			, &global.scanbus
+			, &global.scandevs
+			, &global.dev_name, &global.dev_name, &global.dev_name
+			, &global.aux_name, &global.aux_name
+			, &int_name, &int_name
+			, &audio_type, &audio_type
+
+			, &oendianess, &oendianess
+			, &cendianess, &cendianess
+			, &global.userspeed, &global.userspeed
+
+			, &global.playback_rate, &global.playback_rate
+			, &global.md5blocksize, &global.md5blocksize
+			, &global.useroverlap, &global.useroverlap
+			, &user_sound_device, &user_sound_device
+
+			, &cddbp, &cddbp
+			, &channels, &channels
+			, &bits, &bits
+			, &irate, &irate
+			, &global.gui, &global.gui
+
+			, &divider, &divider
+			, &trackspec, &trackspec
+			, &cd_index, &cd_index
+			, &duration, &duration
+			, &sector_offset, &sector_offset
+
+			, &global.nsectors, &global.nsectors
+			, handle_verbose_opts, &userverbose
+			, handle_verbose_opts, &userverbose
+			, &global.buffers, &global.buffers
+
+			, &stereo, &stereo
+			, &mono, &mono
+			, &waitforsignal, &waitforsignal
+			, &global.echo, &global.echo
+			, &global.quiet, &global.quiet
+			, &domax, &domax
+
+			) < 0) {
+		errmsgno(EX_BAD, "Bad Option: %s.\n", cav[0]);
+		fputs ("use 'icedax -help' to get more information.\n", stderr);
+		exit (SYNTAX_ERROR);
+	}
+	if (getfiles(&cac, &cav, opts) == 0)
+		/* No more file type arguments */;
+	moreargs = cav - argv;
+	if (version) {
+     fprintf(stderr, "icedax " CDRKIT_VERSION "\n");
+     exit(EXIT_SUCCESS);
+  }
+	if (help) {
+		usage();
+	}
+	if (!global.scanbus)
+		cdr_defaults(&global.dev_name, NULL, NULL, NULL); 
+	if (dump_rates) {	/* list available rates */
+		int ii;
+
+		fputs("\
+Available rates are:\n\
+Rate   Divider      Rate   Divider      Rate   Divider      Rate   Divider\n\
+"			, stderr );
+		for (ii = 1; ii <= 44100 / 880 / 2; ii++) {
+			long i2 = ii;
+			fprintf(stderr, "%7.1f  %2ld         %7.1f  %2ld.5       ",
+	        		44100.0/i2, i2, 44100.0/(i2+0.5), i2);
+			i2 += 25;
+			fprintf(stderr, "%7.1f  %2ld         %7.1f  %2ld.5\n",
+        			44100.0/i2, i2, 44100.0/(i2+0.5), i2);
+			i2 -= 25;
+		}
+		exit(NO_ERROR);
+	}
+	if (channels) {
+		if (*channels == 's') {
+			global.channels = 2;
+			global.swapchannels = 1;
+		} else {
+			global.channels = strtol(channels, NULL, 10);
+		}
+	}
+	if (irate >= 0) {
+		rate = irate;
+	}
+	if (divider) {
+		double divider_d;
+		divider_d = strtod(divider , NULL);
+		if (divider_d > 0.0) {
+			rate = 44100.0 / divider_d;
+		} else {
+			fputs("E option -divider requires a nonzero, positive argument.\nSee -dump-rates.", stderr);
+			exit(SYNTAX_ERROR);
+		}
+	}
+	if (trackspec) {
+		char * endptr;
+		char * endptr2;
+		track = strtoul(trackspec, &endptr, 10 );
+		endtrack = strtoul(endptr, &endptr2, 10 );
+		if (endptr2 == endptr) {
+			endtrack = track;
+		} else if (track == endtrack) {
+			bulk = -1;
+		}
+	}
+	if (duration) {
+		char *end_ptr = NULL;
+		rectime = strtod(duration, &end_ptr );
+		if (*end_ptr == 'f') {
+			rectime = rectime / 75.0;
+			/* TODO: add an absolute end of recording. */
+#if	0
+		} else if (*end_ptr == 'F') {
+			rectime = rectime / 75.0;
+#endif
+		} else if (*end_ptr != '\0') {
+			rectime = -1.0;
+		}
+	}
+	if (oendianess) {
+		if (strcasecmp(oendianess, "little") == 0) {
+			global.outputendianess = LITTLE;
+		} else if (strcasecmp(oendianess, "big") == 0) {
+			global.outputendianess = BIG;
+		} else {
+			usage2("wrong parameter '%s' for option -E", oendianess);
+		}
+	}
+	if (cendianess) {
+		if (strcasecmp(cendianess, "little") == 0) {
+			littleendian = 1;
+		} else if (strcasecmp(cendianess, "big") == 0) {
+			littleendian = 0;
+		} else if (strcasecmp(cendianess, "guess") == 0) {
+			littleendian = -2;
+		} else {
+			usage2("wrong parameter '%s' for option -C", cendianess);
+		}
+	}
+	if (cddbp >= 0) {
+		global.cddbp = 1 + cddbp;
+	}
+	if (stereo) {
+		global.channels = 2;
+	}
+	if (mono) {
+		global.channels = 1;
+        	global.need_hostorder = 1;
+	}
+	if (global.echo) {
+#ifdef	ECHO_TO_SOUNDCARD
+		if (global.playback_rate != 100) {
+		        RestrictPlaybackRate( global.playback_rate );
+		}
+       		global.need_hostorder = 1;
+#else
+		fprintf(stderr, "There is no sound support compiled into %s.\n",argv[0]);
+		global.echo = 0;
+#endif
+	}
+	if (global.quiet) {
+		global.verbose = 0;
+	}
+	if (domax) {
+		global.channels = 2; bits = 16; rate = 44100;
+	}
+	if (global.findminmax) {
+	        global.need_hostorder = 1;
+	}
+	if (global.deemphasize) {
+	        global.need_hostorder = 1;
+	}
+	if (global.just_the_toc) {
+		global.verbose = SHOW_MAX;
+		bulk = 1;
+	}
+	if (global.gui) {
+#ifdef	Thomas_will_es
+		global.no_file = 1;
+		global.no_infofile = 1;
+		global.verbose = SHOW_MAX;
+#endif
+		global.no_cddbfile = 1;
+	}
+	if (global.no_file) {
+		global.no_infofile = 1;
+		global.no_cddbfile = 1;
+	}
+	if (global.no_infofile) {
+		global.no_cddbfile = 1;
+	}
+	if (global.md5blocksize) {
+#ifdef	MD5_SIGNATURES
+		fputs("MD5 signatures are currently broken! Sorry\n", stderr);
+#else
+		fputs("MD5 signatures are currently broken! Sorry\n", stderr);
+#endif
+	}
+	if (user_sound_device) {
+#ifndef	ECHO_TO_SOUNDCARD
+		fputs("There is no sound support configured!\n", stderr);
+#endif
+	}
+	if (global.paranoia_selected) {
+		global.useroverlap = 0;
+	}
+	if (userverbose >= 0) {
+		global.verbose = userverbose;
+	}
+}
+
+  /* check all parameters */
+  if (global.buffers < 1) {
+    usage2("Incorrect buffer setting: %d", global.buffers);
+  }
+
+  if (global.nsectors < 1) {
+    usage2("Incorrect nsectors setting: %d", global.nsectors);
+  }
+
+  if (global.verbose < 0 || global.verbose > SHOW_MAX) {
+    usage2("Incorrect verbose level setting: %d",global.verbose);
+  }
+  if (global.verbose == 0) global.quiet = 1;
+
+  if ( rectime < 0.0 ) {
+    usage2("Incorrect recording time setting: %d.%02d",
+			(int)rectime, (int)(rectime*100+0.5) % 100);
+  }
+
+  if ( global.channels != 1 && global.channels != 2 ) {
+    usage2("Incorrect channel setting: %d",global.channels);
+  }
+
+  if ( bits != 8 && bits != 12 && bits != 16 ) {
+    usage2("Incorrect bits_per_sample setting: %d",bits);
+  }
+
+  if ( rate < 827.0 || rate > 44100.0 ) {
+    usage2("Incorrect sample rate setting: %d.%02d",
+	(int)rate, ((int)rate*100) % 100);
+  }
+
+  int_part = (double)(long) (2*44100.0 / rate);
+  
+  if (2*44100.0 / rate - int_part >= 0.5 ) {
+      int_part += 1.0;
+      fprintf( stderr, "Nearest available sample rate is %d.%02d Hertz\n",
+	      2*44100 / (int)int_part,
+	      (2*4410000 / (int)int_part) % 100);
+  }
+  Halved = ((int) int_part) & 1;
+  rate = 2*44100.0 / int_part;
+  undersampling = (int) int_part / 2.0;
+  samples_to_do = undersampling;
+
+  if (!strcmp((char *)int_name,"generic_scsi"))
+      interface = GENERIC_SCSI;
+  else if (!strcmp((char *)int_name,"cooked_ioctl"))
+      interface = COOKED_IOCTL;
+  else  {
+    usage2("Incorrect interface setting: %s",int_name);
+  }
+
+  /* check * init audio file */
+  if (!strncmp(audio_type,"wav",3)) {
+    global.audio_out = &wavsound;
+  } else if (!strncmp(audio_type, "sun", 3) || !strncmp(audio_type, "au", 2)) {
+    /* Enhanced compatibility */
+    audio_type = "au";
+    global.audio_out = &sunsound;
+  } else if (!strncmp(audio_type, "cdr", 3) || 
+             !strncmp(audio_type, "raw", 3)) {
+    global.audio_out = &rawsound;
+  } else if (!strncmp(audio_type, "aiff", 4)) {
+    global.audio_out = &aiffsound;
+  } else if (!strncmp(audio_type, "aifc", 4)) {
+    global.audio_out = &aifcsound;
+#ifdef USE_LAME
+  } else if (!strncmp(audio_type, "mp3", 3)) {
+    global.audio_out = &mp3sound;
+    if (!global.quiet) {
+	unsigned char Lame_version[20];
+
+	fetch_lame_version(Lame_version);
+	fprintf(stderr, "Using LAME version %s.\n", Lame_version);
+    }
+    if (bits < 9) {
+	bits = 16;
+	fprintf(stderr, "Warning: sample size forced to 16 bit for MP3 format.\n");
+    }
+#endif /* USE_LAME */
+  } else {
+    usage2("Incorrect audio type setting: %3s", audio_type);
+  }
+
+  if (bulk == -1) bulk = 0;
+
+  global.need_big_endian = global.audio_out->need_big_endian;
+  if (global.outputendianess != NONE)
+    global.need_big_endian = global.outputendianess == BIG;
+
+  if (global.no_file) global.fname_base[0] = '\0';
+
+  if (!bulk) {
+    strcat(global.fname_base, ".");
+    strcat(global.fname_base, audio_type);
+  }
+
+  /* If we need to calculate with samples or write them to a soundcard,
+   * we need a conversion to host byte order.
+   */ 
+  if (global.channels != 2 
+      || bits != 16
+      || rate != 44100)
+	global.need_hostorder = 1;
+
+  /* Bad hack!!
+   * Remove for release 2.0
+   * this is a bug compatibility feature.
+   */
+  if (global.gui && global.verbose == SHOW_TOC)
+	global.verbose |= SHOW_STARTPOSITIONS | SHOW_SUMMARY | SHOW_TITLES;
+
+  /*
+   * all options processed.
+   * Now a file name per track may follow 
+   */
+  argc2 = argc3 = argc - moreargs;
+  argv2 = argv + moreargs;
+  if ( moreargs < argc ) {
+    if (!strcmp(argv[moreargs],"-")) {
+#ifdef	NEED_O_BINARY
+      setmode(fileno(stdout), O_BINARY);
+#endif
+      global.audio = dup (fileno(stdout));
+      strncpy( global.fname_base, "standard_output", sizeof(global.fname_base) );
+      global.fname_base[sizeof(global.fname_base)-1]=0;
+    } else if (!is_fifo(argv[moreargs])) {
+	/* we do have at least one argument */
+	global.multiname = 1;
+    }
+  }
+
+#define SETSIGHAND(PROC, SIG, SIGNAME) if (signal(SIG, PROC) == SIG_ERR) \
+	{ fprintf(stderr, "cannot set signal %s handler\n", SIGNAME); exit(SETSIG_ERROR); }
+    SETSIGHAND(exit_wrapper, SIGINT, "SIGINT")
+    SETSIGHAND(exit_wrapper, SIGQUIT, "SIGQUIT")
+    SETSIGHAND(exit_wrapper, SIGTERM, "SIGTERM")
+    SETSIGHAND(exit_wrapper, SIGHUP, "SIGHUP")
+
+    SETSIGHAND(set_nonforked, SIGPIPE, "SIGPIPE")
+
+  /* setup interface and open cdrom device */
+  /* request sychronization facilities and shared memory */
+  SetupInterface( );
+
+  /* use global.useroverlap to set our overlap */
+  if (global.useroverlap != -1)
+	global.overlap = global.useroverlap;
+
+  /* check for more valid option combinations */
+
+  if (global.nsectors < 1+global.overlap) {
+	fprintf( stderr, "Warning: Setting #nsectors to minimum of %d, due to jitter correction!\n", global.overlap+1);
+	  global.nsectors = global.overlap+1;
+  }
+
+  if (global.overlap > 0 && global.buffers < 2) {
+	fprintf( stderr, "Warning: Setting #buffers to minimum of 2, due to jitter correction!\n");
+	  global.buffers = 2;
+  }
+
+    /* Value of 'nsectors' must be defined here */
+
+    global.shmsize = 0;
+#ifdef	USE_PARANOIA
+    while (global.shmsize < sizeof (struct paranoia_statistics))
+		global.shmsize += global.pagesize;
+#endif
+    global.shmsize += 10*global.pagesize;	/* XXX Der Speicherfehler ist nicht in libparanoia sondern in cdda2wav :-( */
+    global.shmsize += HEADER_SIZE + ENTRY_SIZE_PAGE_AL * global.buffers;
+
+#if	defined (HAVE_FORK_AND_SHAREDMEM)
+	/*
+	 * The (void *) cast is to avoid a GCC warning like:
+	 * warning: dereferencing type-punned pointer will break strict-aliasing rules
+	 * which does not apply to this code. (void *) introduces a compatible
+	 * intermediate type in the cast list.
+	 */
+    he_fill_buffer = request_shm_sem(global.shmsize, (unsigned char **)(void *)&he_fill_buffer);
+    if (he_fill_buffer == NULL) {
+	fprintf( stderr, "no shared memory available!\n");
+	exit(SHMMEM_ERROR);
+    }
+#else /* do not have fork() and shared memory */
+    he_fill_buffer = malloc(global.shmsize);
+    if (he_fill_buffer == NULL) {
+	fprintf( stderr, "no buffer memory available!\n");
+	exit(NOMEM_ERROR);
+    }
+#endif
+#ifdef	USE_PARANOIA
+    {
+	int	i = 0;
+
+	para_stat = (struct paranoia_statistics *)he_fill_buffer;
+	while (i < sizeof (struct paranoia_statistics)) {
+			i += global.pagesize;
+			he_fill_buffer += global.pagesize;
+			global.shmsize -= global.pagesize;
+	}
+    }
+#endif
+
+    if (global.verbose != 0)
+   	 fprintf(stderr,
+   		 "%u bytes buffer memory requested, %d buffers, %d sectors\n",
+   		 global.shmsize, global.buffers, global.nsectors);
+
+    /* initialize pointers into shared memory segment */
+    last_buffer = he_fill_buffer + 1;
+    total_segments_read = (unsigned long *) (last_buffer + 1);
+    total_segments_written = total_segments_read + 1;
+    child_waits = (int *) (total_segments_written + 1);
+    parent_waits = child_waits + 1;
+    in_lendian = parent_waits + 1;
+    eorecording = in_lendian + 1;
+    *total_segments_read = *total_segments_written = 0;
+    nSamplesToDo = (unsigned long *)(eorecording + 1);
+    *eorecording = 0;
+    *in_lendian = global.in_lendian;
+
+    set_total_buffers(global.buffers, sem_id);
+
+
+#if defined(HAVE_SEMGET) && defined(USE_SEMAPHORES)
+  atexit ( free_sem );
+#endif
+
+  /*
+   * set input endian default
+   */
+  if (littleendian != -1)
+    *in_lendian = littleendian;
+
+  /* get table of contents */
+  cdtracks = ReadToc();
+  if (cdtracks == 0) {
+    fprintf(stderr, "No track in table of contents! Aborting...\n");
+    exit(MEDIA_ERROR);
+  }
+
+  calc_cddb_id();
+  calc_cdindex_id();
+
+#if	1
+  Check_Toc();
+#endif
+
+  if (ReadTocText != NULL && FirstAudioTrack () != -1) {
+	ReadTocText(get_scsi_p());
+	handle_cdtext();
+  }
+  if ( global.verbose == SHOW_JUSTAUDIOTRACKS ) {
+    unsigned int z;
+
+    for (z = 0; z < cdtracks; z++)
+	if (Get_Datatrack(z) == 0)
+	  printf("%02d\t%06ld\n", Get_Tracknumber(z), Get_AudioStartSector(z));
+    exit(NO_ERROR);
+  }
+
+  if ( global.verbose != 0 ) {
+    fputs( "#icedax version ", stderr );
+    fputs( VERSION, stderr );
+#if defined USE_POSIX_PRIORITY_SCHEDULING || defined HAVE_SYS_PRIOCNTL_H
+    fputs( ", real time sched.", stderr );
+#endif
+#if defined ECHO_TO_SOUNDCARD
+    fputs( ", soundcard", stderr );
+#endif
+#if defined USE_PARANOIA
+    fputs( ", libparanoia", stderr );
+#endif
+    fputs( " support\n", stderr );
+  }
+
+  FixupTOC(cdtracks + 1);
+
+#if	0
+  if (!global.paranoia_selected) {
+    fprintf(stderr, "NICE\n");
+    /* try to get some extra kicks */
+    priv_on();
+    needroot(0);
+#if defined HAVE_SETPRIORITY
+    setpriority(PRIO_PROCESS, 0, -20);
+#else
+# if defined(HAVE_NICE) && (HAVE_NICE == 1)
+    nice(-20);
+# endif
+#endif
+    priv_off();
+    dontneedroot();
+  }
+#endif
+
+  /* switch cdrom to audio mode */
+  EnableCdda (get_scsi_p(), 1, CD_FRAMESIZE_RAW);
+
+  atexit ( CloseAll );
+
+  DisplayToc();
+  if ( FirstAudioTrack () == -1 ) {
+    if (no_disguised_audiotracks()) {
+      FatalError ( "This disk has no audio tracks\n" );
+    }
+  }
+
+  Read_MCN_ISRC();
+
+  /* check if start track is in range */
+  if ( track < 1 || track > cdtracks ) {
+    usage2("Incorrect start track setting: %d",track);
+  }
+
+  /* check if end track is in range */
+  if ( endtrack < track || endtrack > cdtracks ) {
+    usage2("Incorrect end track setting: %ld",endtrack);
+  }
+
+  do {
+    lSector = Get_AudioStartSector ( track );
+    lSector_p1 = Get_EndSector ( track ) + 1;
+
+    if ( lSector < 0 ) {
+      if ( bulk == 0 ) {
+        FatalError ( "Track %d not found\n", track );
+      } else {
+        fprintf(stderr, "Skipping data track %d...\n", track);
+	if (endtrack == track) endtrack++;
+        track++;
+      }
+    }
+  } while (bulk != 0 && track <= cdtracks && lSector < 0);
+
+  if ((global.illleadout_cd == 0 || global.reads_illleadout != 0) && cd_index != -1) {
+    if (global.verbose && !global.quiet) {
+      global.verbose |= SHOW_INDICES;
+    }
+    sector_offset += ScanIndices( track, cd_index, bulk );
+  } else {
+    cd_index = 1;
+    if (global.deemphasize || (global.verbose & SHOW_INDICES)) {
+      ScanIndices( track, cd_index, bulk );
+    }
+  }
+
+  lSector += sector_offset;
+  /* check against end sector of track */
+  if ( lSector >= lSector_p1 ) {
+    fprintf(stderr, "W Sector offset %lu exceeds track size (ignored)\n", sector_offset );
+    lSector -= sector_offset;
+  }
+
+  if ( lSector < 0L ) {
+    fputs( "Negative start sector! Set to zero.\n", stderr );
+    lSector = 0L;
+  }
+
+  lSector_p2 = Get_LastSectorOnCd( track );
+  if (bulk == 1 && track == endtrack && rectime == 0.0)
+     rectime = 99999.0;
+  if ( rectime == 0.0 ) {
+    /* set time to track time */
+    *nSamplesToDo = (lSector_p1 - lSector) * CD_FRAMESAMPLES;
+    rectime = (lSector_p1 - lSector) / 75.0;
+    if (CheckTrackrange( track, endtrack) == 1) {
+      lSector_p2 = Get_EndSector ( endtrack ) + 1;
+
+      if (lSector_p2 >= 0) {
+        rectime = (lSector_p2 - lSector) / 75.0;
+        *nSamplesToDo = (long)(rectime*44100.0 + 0.5);
+      } else {
+        fputs( "End track is no valid audio track (ignored)\n", stderr );
+      }
+    } else {
+      fputs( "Track range does not consist of audio tracks only (ignored)\n", stderr );
+    }
+  } else {
+    /* Prepare the maximum recording duration.
+     * It is defined as the biggest amount of
+     * adjacent audio sectors beginning with the
+     * specified track/index/offset. */
+
+    if ( rectime > (lSector_p2 - lSector) / 75.0 ) {
+      rectime = (lSector_p2 - lSector) / 75.0;
+      lSector_p1 = lSector_p2;
+    }
+
+    /* calculate # of samples to read */
+    *nSamplesToDo = (long)(rectime*44100.0 + 0.5);
+  }
+
+  global.OutSampleSize = (1+bits/12);
+  if (*nSamplesToDo/undersampling == 0L) {
+      usage2("Time interval is too short. Choose a duration greater than %d.%02d secs!", 
+	       undersampling/44100, (int)(undersampling/44100) % 100);
+  }
+  if ( moreargs < argc ) {
+    if (!strcmp(argv[moreargs],"-") || is_fifo(argv[moreargs])) {
+      /*
+       * pipe mode
+       */
+      if (bulk == 1) {
+        fprintf(stderr, "W Bulk mode is disabled while outputting to a %spipe\n",
+		is_fifo(argv[moreargs]) ? "named " : "");
+        bulk = 0;
+      }
+      global.no_cddbfile = 1;
+    }
+  }
+  if (global.no_infofile == 0) {
+    global.no_infofile = 1;
+    if (global.channels == 1 || bits != 16 || rate != 44100) {
+      fprintf(stderr, "W Sample conversions disable generation of info files!\n");
+    } else if (waitforsignal == 1) {
+      fprintf(stderr, "W Option -w 'wait for signal' disables generation of info files!\n");
+    } else if (sector_offset != 0) {
+      fprintf(stderr, "W Using an start offset (option -o) disables generation of info files!\n");
+    } else if (!bulk &&
+      !((lSector == Get_AudioStartSector(track)) &&
+        ((long)(lSector + rectime*75.0 + 0.5) == Get_EndSector(track) + 1))) {
+      fprintf(stderr, "W Duration is not set for complete tracks (option -d), this disables generation\n  of info files!\n");
+    } else {
+      global.no_infofile = 0;
+    }
+  }
+
+  SamplesToWrite = *nSamplesToDo*2/(int)int_part;
+
+  {
+	int first = FirstAudioTrack();
+	tracks_included = Get_Track(
+	      (unsigned) (lSector + *nSamplesToDo/CD_FRAMESAMPLES -1))
+				     - max((int)track,first) +1;
+  }
+
+  if (global.multiname != 0 && moreargs + tracks_included > argc) {
+	global.multiname = 0;
+  }
+
+  if ( !waitforsignal ) {
+
+#ifdef INFOFILES
+      if (!global.no_infofile) {
+	int i;
+
+	for (i = track; i < (int)track + tracks_included; i++) {
+		unsigned minsec, maxsec;
+	        char *tmp_fname;
+
+	        /* build next filename */
+
+	        tmp_fname = get_next_name();
+	        if (tmp_fname != NULL)
+		  strncpy( global.fname_base, tmp_fname, sizeof(global.fname_base)-8 );
+ 		global.fname_base[sizeof(global.fname_base)-1]=0;
+		minsec = max(lSector, Get_AudioStartSector(i));
+		maxsec = min(lSector + rectime*75.0 + 0.5, 1+Get_EndSector(i));
+		if ((int)minsec == Get_AudioStartSector(i) &&
+		    (int)maxsec == 1+Get_EndSector(i)) {
+			write_info_file(global.fname_base,i,(maxsec-minsec)*CD_FRAMESAMPLES, bulk && global.multiname == 0);
+		} else {
+			fprintf(stderr,
+				 "Partial length copy for track %d, no info file will be generated for this track!\n", i);
+		}
+		if (!bulk) break;
+	}
+	reset_name_iterator();
+      }
+#endif
+
+  }
+
+  if (global.just_the_toc) exit(NO_ERROR);
+
+#ifdef  ECHO_TO_SOUNDCARD
+  if (user_sound_device[0] != '\0') {
+      set_snd_device(user_sound_device);
+  }
+  init_soundcard(rate, bits);
+#endif /* ECHO_TO_SOUNDCARD */
+
+  if (global.userspeed > -1)
+     global.speed = global.userspeed;
+
+  if (global.speed != 0 && SelectSpeed != NULL) {
+     SelectSpeed(get_scsi_p(), global.speed);
+  }
+
+  current_track = track;
+
+  if ( !global.no_file ) {
+    {
+      char *myfname;
+
+      myfname = get_next_name();
+
+      if (myfname != NULL) {
+        strncpy( global.fname_base, myfname, sizeof(global.fname_base)-8 );
+        global.fname_base[sizeof(global.fname_base)-1]=0;
+      }
+    }
+
+    /* strip audio_type extension */
+    {
+      char *cp = global.fname_base;
+
+      cp = strrchr(cp, '.');
+      if (cp == NULL) {
+	cp = global.fname_base + strlen(global.fname_base);
+      }
+      *cp = '\0';
+    }
+    if (bulk && global.multiname == 0) {
+      sprintf(fname, "%s_%02u.%s",global.fname_base,current_track,audio_type);
+    } else {
+      sprintf(fname, "%s.%s",global.fname_base,audio_type);
+    }
+
+    OpenAudio( fname, rate, bits, global.channels, 
+	      (unsigned)(SamplesToWrite*global.OutSampleSize*global.channels),
+		global.audio_out);
+  }
+
+  global.Remainder = (75 % global.nsectors)+1;
+
+  global.sh_bits = 16 - bits;		/* shift counter */
+
+  global.iloop = *nSamplesToDo;
+  if (Halved && (global.iloop&1))
+      global.iloop += 2;
+
+  BeginAtSample = lSector * CD_FRAMESAMPLES;
+
+#if	1
+	if ( (global.verbose & SHOW_SUMMARY) && !global.just_the_toc &&
+	     (global.reads_illleadout == 0 ||
+	      lSector+*nSamplesToDo/CD_FRAMESAMPLES
+	       <= (unsigned) Get_AudioStartSector(cdtracks-1))) {
+
+		fprintf(stderr, "samplefile size will be %lu bytes.\n",
+			global.audio_out->GetHdrSize() +
+			global.audio_out->InSizeToOutSize(SamplesToWrite*global.OutSampleSize*global.channels)  ); 
+		fprintf (stderr, "recording %d.%04d seconds %s with %d bits @ %5d.%01d Hz"
+			,(int)rectime , (int)(rectime * 10000) % 10000,
+			global.channels == 1 ? "mono":"stereo", bits, (int)rate, (int)(rate*10)%10);
+		if (!global.no_file && *global.fname_base)
+			fprintf(stderr, " ->'%s'...", global.fname_base );
+		fputs("\n", stderr);
+	}
+#endif
+
+#if defined(HAVE_SEMGET) && defined(USE_SEMAPHORES)
+#else
+	init_pipes();
+#endif
+
+#ifdef	USE_PARANOIA
+	if (global.paranoia_selected) {
+		long paranoia_mode;
+
+		global.cdp = paranoia_init(get_scsi_p(), global.nsectors);
+
+		if (global.paranoia_parms.overlap >= 0) {
+			int	overlap = global.paranoia_parms.overlap;
+
+			if (overlap > global.nsectors - 1) 
+				overlap = global.nsectors - 1;
+			paranoia_overlapset(global.cdp, overlap);
+		}
+		/*
+		 * Default to a  minimum of dynamic overlapping == 0.5 sectors.
+		 * If we don't do this, we get the default from libparanoia
+		 * which is approx. 0.1.
+		 */
+		if (global.paranoia_parms.mindynoverlap < 0)
+			paranoia_dynoverlapset(global.cdp, CD_FRAMEWORDS/2, -1);
+		paranoia_dynoverlapset(global.cdp,
+			global.paranoia_parms.mindynoverlap * CD_FRAMEWORDS,
+			global.paranoia_parms.maxdynoverlap * CD_FRAMEWORDS);
+
+		paranoia_mode = PARANOIA_MODE_FULL ^ PARANOIA_MODE_NEVERSKIP;
+
+		if (global.paranoia_parms.disable_paranoia) {
+			paranoia_mode = PARANOIA_MODE_DISABLE;
+		}
+		if (global.paranoia_parms.disable_extra_paranoia) {
+			paranoia_mode |= PARANOIA_MODE_OVERLAP;
+			paranoia_mode &= ~PARANOIA_MODE_VERIFY;
+		}
+		/* not yet implemented */
+		if (global.paranoia_parms.disable_scratch_detect) {
+			paranoia_mode &= ~(PARANOIA_MODE_SCRATCH|PARANOIA_MODE_REPAIR);
+		}
+		/* not yet implemented */
+		if (global.paranoia_parms.disable_scratch_repair) {
+			paranoia_mode &= ~PARANOIA_MODE_REPAIR;
+		}
+
+		paranoia_modeset(global.cdp, paranoia_mode);
+		if (global.verbose)
+			fprintf(stderr, "using lib paranoia for reading.\n");
+		paranoia_seek(global.cdp, lSector, SEEK_SET);
+		paranoia_reset();
+	}
+#endif
+#if defined(HAVE_FORK_AND_SHAREDMEM)
+
+	/* Everything is set up. Now fork and let one process read cdda sectors
+	   and let the other one store them in a wav file */
+
+	/* forking */
+	child_pid = fork();
+	if (child_pid > 0 && global.gui > 0 && global.verbose > 0)
+		fprintf( stderr, "child pid is %d\n", child_pid);
+
+	/*********************** fork **************************************/
+	if (child_pid == 0) {
+		/* child WRITER section */
+
+#ifdef	HAVE_AREAS
+		/* Under BeOS a fork() with shared memory does not work as
+		 * it does under System V Rel. 4. The mapping of the child
+		 * works with copy on write semantics, so changes do not propagate
+		 * back and forth. The existing mapping has to be deleted
+		 * and replaced by an clone without copy on write semantics.
+		 * This is done with clone_area(...,B_CLONE_ADDRESS,...).
+		 * Thanks to file support.c from the postgreSQL project.
+		 */
+		area_info inf;
+		int32 cook = 0;
+		/* iterate over all mappings to find our shared memory mapping. */
+		while (get_next_area_info(0, &cook, &inf) == B_OK)
+		{
+			/* check the name of the mapping. */
+			if (!strcmp(inf.name, AREA_NAME))
+			{
+				void *area_address;
+				area_id area_parent;
+
+				/* kill the cow mapping. */
+				area_address = inf.address;
+				if (B_OK != delete_area(inf.area))
+				{
+					fprintf(stderr, "delete_area: no valid area.\n");
+					exit(SHMMEM_ERROR);
+				}
+				/* get the parent mapping. */
+				area_parent = find_area(inf.name);
+				if (area_parent == B_NAME_NOT_FOUND)
+				{
+					fprintf(stderr, "find_area: no such area name.\n");
+					exit(SHMMEM_ERROR);
+				}
+				/* clone the parent mapping without cow. */
+				if (B_OK > clone_area("shm_child", &area_address, B_CLONE_ADDRESS,
+					B_READ_AREA | B_WRITE_AREA, area_parent))
+				{
+					fprintf(stderr,"clone_area failed\n");
+					exit(SHMMEM_ERROR);
+				}
+			}
+		}
+#endif
+#ifdef	__EMX__
+		if (DosGetSharedMem(he_fill_buffer, 3)) {
+			comerr("DosGetSharedMem() failed.\n");
+		}
+#endif
+		global.have_forked = 1;
+		forked_write();
+#ifdef	__EMX__
+		DosFreeMem(he_fill_buffer);
+		_exit(NO_ERROR);
+		/* NOTREACHED */
+#endif
+		exit_wrapper(NO_ERROR);
+		/* NOTREACHED */
+	} else if (child_pid > 0) {
+		/* parent READER section */
+    
+		global.have_forked = 1;
+		switch_to_realtime_priority();
+
+		forked_read();
+#ifdef	HAVE_AREAS
+		{
+			area_id aid;
+			aid = find_area(AREA_NAME);
+			if (aid < B_OK) {
+				comerrno(aid, "find_area() failed.\n");
+			}
+			delete_area(aid);
+		}
+#endif
+#ifdef	__EMX__
+		DosFreeMem(he_fill_buffer);
+#endif
+		exit_wrapper(NO_ERROR);
+		/* NOTREACHED */
+	} else
+		perror("fork error.");
+
+#endif
+	/* version without fork */
+	{
+		global.have_forked = 0;
+#if	0
+		if (!global.paranoia_selected) {
+			fprintf(stderr, "REAL\n");
+			switch_to_realtime_priority();
+		}
+#endif
+		fprintf(stderr, "a nonforking version is running...\n");
+		nonforked_loop();
+		exit_wrapper(NO_ERROR);
+		/* NOTREACHED */
+	}
+#ifdef	USE_PARANOIA
+	if (global.paranoia_selected)
+		paranoia_free(global.cdp);
+#endif
+
+	return 0;
+}