/*
  Copyright (C) 2004, 2005, 2007, 2008 Rocky Bernstein <rocky@gnu.org>
  Copyright (C) 2014 Robert Kausch <robert.kausch@freac.org>
  Original interface.c Copyright (C) 1994-1997
             Eissfeldt heiko@colossus.escape.de
  Current blenderization Copyright (C) 1998-1999 Monty xiphmont@mit.edu
  Copyright (C) 1998 Monty xiphmont@mit.edu
*/
/**

  CD-ROM code which interfaces between user-level visible CD paranoia
  routines and libddio routines. (There is some GNU/Linux-specific
  code here too that should probably be removed.

**/

#include "config.h"
#include "common_interface.h"
#include "low_interface.h"
#include "utils.h"

/** The below variables are trickery to force the above enum symbol
    values to be recorded in debug symbol tables. They are used to
    allow one to refer to the enumeration value names in the typedefs
    above in a debugger and debugger expressions
*/

paranoia_jitter_t     debug_paranoia_jitter;
paranoia_cdda_enums_t debug_paranoia_cdda_enums;

/*! reads TOC via libcdio and returns the number of tracks in the disc.
    0 is returned if there was an error.
*/
static int
cddap_readtoc (cdrom_drive_t *d)
{
  int i;
  track_t i_track;

  /* Save TOC Entries */
  d->tracks = cdio_get_num_tracks(d->p_cdio) ;

  if (CDIO_INVALID_TRACK == d->tracks) return 0;

  i_track   = cdio_get_first_track_num(d->p_cdio);

  for ( i=0; i < d->tracks; i++) {
    d->disc_toc[i].bTrack = i_track;
    d->disc_toc[i].dwStartSector = cdio_get_track_lsn(d->p_cdio, i_track);
    i_track++;
  }

  d->disc_toc[i].bTrack = i_track;
  d->disc_toc[i].dwStartSector = cdio_get_track_lsn(d->p_cdio,
						    CDIO_CDROM_LEADOUT_TRACK);

  d->cd_extra=FixupTOC(d, d->tracks+1); /* fixup includes lead-out */
  return --i_track;  /* number of tracks returned does not include lead-out */
}


/* Set operating speed */
static int
cddap_setspeed(cdrom_drive_t *d, int i_speed)
{
  return cdio_set_speed(d->p_cdio, i_speed);
}

/* read 'i_sector' adjacent audio sectors
 * into buffer '*p' beginning at sector 'begin'
 */

static long int
read_blocks (cdrom_drive_t *d, void *p, lsn_t begin, long i_sectors)
{
  int retry_count = 0;
  int err;
  int ret = 0;
  char *buffer=(char *)p;

  if(p==NULL)buffer = malloc(i_sectors*CD_FRAMESIZE_RAW);

  do {
    struct timespec tv1;
    struct timespec tv2;
    int ret1,ret2;

    ret1 = gettime(&tv1);
    err  = cdio_read_audio_sectors( d->p_cdio, buffer, begin, i_sectors);
    ret2 = gettime(&tv2);

    if(ret1<0 || ret2<0) {
      d->last_milliseconds=-1;
    } else {
      d->last_milliseconds = (tv2.tv_sec-tv1.tv_sec)*1000. + (tv2.tv_nsec-tv1.tv_nsec)/1000000.;
    }

    if ( DRIVER_OP_SUCCESS != err ) {
      if (!d->error_retry) {
	ret=-7;
	goto done;
      }

      if (i_sectors==1) {
	/* *Could* be I/O or media error.  I think.  If we're at
	   30 retries, we better skip this unhappy little
	   sector. */
	if (retry_count>MAX_RETRIES-1) {
	  char b[256];
	  snprintf(b, sizeof(b),
		   "010: Unable to access sector %ld: skipping...\n",
		   (long int) begin);
	  cderror(d, b);
	  ret=-10;
	  goto done;
	}
      }

      if(retry_count>4)
	if(i_sectors>1)
	  i_sectors=i_sectors*3/4;
      retry_count++;
      if (retry_count>MAX_RETRIES) {
	cderror(d,"007: Unknown, unrecoverable error reading data\n");
	ret=-7;
	goto done;
      }
    } else
      break;
  } while (err);

  ret=i_sectors;

 done:
  if(p==NULL && buffer)free(buffer);
  return ret;
}

typedef enum  {
  JITTER_NONE = 0,
  JITTER_SMALL= 1,
  JITTER_LARGE= 2,
  JITTER_MASSIVE=3
} jitter_baddness_t;

/* read 'i_sector' adjacent audio sectors
 * into buffer '*p' beginning at sector 'begin'
 */

static long int
jitter_read (cdrom_drive_t *d, void *p, lsn_t begin, long i_sectors,
	     jitter_baddness_t jitter_badness)
{
  static int i_jitter=0;
  int jitter_flag;
  long i_sectors_orig = i_sectors;
  long i_jitter_offset = 0;

  char *p_buf=malloc(CDIO_CD_FRAMESIZE_RAW*(i_sectors+1));

  if (d->i_test_flags & CDDA_TEST_ALWAYS_JITTER)
    jitter_flag = 1;
  else
#ifdef HAVE_DRAND48
    jitter_flag = (drand48() > .9) ? 1 : 0;
#else
    jitter_flag = (((float)rand()/RAND_MAX) > .9) ? 1 : 0;
#endif

  if (jitter_flag) {
    int i_coeff = 0;
    int i_jitter_sectors = 0;
    switch(jitter_badness) {
    case JITTER_SMALL  : i_coeff =   4; break;
    case JITTER_LARGE  : i_coeff =  32; break;
    case JITTER_MASSIVE: i_coeff = 128; break;
    case JITTER_NONE   :
    default            : ;
    }
#ifdef HAVE_DRAND48
    i_jitter = i_coeff * (int)((drand48()-.5)*CDIO_CD_FRAMESIZE_RAW/8);
#else
    i_jitter = i_coeff * (int)((((float)rand()/RAND_MAX)-.5)*CDIO_CD_FRAMESIZE_RAW/8);
#endif

    /* We may need to add another sector to compensate for the bytes that
       will be dropped off when jittering, and the begin location may
       be a little different.
    */
    i_jitter_sectors = i_jitter / CDIO_CD_FRAMESIZE_RAW;

    if (i_jitter >= 0)
      i_jitter_offset  = i_jitter % CDIO_CD_FRAMESIZE_RAW;
    else {
      i_jitter_offset  = CDIO_CD_FRAMESIZE_RAW -
	(-i_jitter % CDIO_CD_FRAMESIZE_RAW);
      i_jitter_sectors--;
    }


    if (begin + i_jitter_sectors > 0) {
#if TRACE_PARANOIA
      char buffer[256];
      sprintf(buffer, "jittering by %d, offset %ld\n", i_jitter,
	      i_jitter_offset);
      cdmessage(d,buffer);
#endif

      begin += i_jitter_sectors;
      i_sectors ++;
    } else
      i_jitter_offset = 0;

  }

  i_sectors = read_blocks(d, p_buf, begin, i_sectors);

  if (i_sectors < 0) return i_sectors;

  if (i_sectors < i_sectors_orig) {
    /* Had to reduce # of sectors due to read errors. So give full amount,
       with no jittering. */
    if (p) memcpy(p, p_buf, i_sectors*CDIO_CD_FRAMESIZE_RAW);
  } else {
    /* Got full amount, but now adjust size for jittering. */
    if (p) memcpy(p, p_buf+i_jitter_offset, i_sectors_orig*CDIO_CD_FRAMESIZE_RAW);
    i_sectors = i_sectors_orig;
  }

  free(p_buf);
  return(i_sectors);
}

/* read 'i_sector' adjacent audio sectors
 * into buffer '*p' beginning at sector 'begin'
 */

static long int
cddap_read (cdrom_drive_t *d, void *p, lsn_t begin, long i_sectors)
{
  jitter_baddness_t jitter_badness = d->i_test_flags & 0x3;

  /* read d->nsectors at a time, max. */
  i_sectors = ( i_sectors > d->nsectors && d->nsectors > 0 )
    ? d->nsectors : i_sectors;

  /* If we are testing under-run correction, we will deliberately set
     what we read a frame short.  */
  if (d->i_test_flags & CDDA_TEST_UNDERRUN )
    i_sectors--;

  if (jitter_badness) {
    return jitter_read(d, p, begin, i_sectors, jitter_badness);
  } else
    return read_blocks(d, p, begin, i_sectors);

}

static int
verify_read_command(cdrom_drive_t *d)
{
  int i;
  int16_t *buff=malloc(CDIO_CD_FRAMESIZE_RAW);
  int audioflag=0;
  int i_test_flags = d->i_test_flags;

  d->i_test_flags = 0;

  cdmessage(d,"Verifying drive can read CDDA...\n");

  d->enable_cdda(d,1);

  for(i=1;i<=d->tracks;i++){
    if(cdda_track_audiop(d,i)==1){
      long firstsector=cdda_track_firstsector(d,i);
      long lastsector=cdda_track_lastsector(d,i);
      long sector=(firstsector+lastsector)>>1;
      audioflag=1;

      if(d->read_audio(d,buff,sector,1)>0){
	cdmessage(d,"\tExpected command set reads OK.\n");
	d->enable_cdda(d,0);
	free(buff);
	d->i_test_flags = i_test_flags;
	return(0);
      }
    }
  }

  d->enable_cdda(d,0);

  if(!audioflag){
    cdmessage(d,"\tCould not find any audio tracks on this disk.\n");
    free(buff);
    return(-403);
  }

  cdmessage(d,"\n\tUnable to read any data; "
	    "drive probably not CDDA capable.\n");

  cderror(d,"006: Could not read any data from drive\n");

  free(buff);
  return(-6);
}

#include "drive_exceptions.h"

#ifdef HAVE_LINUX_MAJOR_H
static void
check_exceptions(cdrom_drive_t *d, const exception_t *list)
{

  int i=0;
  while(list[i].model){
    if(!strncmp(list[i].model,d->drive_model,strlen(list[i].model))){
      if(list[i].bigendianp!=-1)d->bigendianp=list[i].bigendianp;
      return;
    }
    i++;
  }
}
#endif /* HAVE_LINUX_MAJOR_H */

/* set function pointers to use the ioctl routines */
int
cddap_init_drive (cdrom_drive_t *d)
{
  int ret;

#if HAVE_LINUX_MAJOR_H
  switch(d->drive_type){
  case MATSUSHITA_CDROM_MAJOR:	/* sbpcd 1 */
  case MATSUSHITA_CDROM2_MAJOR:	/* sbpcd 2 */
  case MATSUSHITA_CDROM3_MAJOR:	/* sbpcd 3 */
  case MATSUSHITA_CDROM4_MAJOR:	/* sbpcd 4 */
    /* don't make the buffer too big; this sucker don't preempt */

    cdmessage(d,"Attempting to set sbpcd buffer size...\n");

    d->nsectors=8;

#if BUFSIZE_DETERMINATION_FIXED
    while(1){

      /* this ioctl returns zero on error; exactly wrong, but that's
         what it does. */

      if (ioctl(d->ioctl_fd, CDROMAUDIOBUFSIZ, d->nsectors)==0) {
	d->nsectors>>=1;
	if(d->nsectors==0){
	  char buffer[256];
	  d->nsectors=8;
	  sprintf(buffer,"\tTrouble setting buffer size.  Defaulting to %d sectors.\n",
		  d->nsectors);
	  cdmessage(d,buffer);
	  break; /* Oh, well.  Try to read anyway.*/
	}
      } else {
	char buffer[256];
	sprintf(buffer,"\tSetting read block size at %d sectors (%ld bytes).\n",
		d->nsectors,(long)d->nsectors*CDIO_CD_FRAMESIZE_RAW);
	cdmessage(d,buffer);
	break;
      }
    }
#endif /* BUFSIZE_DETERMINATION_FIXED */

    break;
  case IDE0_MAJOR:
  case IDE1_MAJOR:
  case IDE2_MAJOR:
  case IDE3_MAJOR:
    d->nsectors=8; /* it's a define in the linux kernel; we have no
		      way of determining other than this guess tho */
    d->bigendianp=0;
    d->is_atapi=1;

    check_exceptions(d, atapi_list);

    break;
  default:
    d->nsectors=25;  /* The max for SCSI MMC2 */
  }
#else
  {
    char buffer[256];
    d->nsectors = 8;
    sprintf(buffer,"\tSetting read block size at %d sectors (%ld bytes).\n",
	    d->nsectors,(long)d->nsectors*CDIO_CD_FRAMESIZE_RAW);
    cdmessage(d,buffer);
  }
#endif /*HAVE_LINUX_MAJOR_H*/

  d->enable_cdda = dummy_exception;
  d->set_speed   = cddap_setspeed;
  d->read_toc    = cddap_readtoc;
  d->read_audio  = cddap_read;

  ret = d->tracks = d->read_toc(d);
  if(d->tracks<1)
    return(ret);

  d->opened=1;

  if( (ret=verify_read_command(d)) ) return(ret);

  d->error_retry=1;

  return(0);
}
