/*

  Copyright (C) 2004-2012, 2014-2015, 2017 Rocky Bernstein <rocky@gnu.org>

  Copyright (C) 2014 Robert Kausch <robert.kausch@freac.org>

  Copyright (C) 1998 Monty <xiphmont@mit.edu>

  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 3 of the License, 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, see <http://www.gnu.org/licenses/>.

  See ChangeLog for recent changes.

*/

#ifdef HAVE_CONFIG_H

# include "config.h"

# define __CDIO_CONFIG_H__ 1

#endif

#ifdef HAVE_STDIO_H

# include <stdio.h>

#endif

#ifdef HAVE_STDARG_H

# include <stdarg.h>

#endif

#ifdef HAVE_LIMITS_H

#include <limits.h>

#endif

#ifndef PATH_MAX

# ifdef MAXPATHLEN

#  define PATH_MAX MAXPATHLEN

# else

#  define PATH_MAX 4096

# endif

#endif

#ifdef HAVE_STDLIB_H

# include <stdlib.h>

#endif

#ifdef HAVE_UNISTD_H

# include <unistd.h>

#endif

#ifdef HAVE_STRING_H

# include <string.h>

#endif

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#include "getopt.h"

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifndef ENOMEDIUM

#define ENOMEDIUM -1

#endif

#include <math.h>

#include <sys/time.h>

#ifdef HAVE_SYS_STAT_H

# include <sys/stat.h>

#endif

#if !defined(HAVE_GETTIMEOFDAY)

/* MinGW uses sys/time.h and sys/timeb.h to roll its own gettimeofday() */

# if defined(HAVE_SYS_TIME_H) && defined(HAVE_SYS_TIMEB_H)

# include <sys/time.h>

# include <sys/timeb.h>

static void gettimeofday(struct timeval* tv, void* timezone);

# endif

#endif /* !defined(HAVE_GETTIMEOFDAY) */

#include <cdio/cdio.h>

#include <cdio/cd_types.h>

#include <cdio/paranoia/cdda.h>

#include <cdio/paranoia/paranoia.h>

#include <cdio/bytesex.h>

#include <cdio/mmc.h>

#include "utils.h"

#include "report.h"

#include "version.h"

#include "header.h"

#include "buffering_write.h"

#include "cachetest.h"

#ifndef O_BINARY

#define O_BINARY 0

#endif

/* I wonder how many alignment issues this is gonna trip in the

   future...  it shouldn't trip any...  I guess we'll find out :) */

static int

bigendianp(void)

{

  int test=1;

  char *hack=(char *)(&test);

  if(hack[0])return(0);

  return(1);

}

static long

parse_offset(cdrom_drive_t *d, char *offset, int begin)

{

  track_t i_track= CDIO_INVALID_TRACK;

  long hours   = -1;

  long minutes = -1;

  long seconds = -1;

  long sectors = -1;

  char *time   = NULL;

  char *temp   = NULL;

  long ret;

  if (!offset) return -1;

  /* separate track from time offset */

  temp=strchr(offset,']');

  if(temp){

    *temp='\0';

    temp=strchr(offset,'[');

    if(temp==NULL){

      report("Error parsing span argument");

      exit(1);

    }

    *temp='\0';

    time=temp+1;

  }

  /* parse track */

  {

    int chars=strspn(offset,"0123456789");

    if(chars>0){

      offset[chars]='\0';

      i_track=atoi(offset);

      if ( i_track > d->tracks ) {

        /*take track i_first_track-1 as pre-gap of 1st track*/

	report("Track #%d does not exist.",i_track);

        exit(1);

      }

    }

  }

  while(time){

    long val,chars;

    char *sec=strrchr(time,'.');

    if(!sec)sec=strrchr(time,':');

    if(!sec)sec=time-1;

    chars=strspn(sec+1,"0123456789");

    if(chars)

      val=atoi(sec+1);

    else

      val=0;

    switch(*sec){

    case '.':

      if(sectors!=-1){

        report("Error parsing span argument");

        exit(1);

      }

      sectors=val;

      break;

    default:

      if(seconds==-1)

        seconds=val;

      else

        if(minutes==-1)

          minutes=val;

        else

          if(hours==-1)

            hours=val;

          else{

            report("Error parsing span argument");

            exit(1);

          }

      break;

    }

    if (sec<=time) break;

    *sec='\0';

  }

  if (i_track == CDIO_INVALID_TRACK) {

    if (seconds==-1 && sectors==-1) return -1;

    if (begin==-1) {

      ret=cdda_disc_firstsector(d);

    } else

      ret = begin;

  } else {

    if ( seconds==-1 && sectors==-1 ) {

      if (begin==-1){

        /* first half of a span */

        return(cdda_track_firstsector(d, i_track));

      }else{

        return(cdda_track_lastsector(d, i_track));

      }

    } else {

      /* relative offset into a track */

      ret=cdda_track_firstsector(d, i_track);

    }

  }

  /* OK, we had some sort of offset into a track */

  if (sectors != -1) ret += sectors;

  if (seconds != -1) ret += seconds*CDIO_CD_FRAMES_PER_SEC;

  if (minutes != -1) ret += minutes*CDIO_CD_FRAMES_PER_MIN;

  if (hours   != -1) ret += hours  *60*CDIO_CD_FRAMES_PER_MIN;

  /* We don't want to outside of the track; if it's relative, that's OK... */

  if( i_track != CDIO_INVALID_TRACK ){

    if (cdda_sector_gettrack(d,ret) != i_track) {

      report("Time/sector offset goes beyond end of specified track.");

      exit(1);

    }

  }

  /* Don't pass up end of session */

  if( ret>cdda_disc_lastsector(d) ) {

    report("Time/sector offset goes beyond end of disc.");

    exit(1);

  }

  return(ret);

}

static void

display_toc(cdrom_drive_t *d)

{

  long audiolen=0;

  track_t i;

  report("\nTable of contents (audio tracks only):\n"

         "track        length               begin        copy pre ch\n"

         "===========================================================");

  for( i=1; i<=d->tracks; i++)

    if ( cdda_track_audiop(d,i) > 0 ) {

      lsn_t sec=cdda_track_firstsector(d,i);

      lsn_t off=cdda_track_lastsector(d,i)-sec+1;

      report("%3d.  %7ld [%02d:%02d.%02d]  %7ld [%02d:%02d.%02d]  %s %s %s",

	     i,

	     (long int) off,

             (int) (off/(CDIO_CD_FRAMES_PER_MIN)),

             (int) ((off/CDIO_CD_FRAMES_PER_SEC) % CDIO_CD_SECS_PER_MIN),

             (int) (off % CDIO_CD_FRAMES_PER_SEC),

	     (long int) sec,

             (int) (sec/(CDIO_CD_FRAMES_PER_MIN)),

             (int) ((sec/CDIO_CD_FRAMES_PER_SEC) % CDIO_CD_SECS_PER_MIN),

             (int) (sec % CDIO_CD_FRAMES_PER_SEC),

	     cdda_track_copyp(d,i)?"  OK":"  no",

	     cdda_track_preemp(d,i)?" yes":"  no",

	     cdda_track_channels(d,i)==2?" 2":" 4");

      audiolen+=off;

    }

  report("TOTAL %7ld [%02d:%02d.%02d]    (audio only)",

	 audiolen,

         (int) (audiolen/(CDIO_CD_FRAMES_PER_MIN)),

         (int) ((audiolen/CDIO_CD_FRAMES_PER_SEC) % CDIO_CD_SECS_PER_MIN),

	 (int) (audiolen % CDIO_CD_FRAMES_PER_SEC));

  report(" ");

}

#include "usage.h"

static void usage(FILE *f)

{

  fprintf( f, usage_help);

}

static long callbegin;

static long callend;

static long callscript=0;

static int skipped_flag=0;

static int abort_on_skip=0;

static FILE *logfile = NULL;

static int logfile_open=0;

static int reportfile_open=0;

#if TRACE_PARANOIA

static void

callback(long int inpos, paranoia_cb_mode_t function)

{

}

#else

static const char *callback_strings[16]={

  "read",

  "verify",

  "jitter",

  "correction",

  "scratch",

  "scratch repair",

  "skip",

  "drift",

  "backoff",

  "overlap",

  "dropped",

  "duped",

  "transport error",

  "cache error",

  "wrote",

  "finished",

};

static void

callback(long int inpos, paranoia_cb_mode_t function)

{

  /*

 (== PROGRESS == [--+!---x-------------->           | 007218 01 ] == :-) . ==)

 */

  int graph=30;

  char buffer[256];

  static long c_sector=0, v_sector=0;

  static char dispcache[]="                              ";

  static int last=0;

  static long lasttime=0;

  long int sector, osector=0;

  struct timeval thistime;

  static char heartbeat=' ';

  int position=0,aheadposition=0;

  static int overlap=0;

  static int printit=-1;

  static int slevel=0;

  static int slast=0;

  static int stimeout=0;

  static int cacheerr=0;

  const char *smilie="= :-)";

  if (callscript)

    fprintf(stderr, "##: %d [%s] @ %ld\n",

            function, ((int) function >= 0 && (int) function < 16 ?

                       callback_strings[function] : ""),

            inpos);

  else{

    if(function==PARANOIA_CB_CACHEERR){

      if(!cacheerr){

	fprintf(stderr,

		"\rWARNING: The CDROM drive appears to be seeking impossibly quickly.\n"

		"This could be due to timer bugs, a drive that really is improbably fast,\n"

		"or, most likely, a bug in cdparanoia's cache modelling.\n\n"

		"Please consider using the -A option to perform an analysis run, then mail\n"

		"the cdparanoia.log file produced by the analysis to paranoia-dev@xiph.org\n"

		"to assist developers in correcting the problem.\n\n");

      }

      cacheerr++;

    }

  }

  if(!quiet){

    long test;

    osector=inpos;

    sector=inpos/CD_FRAMEWORDS;

    if(printit==-1){

       if(isatty(STDERR_FILENO) || (logfile != NULL)){

        printit=1;

      }else{

        printit=0;

      }

    }

    if(printit==1){  /* else don't bother; it's probably being

                        redirected */

      position=((float)(sector-callbegin)/

                (callend-callbegin))*graph;

      aheadposition=((float)(c_sector-callbegin)/

                     (callend-callbegin))*graph;

      if(function == PARANOIA_CB_WROTE){

        v_sector=sector;

        return;

      }

      if (function == PARANOIA_CB_FINISHED) {

        last=8;

        heartbeat='*';

        slevel=0;

        v_sector=sector;

      } else

        if(position<graph && position>=0)

          switch(function){

          case PARANOIA_CB_VERIFY:

            if(stimeout>=30){

              if(overlap>CD_FRAMEWORDS)

                slevel=2;

              else

                slevel=1;

            }

            break;

          case PARANOIA_CB_READ:

            if(sector>c_sector)c_sector=sector;

            break;

          case PARANOIA_CB_FIXUP_EDGE:

            if(stimeout>=5){

              if(overlap>CD_FRAMEWORDS)

                slevel=2;

              else

                slevel=1;

            }

            if(dispcache[position]==' ')

              dispcache[position]='-';

            break;

          case PARANOIA_CB_FIXUP_ATOM:

            if(slevel<3 || stimeout>5)slevel=3;

            if(dispcache[position]==' ' ||

               dispcache[position]=='-')

              dispcache[position]='+';

            break;

          case PARANOIA_CB_READERR:

            slevel=6;

	    if(dispcache[position]!='V' && dispcache[position]!='C')

              dispcache[position]='e';

            break;

	  case PARANOIA_CB_CACHEERR:

	    slevel=8;

	    dispcache[position]='C';

	    break;

          case PARANOIA_CB_SKIP:

            slevel=8;

	    if(dispcache[position]!='C')

	      dispcache[position]='V';

            break;

          case PARANOIA_CB_OVERLAP:

            overlap=osector;

            break;

          case PARANOIA_CB_SCRATCH:

            slevel=7;

            break;

          case PARANOIA_CB_DRIFT:

            if(slevel<4 || stimeout>5)slevel=4;

            break;

          case PARANOIA_CB_FIXUP_DROPPED:

          case PARANOIA_CB_FIXUP_DUPED:

            slevel=5;

            if(dispcache[position]==' ' ||

               dispcache[position]=='-' ||

               dispcache[position]=='+')

              dispcache[position]='!';

            break;

          case PARANOIA_CB_REPAIR:

          case PARANOIA_CB_BACKOFF:

            break;

          case PARANOIA_CB_WROTE:

          case PARANOIA_CB_FINISHED:

	    /* Handled above */

	    ;

          }

      switch(slevel){

      case 0:  /* finished, or no jitter */

        if(skipped_flag)

          smilie=" 8-X";

        else

          smilie=" :^D";

        break;

      case 1:  /* normal.  no atom, low jitter */

        smilie=" :-)";

        break;

      case 2:  /* normal, overlap > 1 */

        smilie=" :-|";

        break;

      case 4:  /* drift */

        smilie=" :-/";

        break;

      case 3:  /* unreported loss of streaming */

        smilie=" :-P";

        break;

      case 5:  /* dropped/duped bytes */

        smilie=" 8-|";

        break;

      case 6:  /* scsi error */

        smilie=" :-0";

        break;

      case 7:  /* scratch */

        smilie=" :-(";

        break;

      case 8:  /* skip */

        smilie=" ;-(";

        skipped_flag=1;

        break;

      }

      gettimeofday(&thistime,NULL);

      test=thistime.tv_sec*10+thistime.tv_usec/100000;

      if (lasttime!=test || function == PARANOIA_CB_FINISHED

	  || slast!=slevel ) {

        if (lasttime!=test || function == PARANOIA_CB_FINISHED) {

          last++;

          lasttime=test;

          if(last>7)last=0;

          stimeout++;

          switch(last){

          case 0:

            heartbeat=' ';

            break;

          case 1:case 7:

            heartbeat='.';

            break;

          case 2:case 6:

            heartbeat='o';

            break;

          case 3:case 5:

            heartbeat='0';

            break;

          case 4:

            heartbeat='O';

            break;

          }

          if(function == PARANOIA_CB_FINISHED)

            heartbeat='*';

        }

        if(slast!=slevel){

          stimeout=0;

        }

        slast=slevel;

        if (abort_on_skip && skipped_flag

	    && function != PARANOIA_CB_FINISHED ) {

          sprintf(buffer,

                  "\r (== PROGRESS == [%s| %06ld %02d ] ==%s %c ==)   ",

                  "  ...aborting; please wait... ",

                  v_sector,overlap/CD_FRAMEWORDS,smilie,heartbeat);

        }else{

          if(v_sector==0)

            sprintf(buffer,

                    "\r (== PROGRESS == [%s| ...... %02d ] ==%s %c ==)   ",

                    dispcache,overlap/CD_FRAMEWORDS,smilie,heartbeat);

          else

            sprintf(buffer,

                    "\r (== PROGRESS == [%s| %06ld %02d ] ==%s %c ==)   ",

                    dispcache,v_sector,overlap/CD_FRAMEWORDS,smilie,heartbeat);

          if ( aheadposition>=0 && aheadposition

	       !(function == PARANOIA_CB_FINISHED) )

            buffer[aheadposition+19]='>';

        }

        if(isatty(STDERR_FILENO))

            fprintf(stderr, "%s", buffer);

        if (logfile != NULL && function == PARANOIA_CB_FINISHED) {

          fprintf(logfile, "%s", buffer+1);

          fprintf(logfile,"\n\n");

          fflush(logfile);

        }

      }

    }

  }

  /* clear the indicator for next batch */

  if(function == PARANOIA_CB_FINISHED)

    memset(dispcache,' ',graph);

}

#endif /* !TRACE_PARANOIA */

static const char optstring[] = "aBcCd:eEfFg:k:hi:l:L:Am:n:o:O:pqQrRsS:Tt:VvwWx:XYZz::";

static const struct option options [] = {

        {"abort-on-skip",             no_argument,       NULL, 'X'},

	{"analyze-drive",             no_argument,       NULL, 'A'},

        {"batch",                     no_argument,       NULL, 'B'},

        {"disable-extra-paranoia",    no_argument,       NULL, 'Y'},

        {"disable-fragmentation",     no_argument,       NULL, 'F'},

        {"disable-paranoia",          no_argument,       NULL, 'Z'},

        {"force-cdrom-big-endian",    no_argument,       NULL, 'C'},

        {"force-cdrom-device",        required_argument, NULL, 'd'},

        {"force-cdrom-little-endian", no_argument,       NULL, 'c'},

        {"force-default-sectors",     required_argument, NULL, 'n'},

        {"force-cooked-device",       required_argument, NULL, 'k'},

        {"force-generic-device",      required_argument, NULL, 'g'},

        {"force-read-speed",          required_argument, NULL, 'S'},

        {"force-search-overlap",      required_argument, NULL, 'o'},

	{"force-overread",            no_argument,       NULL, 'E'},

        {"help",                      no_argument,       NULL, 'h'},

        {"log-summary",               required_argument, NULL, 'l'},

        {"log-debug",                 required_argument, NULL, 'L'},

        {"mmc-timeout",               required_argument, NULL, 'm'},

        {"never-skip",                optional_argument, NULL, 'z'},

        {"output-aifc",               no_argument,       NULL, 'a'},

        {"output-aiff",               no_argument,       NULL, 'f'},

        {"output-raw",                no_argument,       NULL, 'p'},

        {"output-raw-big-endian",     no_argument,       NULL, 'R'},

        {"output-raw-little-endian",  no_argument,       NULL, 'r'},

        {"output-wav",                no_argument,       NULL, 'w'},

        {"query",                     no_argument,       NULL, 'Q'},

        {"quiet",                     no_argument,       NULL, 'q'},

        {"sample-offset",             required_argument, NULL, 'O'},

        {"stderr-progress",           no_argument,       NULL, 'e'},

        {"test-mode",                 required_argument, NULL, 'x'},

        {"toc-bias",                  no_argument,       NULL, 'T'},

        {"toc-offset",                required_argument, NULL, 't'},

        {"verbose",                   no_argument,       NULL, 'v'},

        {"version",                   no_argument,       NULL, 'V'},

        {NULL,0,NULL,0}

};

static cdrom_drive_t    *d        = NULL;

static cdrom_paranoia_t *p        = NULL;

static char             *span     = NULL;

static char *force_cdrom_device   = NULL;

#define free_and_null(p) \

  free(p);               \

  p=NULL;

#if !defined(HAVE_GETTIMEOFDAY) && defined(HAVE_SYS_TIME_H) && defined(HAVE_SYS_TIMEB_H)

static void

gettimeofday(struct timeval* tv, void* timezone)

{

  struct timeb timebuffer;

  ftime( &timebuffer );

  tv->tv_sec=timebuffer.time;

  tv->tv_usec=1000*timebuffer.millitm;

}

#endif

/* This is run automatically before leaving the program.

   Free allocated resources.

*/

static void

cleanup (void)

{

  if (p) paranoia_free(p);

  if (d) cdda_close(d);

  free_and_null(force_cdrom_device);

  free_and_null(span);

  if(logfile_open) {

      fclose(logfile);

      logfile = NULL;

    }

  if(reportfile_open) {

      fclose(reportfile);

      reportfile = NULL;

    }

}

/* Returns true if we have an integer argument.

   If so, pi_arg is set.

   If no argument or integer argument found, we give an error

   message and return false.

*/

static bool

get_int_arg(char c, long int *pi_arg)

{

  long int i_arg;

  char *p_end;

  if (!optarg) {

    /* This shouldn't happen, but we'll check anyway. */

    fprintf(stderr,

            "An (integer) argument for option -%c was expected "

            " but not found. Option ignored\n", c);

    return false;

  }

  errno = 0;

  i_arg = strtol(optarg, &p_end, 10);

  if ( (LONG_MIN == i_arg || LONG_MAX == i_arg) && (0 != errno) ) {

    fprintf(stderr,

            "Value '%s' for option -%c out of range. Value %ld "

            "used instead.\n", optarg, c, i_arg);

    *pi_arg = i_arg;

    return false;

  } else if (*p_end) {

    fprintf(stderr,

            "Can't convert '%s' for option -%c completely into an integer. "

            "Option ignored.\n", optarg, c);

    return false;

  } else {

    *pi_arg = i_arg;

    return true;

  }

}

int

main(int argc,char *argv[])

{

  int   toc_bias             =  0;

  int   force_cdrom_endian   = -1;

  int   output_type          =  1; /* 0=raw, 1=wav, 2=aifc */

  int   output_endian        =  0; /* -1=host, 0=little, 1=big */

  int   query_only           =  0;

  int   batch                =  0;

  int   run_cache_test       =  0;

  long int force_cdrom_overlap  = -1;

  long int force_cdrom_sectors  = -1;

  long int force_cdrom_speed    =  0;

  long int force_overread       =  0;

  long int sample_offset        =  0;

  long int test_flags           =  0;

  long int toc_offset           =  0;

  long int max_retries          = 20;

  char *logfile_name=NULL;

  char *reportfile_name=NULL;

  /* full paranoia, but allow skipping */

  int paranoia_mode=PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP;

  int out;

  int c,long_option_index;

  atexit(cleanup);

  while((c=getopt_long(argc,argv,optstring,options,&long_option_index))!=EOF){

    switch(c){

    case 'a':

      output_type=2;

      output_endian=1;

      break;

    case 'B':

      batch=1;

      break;

    case 'c':

      force_cdrom_endian=0;

      break;

    case 'C':

      force_cdrom_endian=1;

      break;

    case 'e':

      callscript=1;

      fprintf(stderr,

              "Sending all callback output to stderr for wrapper script\n");

      break;

    case 'f':

      output_type=3;

      output_endian=1;

      break;

    case 'F':

      paranoia_mode&=~(PARANOIA_MODE_FRAGMENT);

      break;

    case 'g':

    case 'k':

    case 'd':

      if (force_cdrom_device) {

        fprintf(stderr,

                "Multiple cdrom devices given. Previous device %s ignored\n",

                force_cdrom_device);

        free(force_cdrom_device);

      }

      force_cdrom_device=strdup(optarg);

      break;

    case 'h':

      usage(stdout);

      exit(0);

    case 'l':

      if(logfile_name)free(logfile_name);

      logfile_name=NULL;

      if(optarg)

	logfile_name=strdup(optarg);

      logfile_open=1;

      break;

    case 'L':

      if(reportfile_name)free(reportfile_name);

      reportfile_name=NULL;

      if(optarg)

	reportfile_name=strdup(optarg);

      reportfile_open=1;

      break;

    case 'm':

      {

        long int mmc_timeout_sec;

        if (get_int_arg(c, &mmc_timeout_sec)) {

          mmc_timeout_ms = 1000*mmc_timeout_sec;

        }

      }

      break;

    case 'n':

      get_int_arg(c, &force_cdrom_sectors);

      break;

    case 'o':

      get_int_arg(c, &force_cdrom_overlap);

      break;

    case 'O':

      get_int_arg(c, &sample_offset);

      break;

    case 'p':

      output_type=0;

      output_endian=-1;

      break;

    case 'r':

      output_type=0;

      output_endian=0;

      break;

    case 'q':

      verbose=CDDA_MESSAGE_FORGETIT;

      quiet=1;

      break;

    case 'Q':

      query_only=1;

      break;

    case 'R':

      output_type=0;

      output_endian=1;

      break;

    case 'S':

      get_int_arg(c, &force_cdrom_speed);

      break;

    case 't':

      get_int_arg(c, &toc_offset);

      break;

    case 'T':

      toc_bias=-1;

      break;

    case 'v':

      verbose=CDDA_MESSAGE_PRINTIT;

      quiet=0;

      break;

    case 'V':

      fprintf(stderr,PARANOIA_VERSION);

      fprintf(stderr,"\n");

      exit(0);

      break;

    case 'w':

      output_type=1;

      output_endian=0;

      break;

    case 'W':

      paranoia_mode&=~PARANOIA_MODE_REPAIR;

      break;

    case 'x':

      get_int_arg(c, &test_flags);

      break;

    case 'X':

      /*paranoia_mode&=~(PARANOIA_MODE_SCRATCH|PARANOIA_MODE_REPAIR);*/

      abort_on_skip=1;

      break;

    case 'Y':

      paranoia_mode|=PARANOIA_MODE_OVERLAP; /* cdda2wav style overlap

                                                check only */

      paranoia_mode&=~PARANOIA_MODE_VERIFY;

      break;

    case 'Z':

      paranoia_mode=PARANOIA_MODE_DISABLE;

      break;

    case 'A':

      run_cache_test=1;

      query_only=1;

      reportfile_open=1;

      verbose=CDDA_MESSAGE_PRINTIT;

      break;

    case 'z':

      if (optarg) {

        get_int_arg(c, &max_retries);

        paranoia_mode&=~PARANOIA_MODE_NEVERSKIP;

      } else {

        paranoia_mode|=PARANOIA_MODE_NEVERSKIP;

      }

      break;

    case 'E':

      force_overread=1;

      break;