开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
cdda2wav.c
资源名称：cdrecord-1.8.tar.gz　[点击查看]
上传用户：xiejiait
上传日期：2007-01-06
资源大小：881k
文件大小：62k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

cdda2wav.c：源码内容
  1. /* @(#)cdda2wav.c 1.6 00/01/11 Copyright 1998,1999,2000 Heiko Eissfeldt */
  2. #ifndef lint
  3. static char     sccsid[] =
  4. "@(#)cdda2wav.c 1.6 00/01/11 Copyright 1998,1999,2000 Heiko Eissfeldt";
  6. #endif
  7. #undef DEBUG_BUFFER_ADDRESSES
  8. #undef GPROF
  9. #undef DEBUG_FORKED
  10. #undef DEBUG_CLEANUP
  11. #undef DEBUG_DYN_OVERLAP
  12. #undef DEBUG_READS
  13. /*
  14.  * Copyright: GNU Public License 2 applies
  15.  *
  16.  *   This program is free software; you can redistribute it and/or modify
  17.  *   it under the terms of the GNU General Public License as published by
  18.  *   the Free Software Foundation; either version 2, or (at your option)
  19.  *   any later version.
  20.  *
  21.  *   This program is distributed in the hope that it will be useful,
  22.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24.  *   GNU General Public License for more details.
  25.  *
  26.  *   You should have received a copy of the GNU General Public License
  27.  *   along with this program; if not, write to the Free Software
  28.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29.  *
  30.  * CDDA2WAV (C) 1995-1998 Heiko Eissfeldt heiko@colossus.escape.de
  31.  * parts    (C) Peter Widow
  32.  * parts    (C) Thomas Niederreiter
  33.  * parts    (C) RSA Data Security, Inc.
  34.  *
  35.  * last changes:
  36.  *   18.12.93 - first version, OK
  37.  *   01.01.94 - generalized & clean up HE
  38.  *   10.06.94 - first linux version HE
  39.  *   12.06.94 - wav header alignment problem fixed HE
  40.  *   12.08.94 - open the cdrom device O_RDONLY makes more sense :-)
  41.  * no more floating point math
  42.  * change to sector size 2352 which is more common
  43.  * sub-q-channel information per kernel ioctl requested
  44.  * doesn't work as well as before
  45.  * some new options (-max -i)
  46.  *   01.02.95 - async i/o via semaphores and shared memory
  47.  *   03.02.95 - overlapped reading on sectors
  48.  *   03.02.95 - generalized sample rates. all integral divisors are legal
  49.  *   04.02.95 - sun format added
  50.  *              more divisors: all integral halves >= 1 allowed
  51.  * floating point math needed again
  52.  *   06.02.95 - bugfix for last track and not d0
  53.  *              tested with photo-cd with audio tracks
  54.  * tested with xa disk 
  55.  *   29.01.96 - new options for bulk transfer
  56.  *   01.06.96 - tested with enhanced cd
  57.  *   01.06.96 - tested with cd-plus
  58.  *   02.06.96 - support pipes
  59.  *   02.06.96 - support raw format
  60.  *   04.02.96 - security hole fixed
  61.  *   22.04.97 - large parts rewritten
  62.  *   28.04.97 - make file names DOS compatible
  63.  *   01.09.97 - add speed control
  64.  *   20.10.97 - add find mono option
  65.  *   Jan/Feb 98 - conversion to use Joerg Schillings SCSI library
  66.  *
  67.  */
  69. #include "config.h"
  71. #if defined (HAVE_UNISTD_H) && (HAVE_UNISTD_H == 1)
  72. #include <sys/types.h>
  73. #include <unistd.h>
  74. #endif
  76. #include <stdio.h>
  77. #include <standard.h>
  78. #include <stdlib.h>
  79. #include <strdefs.h>
  80. #if defined HAVE_STRINGS_H
  81. #include <strings.h>
  82. #endif
  83. #include <signal.h>
  84. #include <math.h>
  85. #include <fctldefs.h>
  86. #include <time.h>
  87. #if (defined (HAVE_SYS_TIME_H) || (HAVE_SYS_TIME_H != 1)) && defined (TIME_WITH_SYS_TIME)
  88. #include <sys/time.h>
  89. #endif
  90. #if defined (HAVE_LIMITS_H) && (HAVE_LIMITS_H == 1)
  91. #include <limits.h>
  92. #endif
  93. #if defined (HAVE_SYS_IOCTL_H) && (HAVE_SYS_IOCTL_H == 1)
  94. #include <sys/ioctl.h>
  95. #endif
  97. #if defined (HAVE_SYS_WAIT_H) && (HAVE_SYS_WAIT_H == 1)
  98. #include <sys/wait.h>
  99. #endif
  100. #include <vadefs.h>
  102. #include <standard.h>
  103. #include <scg/scsitransp.h>
  104. #include "mytype.h"
  105. #include "sndconfig.h"
  107. #include "semshm.h" /* semaphore functions */
  108. #include "sndfile.h"
  109. #include "wav.h" /* wav file header structures */
  110. #include "sun.h" /* sun audio file header structures */
  111. #include "raw.h" /* raw file handling */
  112. #include "aiff.h" /* aiff file handling */
  113. #include "aifc.h" /* aifc file handling */
  114. #include "interface.h"  /* low level cdrom interfacing */
  115. #include "cdda2wav.h"
  116. #include "resample.h"
  117. #include "toc.h"
  118. #include "setuid.h"
  119. #include "ringbuff.h"
  120. #include "global.h"
  123. static const char * optstring = "D:A:I:O:c:b:r:a:t:i:d:o:n:v:l:E:C:S:p:M:P:K:smweNqxRBVhFGHTJgQ";
  125. extern char *optarg;
  126. extern int optind, opterr, optopt;
  128. int main __PR((int argc, char **argv));
  129. static void RestrictPlaybackRate __PR((long newrate));
  130. static void output_indices __PR((FILE *fp, index_list *p, unsigned trackstart));
  131. static int write_info_file __PR((char *fname_baseval, unsigned int track, unsigned long SamplesDone, int numbered));
  132. static void CloseAudio __PR((char *fname_baseval, unsigned int track, int bulkflag, int channels_val, unsigned long nSamples, struct soundfile *audio_out));
  133. static void CloseAll __PR((void));
  134. static void OpenAudio __PR((char *fname, double rate, long nBitsPerSample, long channels_val, unsigned long expected_bytes, struct soundfile*audio_out));
  135. static void set_offset __PR((myringbuff *p, int offset));
  136. static int get_offset __PR((myringbuff *p));
  137. static void usage __PR((void));
  138. static void init_globals __PR((void));
  140. #if defined (__GLIBC__) || defined(_GNU_C_SOURCE) || defined(__USE_GNU) || defined(__CYGWIN32__)
  141. #define USE_GETOPT_LONG
  142. #endif
  144. #ifdef USE_GETOPT_LONG
  145. #include <getopt.h> /* for get_long_opt () */
  146. static struct option options [] = {
  147. {"device",required_argument,NULL,'D'},
  148. {"auxdevice",required_argument,NULL,'A'},
  149. {"interface",required_argument,NULL,'I'},
  150. {"output-format",required_argument,NULL,'O'},
  151. {"channels",required_argument,NULL,'c'},
  152. {"bits-per-sample",required_argument,NULL,'b'},
  153. {"rate",required_argument,NULL,'r'},
  154. {"divider",required_argument,NULL,'a'},
  155. {"track",required_argument,NULL,'t'},
  156. {"index",required_argument,NULL,'i'},
  157. {"duration",required_argument,NULL,'d'},
  158. {"offset",required_argument,NULL,'o'},
  159. {"sectors-per-request",required_argument,NULL,'n'},
  160. {"buffers-in-ring",required_argument,NULL,'l'},
  161. {"output-endianess",required_argument,NULL,'E'},
  162. {"cdrom-endianess",required_argument,NULL,'C'},
  163. {"verbose-level",required_argument,NULL,'v'},
  164. {"sound-device",required_argument,NULL,'K'},
  165. #ifdef MD5_SIGNATURES
  166. {"md5",required_argument,NULL,'M'},
  167. #endif
  168. {"stereo",no_argument,NULL,'s'},
  169. {"mono",no_argument,NULL,'m'},
  170. {"wait",no_argument,NULL,'w'},
  171. {"find-extremes",no_argument,NULL,'F'},
  172. {"find-mono",no_argument,NULL,'G'},
  173. #ifdef ECHO_TO_SOUNDCARD
  174. {"echo",no_argument,NULL,'e'},
  175. #endif
  176. {"info-only",no_argument,NULL,'J'},
  177. {"no-write",no_argument,NULL,'N'},
  178. {"no-infofile",no_argument,NULL,'H'},
  179. {"quiet",no_argument,NULL,'q'},
  180. {"max",no_argument,NULL,'x'},
  182. {"set-overlap",required_argument,NULL,'P'},
  183. {"speed-select",required_argument,NULL,'S'},
  185. {"dump-rates",no_argument,NULL,'R'},
  186. {"bulk",no_argument,NULL,'B'},
  187. {"deemphasize",no_argument,NULL,'T'},
  188. {"playback-realtime",required_argument,NULL,'p'},
  189. {"verbose-SCSI",no_argument,NULL,'V'},
  190. {"help",no_argument,NULL,'h'},
  191. {"gui",no_argument,NULL,'g'},
  192. {"silent-SCSI",no_argument,NULL,'Q'},
  193. {NULL,0,NULL,0}
  194. };
  195. #endif /* USE_GETOPT_LONG */
  197. #if defined(__CYGWIN32__) ||defined(__EMX__)
  198. #include <io.h> /* for setmode() prototype */
  199. #endif
  201. /* global variables */
  202. global_t global;
  204. /* static variables */
  205. static unsigned long nSamplesDone = 0;
  207. static int child_pid = -2;
  209. static unsigned long nSamplesToDo;
  210. static unsigned int current_track;
  211. static int bulk = 0;
  214. static void RestrictPlaybackRate( newrate )
  215. long newrate;
  216. {
  217.        global.playback_rate = newrate;
  219.        if ( global.playback_rate < 25 ) global.playback_rate = 25;   /* filter out insane values */
  220.        if ( global.playback_rate > 250 ) global.playback_rate = 250;
  222.        if ( global.playback_rate < 100 )
  223.                global.nsectors = (global.nsectors*global.playback_rate)/100;
  224. }
  227. long SamplesNeeded( amount, undersampling_val)
  228. long amount;
  229. long undersampling_val;
  230. {
  231.   long retval = ((undersampling_val * 2 + Halved)*amount)/2;
  232.   if (Halved && (nSamplesToDo & 1))
  233.     retval += 2;
  234.   return retval;
  235. }
  237. static int argc2;
  238. static int argc3;
  239. static char **argv2;
  241. static void reset_name_iterator __PR((void));
  242. static void reset_name_iterator ()
  243. {
  244. argv2 -= argc3 - argc2;
  245. argc2 = argc3;
  246. }
  248. static char *get_next_name __PR((void));
  249. static char *get_next_name ()
  250. {
  251. if (argc2 > 0) {
  252. argc2--;
  253. return (*argv2++);
  254. } else {
  255. return NULL;
  256. }
  257. }
  259. static char *cut_extension __PR(( char * fname ));
  261. static char
  262. *cut_extension (fname)
  263. char *fname;
  264. {
  265. char *pp;
  267. pp = strrchr(fname, '.');
  269. if (pp == NULL) {
  270. pp = fname + strlen(fname);
  271. }
  272. *pp = '';
  274. return pp;
  275. }
  277. #ifdef INFOFILES
  278. static void output_indices(fp, p, trackstart)
  279. FILE *fp;
  280. index_list *p;
  281. unsigned trackstart;
  282. {
  283.   int ci;
  285.   fprintf(fp, "Index=tt");
  286.   if (p == NULL) {
  287.     fprintf(fp, "0n");
  288.     return;
  289.   }
  291.   for (ci = 1; p != NULL; ci++, p = p->next) {
  292.     int frameoff = p->frameoffset;
  294.     if (p->next == NULL)
  295.  fputs("nIndex0=tt", fp);
  296. #if 0
  297.     else if ( ci > 8 && (ci % 8) == 1)
  298.  fputs("nIndex =tt", fp);
  299. #endif
  300.     if (frameoff != -1)
  301.          fprintf(fp, "%d ", frameoff - trackstart);
  302.     else
  303.          fprintf(fp, "-1 ");
  304.   }
  305.   fputs("n", fp);
  306. }
  308. /*
  309.  * write information at the end of the sampling process
  310.  *
  311.  *
  312.  * uglyfied for Joerg Schillings ultra dumb line parser
  313.  */
  314. static int write_info_file(fname_baseval, track, SamplesDone, numbered)
  315. char *fname_baseval;
  316. unsigned int track;
  317. unsigned long int SamplesDone;
  318. int numbered;
  319. {
  320.   FILE *info_fp;
  321.   char fname[200];
  322.   char datetime[30];
  323.   time_t utc_time;
  324.   struct tm *tmptr;
  326.   /* write info file */
  327.   if (!strcmp(fname_baseval,"standard output")) return 0;
  329.   strncpy(fname, fname_baseval, sizeof(fname) -1);
  330.   fname[sizeof(fname) -1] = 0;
  331.   if (numbered)
  332.     sprintf(cut_extension(fname), "_%02u.inf", track);
  333.   else
  334.     strcpy(cut_extension(fname), ".inf");
  336.   info_fp = fopen (fname, "w");
  337.   if (!info_fp)
  338.     return -1;
  340. #ifdef MD5_SIGNATURES
  341.   if (global.md5blocksize)
  342.     MD5Final (global.MD5_result, &global.context);
  343. #endif
  345.   utc_time = time(NULL);
  346.   tmptr = localtime(&utc_time);
  347.   if (tmptr) {
  348.     strftime(datetime, sizeof(datetime), "%x %X", tmptr);
  349.   } else {
  350.     strncpy(datetime, "unknown", sizeof(datetime));
  351.   }
  352.   fprintf(info_fp, "#created by cdda2wav %s %sn#n", VERSION
  353.   , datetime
  354.   );
  355.   fprintf(info_fp,
  356. "CDINDEX_DISCID=t'%s'n" , global.cdindex_id);
  357.   fprintf(info_fp,
  358. "CDDB_DISCID=t0x%08lxnMCN=tt%snISRC=tt%15.15sn#nAlbumtitle=t'%s'n"
  359.   , (unsigned long) global.cddb_id
  360.   , MCN
  361.   , g_toc[track-1].ISRC
  362.   , global.disctitle != NULL ? global.disctitle : (const unsigned char *)""
  363.   );
  364.   fprintf(info_fp,
  365.   "Tracktitle=t'%s'n"
  366.   , global.tracktitle[track-1] ? global.tracktitle[track-1] : (const unsigned char *)""
  367.   );
  368.   fprintf(info_fp, "Tracknumber=t%un"
  369.   , track
  370.   );
  371.   fprintf(info_fp, 
  372.   "Trackstart=t%dn"
  373.   , g_toc[track-1].dwStartSector
  374.   );
  375.   fprintf(info_fp, 
  376.   "# track length in sectors (1/75 seconds each), rest samplesnTracklength=t%ld, %dn"
  377.   , SamplesDone/588L,(int)(SamplesDone%588));
  378.   fprintf(info_fp, 
  379.   "Pre-emphasis=t%sn"
  380.   , g_toc[track-1].bFlags & 1 ? "yes" : "no");
  381.   fprintf(info_fp, 
  382.   "Channels=t%dn"
  383.   , g_toc[track-1].bFlags & 8 ? 4 : 2);
  384.   fprintf(info_fp, 
  385.   "Copy_permitted=t%sn"
  386.   , g_toc[track-1].bFlags & 2 ? "yes" : "no");
  387.   fprintf(info_fp, 
  388.   "Endianess=t%sn"
  389.   , global.need_big_endian ? "big" : "little"
  390.   );
  391.   fprintf(info_fp, "# index listn");
  392.   output_indices(info_fp, global.trackindexlist[track-1], GetStartSector(track));
  393. #ifdef MD5_SIGNATURES
  394.   fprintf(info_fp, 
  395.   "#(blocksize) checksumnMD-5=tt(%d) %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02xn"
  396.   , global.md5blocksize
  397.   , global.MD5_result[0]
  398.   , global.MD5_result[1]
  399.   , global.MD5_result[2]
  400.   , global.MD5_result[3]
  401.   , global.MD5_result[4]
  402.   , global.MD5_result[5]
  403.   , global.MD5_result[6]
  404.   , global.MD5_result[7]
  405.   , global.MD5_result[8]
  406.   , global.MD5_result[9]
  407.   , global.MD5_result[10]
  408.   , global.MD5_result[11]
  409.   , global.MD5_result[12]
  410.   , global.MD5_result[13]
  411.   , global.MD5_result[14]
  412.   , global.MD5_result[15]);
  413. #endif
  414.   fclose(info_fp);
  415.   return 0;
  416. }
  417. #endif
  419. static void CloseAudio(fname_baseval, track, bulkflag, channels_val, nSamples,
  420. audio_out)
  421. char *fname_baseval;
  422. unsigned int track;
  423. int bulkflag;
  424. int channels_val;
  425. unsigned long nSamples;
  426. struct soundfile *audio_out;
  427. {
  428.       /* define length */
  429.       audio_out->ExitSound( global.audio, nSamples*global.OutSampleSize*channels_val );
  431.       close (global.audio);
  432.       global.audio = -1;
  433. }
  435. static unsigned int track = 1;
  437. /* On terminating:
  438.  * define size-related entries in audio file header, update and close file */
  439. static void CloseAll ()
  440. {
  441.   int chld_return_status = 0;
  442.   int amichild;
  444.   /* terminate child process first */
  445.   amichild = child_pid == 0;
  447. #if defined HAVE_FORK_AND_SHAREDMEM
  448.   if (amichild == 0) {
  449. # ifdef DEBUG_CLEANUP
  450. fprintf(stderr, "Parent (READER) terminating, n");
  451. # endif
  453.     if (global.iloop > 0) {
  454.       /* set to zero */
  455.       global.iloop = 0;
  456.       kill(child_pid, SIGINT);
  457.     }
  459. #else
  460.   if (1) {
  461. #endif
  462.     /* switch to original mode and close device */
  463.     EnableCdda (get_scsi_p(), 0);
  464. #if defined HAVE_FORK_AND_SHAREDMEM
  465.   } else {
  466. #ifdef DEBUG_CLEANUP
  467. fprintf(stderr, "Child (WRITER) terminating, n");
  468. #endif
  469. #else
  470. # ifdef DEBUG_CLEANUP
  471. fprintf(stderr, "Cdda2wav single process terminating, n");
  472. # endif
  473. #endif
  474.     /* do general clean up */
  476.     if (global.audio>=0) {
  477.       if (bulk) {
  478.         /* finish sample file for this track */
  479.         CloseAudio(global.fname_base, current_track, bulk, global.channels,
  480.      global.nSamplesDoneInTrack, global.audio_out);
  481.       } else {
  482.         /* finish sample file for this track */
  483.         CloseAudio(global.fname_base, track, bulk, global.channels,
  484.      (unsigned int) nSamplesToDo, global.audio_out);
  485.       }
  486.     }
  488.     /* tell minimum and maximum amplitudes, if required */
  489.     if (global.findminmax) {
  490.       fprintf(stderr,
  491.  "right channel: minimum amplitude :%d/-32768, maximum amplitude :%d/32767n", 
  492. global.minamp[0], global.maxamp[0]);
  493.       fprintf(stderr,
  494.  "left  channel: minimum amplitude :%d/-32768, maximum amplitude :%d/32767n", 
  495. global.minamp[1], global.maxamp[1]);
  496.     }
  498.     /* tell mono or stereo recording, if required */
  499.     if (global.findmono) {
  500.       fprintf(stderr, "Audio samples are originally %s.n", global.ismono ? "mono" : "stereo");
  501.     }
  504. #ifdef DEBUG_CLEANUP
  505. fprintf(stderr, "Child (WRITER) terminating, n");
  506. #endif
  508.     return;
  509.   }
  511.   if (global.have_forked == 1) {
  512. #ifdef DEBUG_CLEANUP
  513. fprintf(stderr, "Parent wait for child death, n");
  514. #endif
  516. #if defined(HAVE_SYS_WAIT_H) && (HAVE_SYS_WAIT_H == 1)
  517.     /* wait for child to terminate */
  518.     if (0 > wait(&chld_return_status)) {
  519.       perror("");
  520.     } else {
  521.       if (WIFEXITED(chld_return_status)) {
  522.         if (WEXITSTATUS(chld_return_status)) {
  523.           fprintf(stderr, "Child exited with %dn", WEXITSTATUS(chld_return_status));
  524.         }
  525.       }
  526.       if (WIFSIGNALED(chld_return_status)) {
  527.         fprintf(stderr, "Child exited due to signal %dn", WTERMSIG(chld_return_status));
  528.       }
  529.       if (WIFSTOPPED(chld_return_status)) {
  530.         fprintf(stderr, "Child is stopped due to signal %dn", WSTOPSIG(chld_return_status));
  531.       }
  532.     }
  533. #endif
  535. #ifdef DEBUG_CLEANUP
  536. fprintf(stderr, "Parent child death, state:%dn", chld_return_status);
  537. #endif
  538.   }
  539. #ifdef GPROF
  540.   rename("gmon.out", "gmon.child");
  541. #endif
  543. }
  546. /* report a usage error and exit */
  547. #ifdef  PROTOTYPES
  548. static void usage2 (const char *szMessage, ...)
  549. #else
  550. static void usage2 (szMessage, va_alist)
  551. const char *szMessage;
  552. va_dcl
  553. #endif
  554. {
  555.   va_list marker;
  557. #ifdef  PROTOTYPES
  558.   va_start(marker, szMessage);
  559. #else
  560.   va_start(marker);
  561. #endif
  563.   error("%r", szMessage, marker);
  565.   va_end(marker);
  566.   fprintf(stderr, "nPlease use -h or consult the man page for help.n");
  568.   exit (1);
  569. }
  572. /* report a fatal error, clean up and exit */
  573. #ifdef  PROTOTYPES
  574. void FatalError (const char *szMessage, ...)
  575. #else
  576. void FatalError (szMessage, va_alist)
  577. const char *szMessage;
  578. va_dcl
  579. #endif
  580. {
  581.   va_list marker;
  583. #ifdef  PROTOTYPES
  584.   va_start(marker, szMessage);
  585. #else
  586.   va_start(marker);
  587. #endif
  589.   error("%r", szMessage, marker);
  591.   va_end(marker);
  593.   if (child_pid == -2)
  594.     exit (1);
  596.   if (child_pid == 0) {
  597.     /* kill the parent too */
  598.     kill(getppid(), SIGINT);
  599.   } else {
  600. kill(child_pid, SIGINT);
  601.   }
  602.   exit (1);
  603. }
  606. /* open the audio output file and prepare the header. 
  607.  * the header will be defined on terminating (when the size
  608.  * is known). So hitting the interrupt key leaves an intact
  609.  * file.
  610.  */
  611. static void OpenAudio (fname, rate, nBitsPerSample, channels_val, expected_bytes, audio_out)
  612. char *fname;
  613. double rate;
  614. long nBitsPerSample;
  615. long channels_val;
  616. unsigned long expected_bytes;
  617. struct soundfile * audio_out;
  618. {
  619.   if (global.audio == -1) {
  621.     global.audio = open (fname, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY
  622. #ifdef O_NONBLOCK
  623.  | O_NONBLOCK
  624. #endif
  625. #ifdef SYNCHRONOUS_WRITE
  626.  | O_SYNC
  627. #endif
  628.   , 0666);
  629.     if (global.audio == -1) {
  630.       perror("open audio sample file");
  631.       FatalError ("Could not open file %sn", fname);
  632.     }
  633.   }
  634.   audio_out->InitSound( global.audio, channels_val, (unsigned long)rate, nBitsPerSample, expected_bytes );
  636. #ifdef MD5_SIGNATURES
  637.   if (global.md5blocksize)
  638.     MD5Init (&global.context);
  639.   global.md5count = global.md5blocksize;
  640. #endif
  641. }
  644. static void set_offset(p, offset)
  645. myringbuff *p;
  646. int offset;
  647. {
  648. #ifdef DEBUG_SHM
  649.   fprintf(stderr, "Write offset %d at %pn", offset, &p->offset);
  650. #endif
  651.   p->offset = offset;
  652. }
  655. static int get_offset(p)
  656. myringbuff *p;
  657. {
  658. #ifdef DEBUG_SHM
  659.   fprintf(stderr, "Read offset %d from %pn", p->offset, &p->offset);
  660. #endif
  661.   return p->offset;
  662. }
  665. static void usage( )
  666. {
  667.   fprintf( stderr,
  668. "cdda2wav [-c chans] [-s] [-m] [-b bits] [-r rate] [-a divider] [-S speed] [-x]n");
  669.   fprintf( stderr,
  670. "         [-t track[+endtrack]] [-i index] [-o offset] [-d duration] [-F] [-G]n");
  671.   fprintf( stderr,
  672. "         [-q] [-w] [-v] [-R] [-P overlap] [-B] [-T] [-C input-endianess]n");
  673.   fprintf( stderr,
  674. "   [-e] [-n sectors] [-N] [-J] [-H] [-g] [-l buffers] [-D cd-device]n");
  675.   fprintf( stderr,
  676. "   [-I interface] [-K sound-device] [-O audiotype] [-E output-endianess]n");
  677.   fprintf( stderr,
  678. "         [-A auxdevice] [audiofiles ...]n");
  679.   fprintf( stderr,
  680. "Version %sn", VERSION);
  681.   fprintf( stderr,
  682. "cdda2wav copies parts from audio cd's directly to wav or au files.n");
  683.   fprintf( stderr,
  684. "It requires a supported cdrom drive to work.n");
  685.   fprintf( stderr,
  686. "options: -D cd-device: set the cdrom or scsi device (as Bus,Id,Lun).n");
  687.   fprintf( stderr,
  688. "         -A auxdevice: set the aux device (typically /dev/cdrom).n");
  689.   fprintf( stderr,
  690. "         -K sound-device: set the sound device to use for -e (typically /dev/dsp).n");
  691.   fprintf( stderr,
  692. "         -I interface: specify the interface for cdrom access.n");
  693.   fprintf( stderr,
  694. "                     : (generic_scsi or cooked_ioctl).n");
  695.   fprintf( stderr,
  696. "         -c channels : set 1 for mono, 2 or s for stereo (s: channels swapped).n");
  697.   fprintf( stderr,
  698. "         -s          : set to stereo recording.n");
  699.   fprintf( stderr,
  700. "         -m          : set to mono recording.n");
  701.   fprintf( stderr,
  702. "         -x          : set to maximum quality (stereo/16-bit/44.1 KHz).n");
  703.   fprintf( stderr,
  704. "         -b bits     : set bits per sample per channel (8, 12 or 16 bits).n");
  705.   fprintf( stderr,
  706. "         -r rate     : set rate in samples per second. -R gives all ratesn");
  707.   fprintf( stderr,
  708. "         -a divider  : set rate to 44100Hz / divider. -R gives all ratesn");
  709.   fprintf( stderr,
  710. "         -R          : dump a table with all available sample ratesn");
  711.   fprintf( stderr,
  712. "         -S speed    : set the cdrom drive to a given speed during readingn");
  713.   fprintf( stderr,
  714. "         -P sectors  : set amount of overlap sampling (default is 0)n");
  715. #ifdef NOTYET
  716.   fprintf( stderr,
  717. "         -X          : switch off extra alignment paranoia; implies -Y -Zn");
  718.   fprintf( stderr,
  719. "         -Y          : switch off scratch detection; implies -Zn");
  720.   fprintf( stderr,
  721. "         -Z          : switch off scratch reconstructionn");
  722.   fprintf( stderr,
  723. "         -y threshold: tune scratch detection filter; low values catchn");
  724.   fprintf( stderr,
  725. "                     : more scratches but may also catch legitimate valuesn");
  726.   fprintf( stderr,
  727. "         -z          : disable 'smart' scratch auto-detect and force n");
  728.   fprintf( stderr,
  729. "                     : paranoia to treat all data as possibly scratchednn");
  730. #endif
  731.   fprintf( stderr,
  732. "         -n sectors  : read 'sectors' sectors per request.n");
  733.   fprintf( stderr,
  734. "         -l buffers  : use a ring buffer with 'buffers' elements.n");
  735.   fprintf( stderr,
  736. "         -t track[+end track]n");
  737.   fprintf( stderr,
  738. "                     : select start track (and optionally end track).n");
  739.   fprintf( stderr,
  740. "         -i index    : select start index.n");
  741.   fprintf( stderr,
  742. "         -o offset   : start at 'offset' sectors behind start track/index.n");
  743.   fprintf( stderr,
  744. "                       one sector equivalents 1/75 second.n");
  745.   fprintf( stderr,
  746. "         -O audiotype: set wav or au (aka sun) or cdr (aka raw) or aiff or aifc audio format. Default is %s.n", AUDIOTYPE);
  747.   fprintf( stderr,
  748. "         -C endianess: set little or big input sample endianess.n");
  749.   fprintf( stderr,
  750. "         -E endianess: set little or big output sample endianess.n");
  751.   fprintf( stderr,
  752. "         -d duration : set recording time in seconds or 0 for whole track.n");
  753.   fprintf( stderr,
  754. "         -w          : wait for audio signal, then start recording.n");
  755.   fprintf( stderr,
  756. "         -F          : find extrem amplitudes in samples.n");
  757.   fprintf( stderr,
  758. "         -G          : find if input samples are mono.n");
  759.   fprintf( stderr,
  760. "         -T          : undo pre-emphasis in input samples.n");
  761. #ifdef ECHO_TO_SOUNDCARD
  762.   fprintf( stderr,
  763. "         -e          : echo audio data to sound device SOUND_DEV.n");
  764. #endif
  765.   fprintf( stderr,
  766. "         -v level    : print informations on current cd (level: 0-63).n");
  767.   fprintf( stderr,
  768. "         -N          : no file operation.n");
  769.   fprintf( stderr,
  770. "         -J          : give disc information only.n");
  771.   fprintf( stderr,
  772. "         -H          : no info file generation.n");
  773.   fprintf( stderr,
  774. "         -g          : generate special output suitable for gui frontends.n");
  775.   fprintf( stderr,
  776. "         -Q          : do not print status of erreneous scsi-commands.n");
  777. #ifdef MD5_SIGNATURES
  778.   fprintf( stderr,
  779. "         -M count    : calculate MD-5 checksum for 'count' bytes.n");
  780. #endif
  781.   fprintf( stderr,
  782. "         -q          : quiet operation, no screen output.n");
  783.   fprintf( stderr,
  784. "         -p percent  : play (echo) audio at a new pitch rate.n");
  785.   fprintf( stderr,
  786. "         -V          : increase verbosity for SCSI commands.n");
  787.   fprintf( stderr,
  788. "         -h          : this help screen.n"  );
  789.   fprintf( stderr,
  790. "         -B          : record each track into a seperate file.n");
  791.   fprintf( stderr,
  792. "defaults: %s, %d bit, %d.%02d Hz, track 1, no offset, one track,n",
  793.   CHANNELS-1?"stereo":"mono", BITS_P_S,
  794.  44100 / UNDERSAMPLING,
  795.  (4410000 / UNDERSAMPLING) % 100);
  796.   fprintf( stderr,
  797. "          type %s '%s', don't wait for signal, not quiet, not verbose,n",
  798.           AUDIOTYPE, FILENAME);
  799.   fprintf( stderr,
  800. "          use %s, device %s, aux %s",
  801.   DEF_INTERFACE, CD_DEVICE, AUX_DEVICE);
  802. #ifdef ECHO_TO_SOUNDCARD
  803.   fprintf( stderr,
  804. ", sound device %sn",
  805.   SOUND_DEV);
  806. #else
  807.   fprintf( stderr, "n");
  808. #endif
  809.   fprintf( stderr,
  810. "parameters: (optional) a file name or - for standard output.n");
  811.   exit( 1 );
  812. }
  814. static void init_globals()
  815. {
  816.   strncpy(global.dev_name, CD_DEVICE, sizeof(global.dev_name)); /* device name */
  817.   strncpy(global.aux_name, AUX_DEVICE, sizeof(global.aux_name));/* auxiliary cdrom device */
  818.   strncpy(global.fname_base, FILENAME, sizeof(global.fname_base));/* auxiliary cdrom device */
  819.   global.have_forked = 0; /* state variable for clean up */
  820.   global.parent_died = 0; /* state variable for clean up */
  821.   global.audio    = -1; /* audio file desc */
  822.   global.cooked_fd  = -1; /* cdrom file desc */
  823.   global.no_file  =  0; /* flag no_file */
  824.   global.no_infofile  =  0; /* flag no_infofile */
  825.   global.no_cddbfile  =  0; /* flag no_cddbfile */
  826.   global.quiet   =  0; /* flag quiet */
  827.   global.verbose  =  3 + 32 + 64; /* verbose level */
  828.   global.scsi_silent = 0;
  829.   global.scsi_verbose = 0; /* SCSI verbose level */
  830.   global.multiname = 0; /* multiple file names given */
  831.   global.sh_bits  =  0; /* sh_bits: sample bit shift */
  832.   global.Remainder=  0; /* remainder */
  833.   global.iloop    =  0; /* todo counter */
  834.   global.SkippedSamples =  0; /* skipped samples */
  835.   global.OutSampleSize  =  0; /* output sample size */
  836.   global.channels = CHANNELS; /* output sound channels */
  837.   global.nSamplesDoneInTrack = 0; /* written samples in current track */
  838.   global.buffers = 4;           /* buffers to use */
  839.   global.nsectors = NSECTORS;   /* sectors to read in one request */
  840.   global.overlap = 1;           /* amount of overlapping sectors */
  841.   global.useroverlap = -1;      /* amount of overlapping sectors user override */
  842.   global.need_hostorder = 0; /* processing needs samples in host endianess */
  843.   global.outputendianess = NONE; /* user specified output endianess */
  844.   global.findminmax  =  0; /* flag find extrem amplitudes */
  845. #ifdef HAVE_LIMITS_H
  846.   global.maxamp[0] = INT_MIN; /* maximum amplitude */
  847.   global.maxamp[1] = INT_MIN; /* maximum amplitude */
  848.   global.minamp[0] = INT_MAX; /* minimum amplitude */
  849.   global.minamp[1] = INT_MAX; /* minimum amplitude */
  850. #else
  851.   global.maxamp[0] = -32768; /* maximum amplitude */
  852.   global.maxamp[1] = -32768; /* maximum amplitude */
  853.   global.minamp[0] = 32767; /* minimum amplitude */
  854.   global.minamp[1] = 32767; /* minimum amplitude */
  855. #endif
  856.   global.speed = DEFAULT_SPEED; /* use default */ 
  857.   global.userspeed = -1;        /* speed user override */
  858.   global.findmono  =  0; /* flag find if samples are mono */
  859.   global.ismono  =  1; /* flag if samples are mono */
  860.   global.swapchannels  =  0; /* flag if channels shall be swapped */
  861.   global.deemphasize  =  0; /* flag undo pre-emphasis in samples */
  862.   global.playback_rate = 100;   /* new fancy selectable sound output rate */
  863.   global.gui  =  0; /* flag plain formatting for guis */
  864.   global.cddb_id = 0;           /* disc identifying id for CDDB database */
  865.   global.disctitle = NULL;
  866.   global.creator = NULL;
  867.   global.copyright_message = NULL;
  868.   memset(global.tracktitle, 0, sizeof(global.tracktitle));
  869.   memset(global.trackindexlist, 0, sizeof(global.trackindexlist));
  870. }
  872. #if !defined (HAVE_STRCASECMP) || (HAVE_STRCASECMP != 1)
  873. #include <ctype.h>
  874. static int strcasecmp __PR(( const char *s1, const char *s2 ));
  875. static int strcasecmp(s1, s2)
  876. const char *s1;
  877. const char *s2;
  878. {
  879.   if (s1 && s2) {
  880.     while (*s1 && *s2 && (tolower(*s1) - tolower(*s2) == 0)) {
  881.       s1++;
  882.       s2++;
  883.     }
  884.     if (*s1 == '' && *s2 == '') return 0;
  885.     if (*s1 == '') return -1;
  886.     if (*s2 == '') return +1;
  887.     return tolower(*s1) - tolower(*s2);
  888.   }
  889.   return -1;
  890. }
  891. #endif
  893. #if !defined (HAVE_STRTOUL) || (HAVE_STRTOUL != 1)
  894. static unsigned int strtoul __PR(( const char *s1, char **s2, int base ));
  895. static unsigned int strtoul(s1, s2, base)
  896.         const char *s1;
  897.         char **s2;
  898. int base;
  899. {
  900. long retval;
  902. if (base == 10) {
  903. /* strip zeros in front */
  904. while (*s1 == '0')
  905. s1++;
  906. }
  907. if (s2 != NULL) {
  908. *s2 = astol(s1, &retval);
  909. } else {
  910. (void) astol(s1, &retval);
  911. }
  913. return (unsigned long) retval; 
  914. }
  915. #endif
  917. static unsigned long SectorBurst;
  918. #if (SENTINEL > CD_FRAMESIZE_RAW)
  919. error block size for overlap check has to be < sector size
  920. #endif
  923. static void
  924. switch_to_realtime_priority __PR((void));
  926. #ifdef  HAVE_SYS_PRIOCNTL_H
  928. #include <sys/priocntl.h>
  929. #include <sys/rtpriocntl.h>
  930. static void
  931. switch_to_realtime_priority()
  932. {
  933.         pcinfo_t        info;
  934.         pcparms_t       param;
  935.         rtinfo_t        rtinfo;
  936.         rtparms_t       rtparam;
  937. int pid;
  939. pid = getpid();
  941.         /* get info */
  942.         strcpy(info.pc_clname, "RT");
  943.         if (-1 == priocntl(P_PID, pid, PC_GETCID, (void *)&info))
  944.                 comerr("Cannot get priority class id priocntl(PC_GETCID)n");
  946.         movebytes(info.pc_clinfo, &rtinfo, sizeof(rtinfo_t));
  948.         /* set priority not to the max */
  949.         rtparam.rt_pri = rtinfo.rt_maxpri - 2;
  950.         rtparam.rt_tqsecs = 0;
  951.         rtparam.rt_tqnsecs = RT_TQDEF;
  952.         param.pc_cid = info.pc_cid;
  953.         movebytes(&rtparam, param.pc_clparms, sizeof(rtparms_t));
  954. needroot(0);
  955.         if (-1 == priocntl(P_PID, pid, PC_SETPARMS, (void *)&param))
  956.                 comerr("Cannot set priority class parameters priocntl(PC_SETPARMS)n");
  957. dontneedroot();
  958. }
  959. #else
  960. #if      defined _POSIX_PRIORITY_SCHEDULING
  961. #include <sched.h>
  963. static void
  964. switch_to_realtime_priority()
  965. {
  966. #ifdef  _SC_PRIORITY_SCHEDULING
  967. if (sysconf(_SC_PRIORITY_SCHEDULING) == -1) {
  968. errmsg("WARNING: RR-scheduler not available, disabling.n");
  969. } else
  970. #endif
  971. {
  972. int sched_fifo_min, sched_fifo_max;
  973. struct sched_param sched_parms;
  975. sched_fifo_min = sched_get_priority_min(SCHED_FIFO);
  976. sched_fifo_max = sched_get_priority_max(SCHED_FIFO);
  977. sched_parms.sched_priority = sched_fifo_max - 1;
  978. needroot(0);
  979. if (-1 == sched_setscheduler(getpid(), SCHED_FIFO, &sched_parms)
  980. && global.quiet != 1)
  981. perror("cannot set posix realtime scheduling policy");
  982. dontneedroot();
  983. }
  984. }
  985. #else
  986. #if defined(__CYGWIN32__)
  988. /*
  989.  * NOTE: Base.h has a second typedef for BOOL.
  990.  *  We define BOOL to make all local code use BOOL
  991.  *  from Windows.h and use the hidden __SBOOL for
  992.  *  our global interfaces.
  993.  */
  994. #define BOOL WBOOL /* This is the Win BOOL */
  995. #define format __format
  996. #include <Windows32/Base.h>
  997. #include <Windows32/Defines.h>
  998. #include <Windows32/Structures.h>
  999. #include <Windows32/Functions.h>
  1000. #undef format
  1002. static void
  1003. switch_to_realtime_priority()
  1004. {
  1005.    /* set priority class */
  1006.    if (FALSE == SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS)) {
  1007.      fprintf(stderr, "No realtime priority possible.n");
  1008.      return;
  1009.    }
  1011.    /* set thread priority */
  1012.    if (FALSE == SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST)) {
  1013.      fprintf(stderr, "Could not set realtime priority.n");
  1014.    }
  1015. }
  1016. #else
  1017. static void
  1018. switch_to_realtime_priority()
  1019. {
  1020. }
  1021. #endif
  1022. #endif
  1023. #endif
  1025. /* signal handler for process communication */
  1026. static void set_nonforked __PR((int status));
  1028. static void set_nonforked(status)
  1029. int status;
  1030. {
  1032. PRETEND_TO_USE(status);
  1034. global.parent_died = 1;
  1035. #if defined DEBUG_CLEANUP
  1036. fprintf( stderr, "SIGPIPE received from %sn.", child_pid == 0 ? "Child" : "Parent");
  1037. #endif
  1038. if (child_pid == 0)
  1039. kill(getppid(), SIGINT);
  1040. else
  1041. kill(child_pid, SIGINT);
  1042. exit(9);
  1043. }
  1047. static long lSector;
  1048. static long lSector_p2;
  1049. static double rate = 44100 / UNDERSAMPLING;
  1050. static int bits = BITS_P_S;
  1051. static char fname[200];
  1052. static char audio_type[10];
  1053. static long BeginAtSample;
  1054. static unsigned long SamplesToWrite; 
  1055. static unsigned minover;
  1056. static unsigned maxover;
  1058. static unsigned long calc_SectorBurst __PR((void));
  1059. static unsigned long calc_SectorBurst()
  1060. {
  1061. unsigned long SectorBurstVal;
  1063. SectorBurstVal = min(global.nsectors,
  1064.   (global.iloop + CD_FRAMESAMPLES-1) / CD_FRAMESAMPLES);
  1065. if ( lSector+(int)SectorBurst-1 >= lSector_p2 )
  1066. SectorBurstVal = lSector_p2 - lSector;
  1067. return SectorBurstVal;
  1068. }
  1070. /* if PERCENTAGE_PER_TRACK is defined, the percentage message will reach
  1071.  * 100% every time a track end is reached or the time limit is reached.
  1072.  *
  1073.  * Otherwise if PERCENTAGE_PER_TRACK is not defined, the percentage message
  1074.  * will reach 100% once at the very end of the last track.
  1075.  */
  1076. #define PERCENTAGE_PER_TRACK
  1078. static int do_read __PR((myringbuff *p, unsigned *total_unsuccessful_retries));
  1079. static int do_read (p, total_unsuccessful_retries)
  1080. myringbuff *p;
  1081. unsigned *total_unsuccessful_retries;
  1082. {
  1083.       unsigned char *newbuf;
  1084.       int offset;
  1085.       unsigned int retry_count;
  1086.       unsigned int added_size;
  1087.       static unsigned oper = 200;
  1089.       /* how many sectors should be read */
  1090.       SectorBurst =  calc_SectorBurst();
  1092. #define MAX_READRETRY 12
  1094.       retry_count = 0;
  1095.       do {
  1096. #ifdef DEBUG_READS
  1097. fprintf(stderr, "reading from %lu to %lu, overlap %un", lSector, lSector + SectorBurst -1, global.overlap);
  1098. #endif
  1100. #ifdef DEBUG_BUFFER_ADDRESSES
  1101.   fprintf(stderr, "%p %ln", p->data, global.pagesize);
  1102.   if (((unsigned)p->data) & (global.pagesize -1) != 0) {
  1103.     fprintf(stderr, "Address %p is NOT page aligned!!n", p->data);
  1104.   }
  1105. #endif
  1107.           ReadCdRom( get_scsi_p(), p->data, lSector, SectorBurst );
  1108.           if (NULL ==
  1109.                  (newbuf = synchronize( p->data, SectorBurst*CD_FRAMESAMPLES,
  1110.                  nSamplesToDo-global.iloop ))) {
  1111.     /* could not synchronize!
  1112.      * Try to invalidate the cdrom cache.
  1113.      * Increase overlap setting, if possible.
  1114.      */
  1115.            /*trash_cache(p->data, lSector, SectorBurst);*/
  1116.     if (global.overlap < global.nsectors - 1) {
  1117.         global.overlap++;
  1118. lSector--;
  1119.   SectorBurst =  calc_SectorBurst();
  1120. #ifdef DEBUG_DYN_OVERLAP
  1121. fprintf(stderr, "using increased overlap of %un", global.overlap);
  1122. #endif
  1123.     } else {
  1124. lSector += global.overlap - 1;
  1125. global.overlap = 1;
  1126. SectorBurst =  calc_SectorBurst();
  1127.     }
  1128.   } else
  1129. break;
  1130.       } while (++retry_count < MAX_READRETRY);
  1132.       if (retry_count == MAX_READRETRY && newbuf == NULL && global.verbose != 0) {
  1133.         (*total_unsuccessful_retries)++;
  1134.       }
  1136.       if (newbuf) {
  1137.         offset = newbuf - ((unsigned char *)p->data);
  1138.       } else {
  1139.         offset = global.overlap * CD_FRAMESIZE_RAW;
  1140.       }
  1141.       set_offset(p,offset);
  1143.       /* how much has been added? */
  1144.       added_size = SectorBurst * CD_FRAMESAMPLES - offset/4;
  1146.       if (newbuf && nSamplesToDo != global.iloop) {
  1147. minover = min(global.overlap, minover);
  1148. maxover = max(global.overlap, maxover);
  1151. /* should we reduce the overlap setting ? */
  1152. if (offset > CD_FRAMESIZE_RAW && global.overlap > 1) {
  1153. #ifdef DEBUG_DYN_OVERLAP
  1154.           fprintf(stderr, "decreasing overlap from %u to %u (jitter %d)n", global.overlap, global.overlap-1, offset - (global.overlap)*CD_FRAMESIZE_RAW);
  1155. #endif
  1156.   global.overlap--;
  1157.   SectorBurst =  calc_SectorBurst();
  1158. }
  1159.       }
  1161.       if (global.iloop >= added_size)
  1162.         global.iloop -= added_size;
  1163.       else
  1164.         global.iloop = 0;
  1166.       if (global.verbose) {
  1167. unsigned per;
  1169. #ifdef PERCENTAGE_PER_TRACK
  1170.         /* Thomas Niederreiter wants percentage per track */
  1171. unsigned start_in_track = max(BeginAtSample,
  1172.                   g_toc[current_track-1].dwStartSector*CD_FRAMESAMPLES);
  1174. per = min(BeginAtSample+nSamplesToDo,
  1175.   g_toc[current_track].dwStartSector*CD_FRAMESAMPLES)
  1176. - start_in_track;
  1178. per = (BeginAtSample+nSamplesToDo-global.iloop
  1179. - start_in_track
  1180.       )/(per/100);
  1182. #else
  1183. per = global.iloop ? (nSamplesToDo-global.iloop)/(nSamplesToDo/100) : 100;
  1184. #endif
  1186. if (global.overlap > 0) {
  1187.           fprintf(stderr, "r%2d/%2d/%2d/%7d %3d%%",
  1188.            minover, maxover, global.overlap,
  1189.            newbuf ? offset - global.overlap*CD_FRAMESIZE_RAW : 9999999,
  1190. per);
  1191.   fflush(stderr);
  1192. } else if (oper != per) {
  1193.           fprintf(stderr, "r%3d%%", per);
  1194.   fflush(stderr);
  1195.   oper = per;
  1196. }
  1197.       }
  1198.       lSector += SectorBurst - global.overlap;
  1200. #if defined PERCENTAGE_PER_TRACK && defined HAVE_FORK_AND_SHAREDMEM
  1201.       while (lSector >= (int)g_toc[current_track].dwStartSector) {
  1202. current_track++;
  1203.       }
  1204. #endif
  1206.       return offset;
  1207. }
  1210. static unsigned long do_write __PR((myringbuff *p));
  1211. static unsigned long do_write (p)
  1212. myringbuff *p;
  1213. {
  1214.       int current_offset;
  1215.       unsigned int InSamples;
  1216.       current_offset = get_offset(p);
  1218.       /* how many bytes are available? */
  1219.       InSamples = global.nsectors*CD_FRAMESAMPLES - current_offset/4;
  1220.       /* how many samples are wanted? */
  1221.       InSamples = min((nSamplesToDo-nSamplesDone),InSamples);
  1223.       /* when track end is reached, close current file and start a new one */
  1224.       while ((nSamplesDone < nSamplesToDo) && (InSamples != 0)) {
  1225. long unsigned int how_much = InSamples;
  1227. long int left_in_track;
  1228. left_in_track  = (int)g_toc[current_track].dwStartSector*CD_FRAMESAMPLES
  1229.  - (int)(BeginAtSample+nSamplesDone);
  1231. if (left_in_track < 0) {
  1232. fprintf(stderr, "internal error: negative left_in_track:%ldn",left_in_track);
  1233. }
  1235. if (bulk)
  1236.   how_much = min(how_much, (unsigned long) left_in_track);
  1239. #ifdef MD5_SIGNATURES
  1240. if (global.md5count) {
  1241.   MD5Update (&global.context, ((unsigned char *)p->data) +current_offset, min(global.md5count,how_much));
  1242.   global.md5count -= min(global.md5count,how_much);
  1243. }
  1244. #endif
  1245. if ( SaveBuffer ( p->data + current_offset/4,
  1246.  how_much,
  1247.  &nSamplesDone) ) {
  1248.   if (global.have_forked == 1) {
  1249.     /* kill parent */
  1250.     kill(getppid(), SIGINT);
  1251.   }
  1252.   exit(20);
  1253. }
  1254.         global.nSamplesDoneInTrack += how_much;
  1255. SamplesToWrite -= how_much;
  1257. /* move residual samples upto buffer start */
  1258. if (how_much < InSamples) 
  1259. movebytes(
  1260.   (char *)(p->data) + current_offset + how_much*4,
  1261.   (char *)(p->data) + current_offset,
  1262.   (InSamples - how_much) * 4);
  1264. if ((unsigned long) left_in_track < InSamples) {
  1266.   if (bulk) {
  1267.     /* finish sample file for this track */
  1268.     CloseAudio(global.fname_base, current_track, bulk, global.channels,
  1269.      global.nSamplesDoneInTrack, global.audio_out);
  1270.     any_signal = 0;
  1271.           } else if (SamplesToWrite == 0) {
  1272.     /* finish sample file for this track */
  1273.     CloseAudio(global.fname_base, track, bulk, global.channels,
  1274.      (unsigned int) nSamplesToDo, global.audio_out);
  1275.   }
  1277.   if (global.verbose) {
  1278.     if (global.tracktitle[current_track -1] != NULL) {
  1279.       fprintf( stderr, "  track %2u '%s' successfully recordedn", 
  1280. current_track, global.tracktitle[current_track-1]);
  1281.             } else {
  1282.       fprintf( stderr, "  track %2u successfully recordedn", current_track);
  1283.             }
  1284.           }
  1286.           global.nSamplesDoneInTrack = 0;
  1287.   if ( bulk && SamplesToWrite > 0 ) {
  1288.     if ( !global.no_file ) {
  1289.       char *tmp_fname;
  1291.       /* build next filename */
  1292.       tmp_fname = get_next_name();
  1293.       if (tmp_fname != NULL) {
  1294.       strncpy(global.fname_base , tmp_fname, sizeof global.fname_base);
  1295.       global.fname_base[sizeof(global.fname_base)-1]=0;
  1296.       }
  1298.       tmp_fname = cut_extension(global.fname_base);
  1299.       tmp_fname[0] = '';
  1301.       if (global.multiname == 0) {
  1302. sprintf(fname, "%s_%02u.%s",global.fname_base,current_track+1,
  1303. audio_type);
  1304.       } else {
  1305. sprintf(fname, "%s.%s",global.fname_base, audio_type);
  1306.       }
  1307.       OpenAudio( fname, rate, bits, global.channels,
  1308. (g_toc[current_track].dwStartSector -
  1309.  g_toc[current_track-1].dwStartSector)*CD_FRAMESIZE_RAW,
  1310. global.audio_out);
  1311.     }
  1312.   }
  1313.   current_track++;
  1314. }
  1315. InSamples -= how_much;
  1317.       }  /* end while */
  1318.       return nSamplesDone;
  1319. }
  1321. #define PRINT_OVERLAP_INIT 
  1322.    if (global.verbose) { 
  1323. if (global.overlap > 0) 
  1324. fprintf(stderr, "overlap:min/max/cur, jitter, percent_done:n??/??/??/???????   0%%"); 
  1325. else 
  1326. fputs("percent_done:n  0%", stderr); 
  1327.    }
  1329. #if defined HAVE_FORK_AND_SHAREDMEM
  1330. static void forked_read __PR((void));
  1332. /* This function does all audio cdrom reads
  1333.  * until there is nothing more to do
  1334.  */
  1335. static void
  1336. forked_read()
  1337. {
  1338.    unsigned total_unsuccessful_retries = 0;
  1340. #if !defined(HAVE_SEMGET) || !defined(USE_SEMAPHORES)
  1341.    init_child();
  1342. #endif
  1344.    minover = global.nsectors;
  1346.    PRINT_OVERLAP_INIT
  1347.    while (global.iloop) { 
  1349.       do_read(get_next_buffer(), &total_unsuccessful_retries);
  1351.       define_buffer();
  1353.    } /* while (global.iloop) */
  1354.    flush_buffers();
  1356.    if (total_unsuccessful_retries) {
  1357.       fprintf(stderr,"%u unsuccessful matches while readingn",total_unsuccessful_retries);
  1358.    }
  1359. }
  1361. static void forked_write __PR((void));
  1363. static void
  1364. forked_write()
  1365. {
  1367.     /* don't need these anymore.  Good security policy says we get rid
  1368.        of them ASAP */
  1369.     neverneedroot();
  1370.     neverneedgroup();
  1372. #if defined(HAVE_SEMGET) && defined(USE_SEMAPHORES)
  1373. #else
  1374.     init_parent();
  1375. #endif
  1377.     while (nSamplesDone < nSamplesToDo) {
  1379.       /* get oldest buffers */
  1380.       
  1381.       nSamplesDone = do_write(get_oldest_buffer());
  1383.       if (global.parent_died == 0) {
  1384.         drop_buffer();
  1385.       }
  1387.     } /* end while */
  1390.     if (global.verbose) {
  1391.       if (global.tracktitle[current_track -1] != NULL) {
  1392.         fprintf( stderr, "  track %2u '%s' successfully recordedn",
  1393. current_track, global.tracktitle[current_track-1]);
  1394.       } else {
  1395.         fprintf( stderr, "  track %2u successfully recordedn", current_track);
  1396.       }
  1397.     }
  1398. }
  1399. #else
  1401. /* This function implements the read and write calls in one loop (in case
  1402.  * there is no fork/thread_create system call).
  1403.  * This means reads and writes have to wait for each other to complete.
  1404.  */
  1405. static void nonforked_loop __PR((void));
  1407. static void
  1408. nonforked_loop()
  1409. {
  1410.     unsigned total_unsuccessful_retries = 0;
  1412.     minover = global.nsectors;
  1414.     PRINT_OVERLAP_INIT
  1415.     while (global.iloop) { 
  1417.       do_read(get_next_buffer(), &total_unsuccessful_retries);
  1419.       do_write(get_oldest_buffer());
  1421.     }
  1423.     if (total_unsuccessful_retries) {
  1424.       fprintf(stderr,"%u unsuccessful matches while readingn",total_unsuccessful_retries);
  1425.     }
  1427.     if (global.verbose) {
  1428.       if (global.tracktitle[current_track -1] != NULL) {
  1429.         fprintf( stderr, "  track %2u '%s' successfully recordedn",
  1430. current_track, global.tracktitle[current_track-1]);
  1431.       } else {
  1432.         fprintf( stderr, "  track %2u successfully recordedn", current_track);
  1433.       }
  1434.     }
  1435. }
  1436. #endif
  1438. /* and finally: the MAIN program */
  1439. int main( argc, argv )
  1440. int argc;
  1441. char *argv [];
  1442. {
  1443.   long lSector_p1;
  1444.   long sector_offset = 0;
  1445.   unsigned long endtrack = 1;
  1446.   double rectime = DURATION;
  1447.   int cd_index = -1;
  1448.   double int_part;
  1449.   int littleendian = -1;
  1450.   int just_the_toc = 0;
  1451.   char int_name[100];
  1452. #ifdef  ECHO_TO_SOUNDCARD
  1453.   static char user_sound_device[200] = "";
  1454. #endif /* ECHO_TO_SOUNDCARD */
  1455.   int c;
  1456. #ifdef USE_GETOPT_LONG
  1457.   int long_option_index=0;
  1458. #endif /* USE_GETOPT_LONG */
  1459.   int am_i_cdda2wav;
  1460.   char * env_p;
  1461.   int tracks_included;
  1463.   strcpy(int_name, DEF_INTERFACE);
  1464.   strcpy(audio_type, AUDIOTYPE);
  1465.   save_args(argc, argv);
  1467.   /* init global variables */
  1468.   init_globals();
  1470.   /* When being invoked as list_audio_tracks, just dump a list of
  1471.      audio tracks. */
  1472.   am_i_cdda2wav = strcmp(argv[0],"list_audio_tracks");
  1473.   if (!am_i_cdda2wav) global.verbose = SHOW_JUSTAUDIOTRACKS;
  1475.   /* Control those set-id privileges... */
  1476.   initsecurity();
  1478.   env_p = getenv("CDDA_DEVICE");
  1479.   if (env_p != NULL) {
  1480.     strncpy( global.dev_name, env_p, sizeof(global.dev_name) );
  1481.     global.dev_name[sizeof(global.dev_name)-1]=0;
  1482.   }
  1484.   /* command options parsing */
  1485. #ifdef USE_GETOPT_LONG
  1486.   while ( (c = getopt_long (argc,argv,optstring,options,&long_option_index)) 
  1487. != EOF)
  1488. #else
  1489.   while ( (c = getopt(argc, argv, optstring)) != EOF )
  1490. #endif /* USE_GETOPT_LONG */
  1491. {
  1492.     switch (c) {
  1493.       case 'D':    /* override device */
  1494.         strncpy( global.dev_name, optarg, sizeof(global.dev_name) );
  1495.         global.dev_name[sizeof(global.dev_name)-1]=0;
  1496. break;
  1497.       case 'A':    /* override device */
  1498.         strncpy( global.aux_name, optarg, sizeof(global.aux_name) );
  1499.         global.aux_name[sizeof(global.aux_name)-1]=0;
  1500. break;
  1501.       case 'I':    /* override interface */
  1502. strncpy( int_name, optarg, sizeof(int_name) );
  1503.         int_name[sizeof(int_name)-1]=0;
  1504. break;
  1505. #ifdef  ECHO_TO_SOUNDCARD
  1506.       case 'K':    /* override sound device */
  1507. strncpy( user_sound_device, optarg, sizeof(user_sound_device) );
  1508.         user_sound_device[sizeof(user_sound_device)-1]=0;
  1509. break;
  1510. #endif /* ECHO_TO_SOUNDCARD */
  1512.       /* the following options are relevant to 'cdda2wav' only */
  1513. #ifdef MD5_SIGNATURES
  1514.       case 'M':
  1515.         if (!am_i_cdda2wav) break;
  1516. global.md5blocksize = strtoul( optarg, NULL, 10 );
  1517.         break;
  1518. #endif
  1519.       case 'O':    /* override audio type */
  1520.         if (!am_i_cdda2wav) break;
  1521. strncpy( audio_type, optarg, 4);
  1522.         audio_type[sizeof(audio_type)-1]=0;
  1523. break;
  1524.       case 'C':    /* override input endianess */
  1525.         if (!am_i_cdda2wav) break;
  1526. if (strcasecmp(optarg, "little") == 0) {
  1527.    littleendian = 1;
  1528. } else 
  1529. if (strcasecmp(optarg, "big") == 0) {
  1530.    littleendian = 0;
  1531. } else 
  1532. if (strcasecmp(optarg, "guess") == 0) {
  1533.    littleendian = -2;
  1534. } else {
  1535.    usage2("wrong parameter '%s' for option -C", optarg);
  1536. }
  1537. break;
  1538.       case 'E':    /* override output endianess */
  1539.         if (!am_i_cdda2wav) break;
  1540. if (strcasecmp(optarg, "little") == 0) {
  1541.    global.outputendianess = LITTLE;
  1542. } else 
  1543. if (strcasecmp(optarg, "big") == 0) {
  1544.    global.outputendianess = BIG;
  1545. } else {
  1546.    usage2("wrong parameter '%s' for option -E", optarg);
  1547. }
  1548. break;
  1549.       case 'c':    /* override channels */
  1550.         if (!am_i_cdda2wav) break;
  1551. if (optarg[0] == 's') {
  1552. global.channels = 2;
  1553. global.swapchannels = 1;
  1554. } else {
  1555. global.channels = strtol( optarg, NULL, 10);
  1556. }
  1557. break;
  1558.       case 'S':    /* override drive speed */
  1559.         if (!am_i_cdda2wav) break;
  1560. global.userspeed = strtoul( optarg, NULL, 10);
  1561. break;
  1562.       case 'l':    /* install a ring buffer with 'buffers' elements */
  1563.         if (!am_i_cdda2wav) break;
  1564.         global.buffers = strtoul( optarg, NULL, 10);
  1565.         break;
  1566.       case 'b':    /* override bits */
  1567.         if (!am_i_cdda2wav) break;
  1568. bits = strtol( optarg, NULL, 10);
  1569. break;
  1570.       case 'r':    /* override rate */
  1571.         if (!am_i_cdda2wav) break;
  1572. rate = strtol( optarg, NULL, 10);
  1573. break;
  1574.       case 'a':    /* override rate */
  1575.         if (!am_i_cdda2wav) break;
  1576. if (strtod( optarg, NULL ) != 0.0)
  1577.     rate = 44100.0 / strtod( optarg, NULL );
  1578. else {
  1579.     fprintf(stderr, "-a requires a nonzero, positive divider.n");
  1580.     exit ( 1 );
  1581. }
  1582. break;
  1583.       case 't':    /* override start track */
  1584.         if (!am_i_cdda2wav) break;
  1585. {
  1586. char * endptr;
  1587. char * endptr2;
  1588. track = strtoul( optarg, &endptr, 10 );
  1589. endtrack = strtoul( endptr, &endptr2, 10 );
  1590. if (endptr2 == endptr)
  1591. endtrack = track;
  1592. break;
  1593. }
  1594.       case 'i':    /* override start index */
  1595.         if (!am_i_cdda2wav) break;
  1596. cd_index = strtoul( optarg, NULL, 10);
  1597. break;
  1598.       case 'd':    /* override recording time */
  1599.         if (!am_i_cdda2wav) break;
  1600. /* we accept multiple formats now */
  1601. { char *end_ptr = NULL;
  1602.   rectime = strtod( optarg, &end_ptr );
  1603.   if (*end_ptr == '') {
  1604.   } else if (*end_ptr == 'f') {
  1605.     rectime = rectime / 75.0;
  1606. /* TODO: add an absolute end of recording. */
  1607. #if 0
  1608.   } else if (*end_ptr == 'F') {
  1609.     rectime = rectime / 75.0;
  1610. #endif
  1611.   } else
  1612.     rectime = -1.0;
  1613. }
  1614. break;
  1615.       case 'o':    /* override offset */
  1616.         if (!am_i_cdda2wav) break;
  1617. sector_offset = strtol( optarg, NULL, 10);
  1618. break;
  1619.       case 'n':    /* read sectors per request */
  1620.         if (!am_i_cdda2wav) break;
  1621. global.nsectors = strtoul( optarg, NULL, 10);
  1622. break;
  1624.        /*-------------- RS 98 -------------*/
  1625.       case 'p':    /* specify playback pitch rate */
  1626.         global.playback_rate = strtol( optarg, NULL, 10);
  1627.         RestrictPlaybackRate( global.playback_rate );
  1628.         global.need_hostorder = 1;
  1629.         break;
  1630.       case 'P':    /* set initial overlap sectors */
  1631.         if (!am_i_cdda2wav) break;
  1632. global.useroverlap = strtol( optarg, NULL, 10);
  1633. break;
  1635.       case 's':    /* stereo */
  1636.         if (!am_i_cdda2wav) break;
  1637. global.channels = 2;
  1638. break;
  1639.       case 'm':    /* mono */
  1640.         if (!am_i_cdda2wav) break;
  1641. global.channels = 1;
  1642.         global.need_hostorder = 1;
  1643. break;
  1644.       case 'x':    /* max */
  1645.         if (!am_i_cdda2wav) break;
  1646. global.channels = 2; bits = 16; rate = 44100;
  1647. break;
  1648.       case 'w':    /* wait for some audio intensity */
  1649.         if (!am_i_cdda2wav) break;
  1650. waitforsignal = 1;
  1651. break;
  1652.       case 'F':    /* find extreme amplitudes */
  1653.         if (!am_i_cdda2wav) break;
  1654. global.findminmax = 1;
  1655.         global.need_hostorder = 1;
  1656. break;
  1657.       case 'G':    /* find if mono */
  1658.         if (!am_i_cdda2wav) break;
  1659. global.findmono = 1;
  1660. break;
  1661.       case 'e':    /* echo to soundcard */
  1662.         if (!am_i_cdda2wav) break;
  1663. #ifdef ECHO_TO_SOUNDCARD
  1664. global.echo = 1;
  1665.         global.need_hostorder = 1;
  1666. #else
  1667. fprintf(stderr, "There is no sound support compiled into %s.n",argv[0]);
  1668. #endif
  1669. break;
  1670.       case 'v':    /* tell us more */
  1671.         if (!am_i_cdda2wav) break;
  1672. global.verbose = strtol( optarg, NULL, 10);
  1673. break;
  1674.       case 'q':    /* be quiet */
  1675.         if (!am_i_cdda2wav) break;
  1676. global.quiet = 1;
  1677. global.verbose = 0;
  1678. break;
  1679.       case 'N':    /* don't write to file */
  1680.         if (!am_i_cdda2wav) break;
  1681. global.no_file = 1;
  1682. global.no_infofile = 1;
  1683. global.no_cddbfile = 1;
  1684. break;
  1685.       case 'J':    /* information only */
  1686.         if (!am_i_cdda2wav) break;
  1687. global.verbose = SHOW_MAX;
  1688. just_the_toc = 1;
  1689. bulk = 1;
  1690. break;
  1691.       case 'g':    /* screen output formatted for guis */
  1692.         if (!am_i_cdda2wav) break;
  1693. #ifdef Thomas_will_es
  1694. global.no_file = 1;
  1695. global.no_infofile = 1;
  1696. global.no_cddbfile = 1;
  1697. global.verbose = SHOW_MAX;
  1698. #endif
  1699. global.gui = 1;
  1700. break;
  1701.       case 'Q':   /* silent scsi mode */
  1702. global.scsi_silent = 1;
  1703. break;
  1704.       case 'H':    /* don't write extra files */
  1705.         if (!am_i_cdda2wav) break;
  1706. global.no_infofile = 1;
  1707. global.no_cddbfile = 1;
  1708. break;
  1709.       case 'B':    /* bulk transfer */
  1710.         if (!am_i_cdda2wav) break;
  1711. bulk = 1;
  1712. break;
  1713.       case 'T':    /* do deemphasis on the samples */
  1714.         if (!am_i_cdda2wav) break;
  1715. global.deemphasize = 1;
  1716.         global.need_hostorder = 1;
  1717. break;
  1718.       case 'R':    /* list available rates */
  1719.         if (!am_i_cdda2wav) break;
  1720. { int ii;
  1721.   fprintf(stderr, "Cdda2wav version %s: available rates are:nRate   Divider      Rate   Divider      Rate   Divider      Rate   Dividern", VERSION );
  1722.   for (ii = 1; ii <= 44100 / 880 / 2; ii++) {
  1723.     long i2 = ii;
  1724.     fprintf(stderr, "%-7g  %2ld         %-7g  %2ld.5       ",
  1725.                     44100.0/i2,i2,44100/(i2+0.5),i2);
  1726.     i2 += 25;
  1727.     fprintf(stderr, "%-7g  %2ld         %-7g  %2ld.5n",
  1728.                     44100.0/i2,i2,44100/(i2+0.5),i2);
  1729.     i2 -= 25;
  1730.   }
  1731. }
  1732. exit(0);
  1733. break;
  1734.       case 'V':
  1735.         if (!am_i_cdda2wav) break;
  1736. global.scsi_verbose++; /* XXX nach open_scsi() scgp->verbose = .. !!!! */
  1737. break;
  1738.       case 'h':
  1739. usage();
  1740. break;
  1741.       default:
  1742. #ifdef USE_GETOPT_LONG
  1743. fputs ("use cdda2wav --help to get more information.n", stderr);
  1744. #else
  1745. fputs ("use cdda2wav -h to get more information.n", stderr);
  1746. #endif
  1747. exit (1);
  1748.     }
  1749.   }
  1751.   /* check all parameters */
  1752.   if (global.verbose < 0 || global.verbose > SHOW_MAX) {
  1753.     usage2("Incorrect verbose level setting: %d",global.verbose);
  1754.   }
  1755.   if (global.verbose == 0) global.quiet = 1;
  1757.   if ( rectime < 0.0 ) {
  1758.     usage2("Incorrect recording time setting: %d.%02d",
  1759. (int)rectime, (int)(rectime*100+0.5) % 100);
  1760.   }
  1762.   if ( global.channels != 1 && global.channels != 2 ) {
  1763.     usage2("Incorrect channel setting: %d",global.channels);
  1764.   }
  1766.   if ( bits != 8 && bits != 12 && bits != 16 ) {
  1767.     usage2("Incorrect bits_per_sample setting: %d",bits);
  1768.   }
  1770.   if ( rate < 827.0 || rate > 44100.0 ) {
  1771.     usage2("Incorrect sample rate setting: %d.%02d",
  1772. (int)rate, ((int)rate*100) % 100);
  1773.   }
  1775.   int_part = (double)(long) (2*44100.0 / rate);
  1776.   
  1777.   if (2*44100.0 / rate - int_part >= 0.5 ) {
  1778.       int_part += 1.0;
  1779.       fprintf( stderr, "Nearest available sample rate is %d.%02d Hertzn",
  1780.       2*44100 / (int)int_part,
  1781.       (2*4410000 / (int)int_part) % 100);
  1782.   }
  1783.   Halved = ((int) int_part) & 1;
  1784.   rate = 2*44100.0 / int_part;
  1785.   undersampling = (int) int_part / 2.0;
  1786.   samples_to_do = undersampling;
  1788.   if (!strcmp((char *)int_name,"generic_scsi"))
  1789.       interface = GENERIC_SCSI;
  1790.   else if (!strcmp((char *)int_name,"cooked_ioctl"))
  1791.       interface = COOKED_IOCTL;
  1792.   else  {
  1793.     usage2("Incorrect interface setting: %s",int_name);
  1794.   }
  1796.   /* If we need to calculate with samples or write them to a soundcard,
  1797.    * we need a conversion to host byte order.
  1798.    */ 
  1799.   if (global.channels != 2 
  1800.       || bits != 16
  1801.       || rate != 44100)
  1802. global.need_hostorder = 1;
  1804.   /* check * init audio file */
  1805.   if (!strncmp(audio_type,"wav",3)) {
  1806.     global.audio_out = &wavsound;
  1807.   } else if (!strncmp(audio_type, "sun", 3) || !strncmp(audio_type, "au", 2)) {
  1808.     /* Enhanced compatibility */
  1809.     strcpy(audio_type, "au");
  1810.     global.audio_out = &sunsound;
  1811.   } else if (!strncmp(audio_type, "cdr", 3) || 
  1812.              !strncmp(audio_type, "raw", 3)) {
  1813.     global.audio_out = &rawsound;
  1814.   } else if (!strncmp(audio_type, "aiff", 4)) {
  1815.     global.audio_out = &aiffsound;
  1816.   } else if (!strncmp(audio_type, "aifc", 4)) {
  1817.     global.audio_out = &aifcsound;
  1818.   } else {
  1819.     usage2("Incorrect audio type setting: %3s", audio_type);
  1820.   }
  1822.   global.need_big_endian = global.audio_out->need_big_endian;
  1823.   if (global.outputendianess != NONE)
  1824.     global.need_big_endian = global.outputendianess == BIG;
  1826.   if (global.no_file) global.fname_base[0] = '';
  1828.   if (!bulk) {
  1829.     strcat(global.fname_base, ".");
  1830.     strcat(global.fname_base, audio_type);
  1831.   }
  1833.   /*
  1834.    * all options processed.
  1835.    * Now a file name per track may follow 
  1836.    */
  1837.   argc2 = argc3 = argc - optind;
  1838.   argv2 = argv + optind;
  1839.   if ( optind < argc ) {
  1840.     if (!strcmp(argv[optind],"-")) {
  1841.       /*
  1842.        * pipe mode
  1843.        */
  1844.       if (bulk == 1) {
  1845.         fprintf(stderr, "bulk mode disabled while outputting to a pipen");
  1846.         bulk = 0;
  1847.       }
  1848. #if     defined(__CYGWIN32__) || defined(__EMX__)
  1849.       setmode(fileno(stdout), O_BINARY);
  1850. #endif
  1852.       global.audio = dup (fileno(stdout));
  1853.       strncpy( global.fname_base, "standard output", sizeof(global.fname_base) );
  1854.       global.fname_base[sizeof(global.fname_base)-1]=0;
  1855.       global.no_infofile = 1;
  1856.       global.no_cddbfile = 1;
  1857.     } else if (optind + 1 < argc) {
  1858. /* do we have more than one argument? */
  1859. global.multiname = 1;
  1860.     }
  1861.   }
  1863. #define SETSIGHAND(PROC, SIG, SIGNAME) if (signal(SIG, PROC) == SIG_ERR) 
  1864. { fprintf(stderr, "cannot set signal %s handlern", SIGNAME); exit(1); }
  1865.     SETSIGHAND(exit, SIGINT, "SIGINT")
  1866.     SETSIGHAND(exit, SIGQUIT, "SIGQUIT")
  1867.     SETSIGHAND(exit, SIGTERM, "SIGTERM")
  1868.     SETSIGHAND(exit, SIGHUP, "SIGHUP")
  1870.     SETSIGHAND(set_nonforked, SIGPIPE, "SIGPIPE")
  1873.   /* setup interface and open cdrom device */
  1874.   /* request sychronization facilities and shared memory */
  1875.   SetupInterface( );
  1876. #if defined(HAVE_SEMGET) && defined(USE_SEMAPHORES)
  1877.   atexit ( free_sem );
  1878. #endif
  1879.   /*
  1880.    * set input endian default
  1881.    */
  1882.   if (littleendian != -1)
  1883.     *in_lendian = littleendian;
  1885.   /* get table of contents */
  1886.   cdtracks = ReadToc( get_scsi_p(), g_toc );
  1887.   if (cdtracks == 0) {
  1888.     fprintf(stderr, "No track in table of contents! Aborting...n");
  1889.     exit(10);
  1890.   }
  1891.   if (ReadTocText != NULL) ReadTocText(get_scsi_p());
  1893.   handle_cdtext();
  1895.   calc_cddb_id();
  1896.   calc_cdindex_id();
  1897.   if ( global.verbose == SHOW_JUSTAUDIOTRACKS ) {
  1898.     unsigned int z;
  1900.     for (z = 0; z < cdtracks; z++)
  1901. if ((g_toc[z].bFlags & CDROM_DATA_TRACK) == 0)
  1902.   printf("%02dt%06un", g_toc[z].bTrack, g_toc[z].dwStartSector);
  1903.     exit(0);
  1904.   }
  1906.   if ( global.verbose != 0 ) {
  1907.     fputs( "#Cdda2wav version ", stderr );
  1908.     fputs( VERSION, stderr );
  1909. #if defined _POSIX_PRIORITY_SCHEDULING || defined HAVE_SYS_PRIOCNTL_H
  1910.     fputs( " real time sched.", stderr );
  1911. #endif
  1912. #if defined ECHO_TO_SOUNDCARD
  1913.     fputs( " soundcard support", stderr );
  1914. #endif
  1915.     fputs( "n", stderr );
  1916.   }
  1918.   have_CD_extra = FixupTOC(cdtracks + 1);
  1920.   if ( global.verbose & (SHOW_TOC | SHOW_STARTPOSITIONS) )
  1921.     DisplayToc ();
  1923.   /* use global.useroverlap to set our overlap */
  1924.   if (global.useroverlap != -1)
  1925. global.overlap = global.useroverlap;
  1927.   if (global.nsectors < 1+global.overlap) {
  1928.       usage2("Overlap (%d) is greater or equal than nsectors (%d)nUse -P to set the overlap sectors and -n to set the nsectors",global.overlap, global.nsectors);
  1929.   }
  1931.   /* try to get some extra kicks */
  1932.   needroot(0);
  1933. #if defined(HAVE_NICE) && (HAVE_NICE == 1)
  1934.   nice(-20);
  1935. #endif
  1936.   dontneedroot();
  1938.   /* switch cdrom to audio mode */
  1939.   EnableCdda (get_scsi_p(), 1);
  1941.   atexit ( CloseAll );
  1943.   if ( !FirstAudioTrack () )
  1944.     FatalError ( "This disk has no audio tracksn" );
  1946.   if ( global.verbose & (SHOW_MCN | SHOW_ISRC) )
  1947.     Read_MCN_ISRC();
  1949.   /* check if start track is in range */
  1950.   if ( track < 1 || track > cdtracks ) {
  1951.     usage2("Incorrect start track setting: %d",track);
  1952.   }
  1954.   /* check if end track is in range */
  1955.   if ( endtrack < track || endtrack > cdtracks ) {
  1956.     usage2("Incorrect end track setting: %ld",endtrack);
  1957.   }
  1959.   do {
  1960.     lSector = GetStartSector ( track );
  1961.     lSector_p1 = GetEndSector ( track ) + 1;
  1963.     if ( lSector < 0 ) {
  1964.       if ( bulk == 0 ) {
  1965.         FatalError ( "track %d not foundn", track );
  1966.       } else {
  1967.         fprintf(stderr, "Skipping data track %d...n", track);
  1968. if (endtrack == track) endtrack++;
  1969.         track++;
  1970.       }
  1971.     }
  1972.   } while (bulk != 0 && track <= cdtracks && lSector < 0);
  1974.   if (cd_index != -1) {
  1975.     if (global.verbose && !global.quiet) {
  1976.       global.verbose |= SHOW_INDICES;
  1977.     }
  1978.     sector_offset += ScanIndices( track, cd_index, bulk );
  1979.   } else {
  1980.     cd_index = 1;
  1981.     if (global.verbose & SHOW_INDICES) {
  1982.       ScanIndices( track, cd_index, bulk );
  1983.     }
  1984.   }
  1986.   lSector += sector_offset;
  1987.   /* check against end sector of track */
  1988.   if ( lSector >= lSector_p1 ) {
  1989.     fputs( "sector offset exceeds track size (ignored)n", stderr );
  1990.     lSector -= sector_offset;
  1991.   }
  1993.   if ( lSector < 0L ) {
  1994.     fputs( "negative start sector! Set to zero.n", stderr );
  1995.     lSector = 0L;
  1996.   }
  1998.   lSector_p2 = GetLastSectorOnCd( track );
  1999.   if (bulk == 1 && track == endtrack && rectime == 0.0)
  2000.      rectime = 99999.0;
  2001.   if ( rectime == 0.0 ) {
  2002.     /* set time to track time */
  2003.     nSamplesToDo = (lSector_p1 - lSector) * CD_FRAMESAMPLES;
  2004.     rectime = (lSector_p1 - lSector) / 75.0;
  2005.     if (CheckTrackrange( track, endtrack) == 1) {
  2006.       lSector_p2 = GetEndSector ( endtrack ) + 1;
  2008.       if (lSector_p2 >= 0) {
  2009.         rectime = (lSector_p2 - lSector) / 75.0;
  2010.         nSamplesToDo = (long)(rectime*44100.0 + 0.5);
  2011.       } else {
  2012.         fputs( "end track is no valid audio track (ignored)n", stderr );
  2013.       }
  2014.     } else {
  2015.       fputs( "track range does not consist of audio tracks only (ignored)n", stderr );
  2016.     }
  2017.   } else {
  2018.     /* Prepare the maximum recording duration.
  2019.      * It is defined as the biggest amount of
  2020.      * adjacent audio sectors beginning with the
  2021.      * specified track/index/offset. */
  2023.     if ( rectime > (lSector_p2 - lSector) / 75.0 ) {
  2024.       rectime = (lSector_p2 - lSector) / 75.0;
  2025.       lSector_p1 = lSector_p2;
  2026.     }
  2028.     /* calculate # of samples to read */
  2029.     nSamplesToDo = (long)(rectime*44100.0 + 0.5);
  2030.   }
  2032.   global.OutSampleSize = (1+bits/12);
  2033.   if (nSamplesToDo/undersampling == 0L) {
  2034.       usage2("Time interval is too short. Choose a duration greater than %d.%02d secs!", 
  2035.        undersampling/44100, (int)(undersampling/44100) % 100);
  2036.   }
  2037.   SamplesToWrite = nSamplesToDo*2/(int)int_part;
  2039.   tracks_included = GetTrack(
  2040.       (unsigned) (lSector + nSamplesToDo/CD_FRAMESAMPLES -1))
  2041.      - track + 1;
  2042.   if ( !waitforsignal ) {
  2044.       if (global.multiname != 0 && optind + tracks_included > argc) {
  2045. global.multiname = 0;
  2046.       }
  2048. #ifdef INFOFILES
  2049.       if (!global.no_infofile) {
  2050. int i;
  2052. for (i = track; i < track + tracks_included; i++) {
  2053. unsigned minsec, maxsec;
  2054.         char *tmp_fname;
  2056.         /* build next filename */
  2058.         tmp_fname = get_next_name();
  2059.         if (tmp_fname != NULL)
  2060.   strncpy( global.fname_base, tmp_fname, sizeof(global.fname_base)-8 );
  2061.   global.fname_base[sizeof(global.fname_base)-1]=0;
  2062. minsec = max(lSector, GetStartSector(i));
  2063. maxsec = min(lSector_p2, 1+GetEndSector(i));
  2064. write_info_file(global.fname_base,i,(maxsec-minsec)*CD_FRAMESAMPLES, bulk && global.multiname == 0);
  2065. if (!bulk) break;
  2066. }
  2067. reset_name_iterator();
  2068.       }
  2069. #endif
  2071.   }
  2073.   if (just_the_toc) exit(0);
  2075. #ifdef  ECHO_TO_SOUNDCARD
  2076.   if (user_sound_device[0] != '') {
  2077.       set_snd_device(user_sound_device);
  2078.   }
  2079.   init_soundcard(rate, bits);
  2080. #endif /* ECHO_TO_SOUNDCARD */
  2082.   if (global.userspeed > -1)
  2083.      global.speed = global.userspeed;
  2085.   if (global.speed != 0 && SelectSpeed != NULL) {
  2086.      SelectSpeed(get_scsi_p(), global.speed);
  2087.   }
  2089.   current_track = track;
  2091.   if ( !global.no_file ) {
  2092.     {
  2093.       char *myfname;
  2095.       myfname = get_next_name();
  2097.       if (myfname != NULL) {
  2098.         strncpy( global.fname_base, myfname, sizeof(global.fname_base)-8 );
  2099.         global.fname_base[sizeof(global.fname_base)-1]=0;
  2100.       }
  2101.     }
  2103.     /* strip audio_type extension */
  2104.     {
  2105.       char *cp = global.fname_base;
  2107.       cp = strrchr(cp, '.');
  2108.       if (cp == NULL) {
  2109. cp = global.fname_base + strlen(global.fname_base);
  2110.       }
  2111.       *cp = '';
  2112.     }
  2113.     if (bulk && global.multiname == 0) {
  2114.       sprintf(fname, "%s_%02u.%s",global.fname_base,current_track,audio_type);
  2115.     } else {
  2116.       sprintf(fname, "%s.%s",global.fname_base,audio_type);
  2117.     }
  2119.     OpenAudio( fname, rate, bits, global.channels, 
  2120.       (unsigned)(SamplesToWrite*global.OutSampleSize*global.channels),
  2121. global.audio_out);
  2122.   }
  2124.   global.Remainder = (75 % global.nsectors)+1;
  2126.   global.sh_bits = 16 - bits; /* shift counter */
  2128.   global.iloop = nSamplesToDo;
  2129.   if (Halved && (global.iloop&1))
  2130.       global.iloop += 2;
  2132.   BeginAtSample = lSector * CD_FRAMESAMPLES;
  2134.   if ( 1 ) {
  2135.       if ( (global.verbose & SHOW_SUMMARY) && !just_the_toc ) {
  2136. fprintf(stderr, "samplefile size will be %lu bytes.n",
  2137.            global.audio_out->GetHdrSize() + SamplesToWrite*global.OutSampleSize*global.channels  ); 
  2138.         fprintf (stderr, "recording %d.%05d seconds %s with %d bits @ %5d.%01d Hz"
  2139.       ,(int)rectime , (int)(rectime * 10000) % 10000,
  2140.       global.channels == 1 ? "mono":"stereo", bits, (int)rate, (int)(rate*10)%10);
  2141.         if (!global.no_file && *global.fname_base)
  2142. fprintf(stderr, " ->'%s'...", global.fname_base );
  2143.         fputs("n", stderr);
  2144.       }
  2145.   }
  2146. #if defined(HAVE_SEMGET) && defined(USE_SEMAPHORES)
  2147. #else
  2148.   init_pipes();
  2149. #endif
  2151. #if defined(HAVE_FORK_AND_SHAREDMEM)
  2153.   /* Everything is set up. Now fork and let one process read cdda sectors
  2154.      and let the other one store them in a wav file */
  2156.   /* forking */
  2157.   child_pid = fork();
  2158.   if (child_pid > 0 && global.gui > 0 && global.verbose > 0) fprintf( stderr, "child pid is %dn", child_pid);
  2160.   /*********************** fork **************************************/
  2161.   if (child_pid == 0) {
  2162.     /* child WRITER section */
  2164. #ifdef __EMX__
  2165.     if (DosGetSharedMem(fill_buffer, 3)) {
  2166.       comerr("DosGetSharedMem() failed.n");
  2167.     }
  2168. #endif
  2169.     global.have_forked = 1;
  2170.     forked_write();
  2171. #ifdef __EMX__
  2172.     DosFreeMem(fill_buffer);
  2173.     _exit(0);
  2174. #endif
  2175.     exit(0);
  2176.   } else if (child_pid > 0) {
  2177.     /* parent READER section */
  2178.     
  2179.     global.have_forked = 1;
  2180.     switch_to_realtime_priority();
  2182.     forked_read();
  2183. #ifdef __EMX__
  2184.     DosFreeMem(fill_buffer);
  2185. #endif
  2186.     exit(0);
  2187.   } else
  2188. #else
  2189.   /* version without fork */
  2190.   {
  2191.     global.have_forked = 0;
  2192.     switch_to_realtime_priority();
  2194.     fprintf(stderr, "a nonforking version is running...n");
  2195.     nonforked_loop();
  2196.     exit(0);
  2197.   }
  2198. #endif
  2200.   return 0;
  2201. }