/*

  Copyright (C) 2004-2008, 2011-2012, 2014, 2017

  Rocky Bernstein <rocky@gnu.org>

    toc reading routine adapted from cuetools

  Copyright (C) 2003 Svend Sanjay Sorensen <ssorensen@fastmail.fm>

  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/>.

*/

/* This code implements low-level access functions for a CD images

   residing inside a disk file (*.bin) and its associated cue sheet.

   (*.cue).

*/

#include "portable.h"

#ifdef HAVE_LIMITS_H

#include <limits.h>

#endif

#ifdef HAVE_STDIO_H

#include <stdio.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#ifdef HAVE_STRINGS_H

#include <strings.h>

#endif

#ifdef HAVE_GLOB_H

#include <glob.h>

#endif

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_INTTYPES_H

#include <inttypes.h>

#else

#define PRId64 "lld"

#endif

#include <ctype.h>

#include <cdio/logging.h>

#include <cdio/sector.h>

#include <cdio/util.h>

#include <stdio.h>

#include <cdio/utf8.h>

#include <cdio/version.h>

#include "image.h"

#include "cdio_assert.h"

#include "_cdio_stdio.h"

/* reader */

#define DEFAULT_CDIO_DEVICE "videocd.bin"

#define DEFAULT_CDIO_CDRDAO "videocd.toc"

#ifdef _WIN32

#define CDIO_FOPEN fopen_utf8

#else

#define CDIO_FOPEN fopen

#endif

#include "image_common.h"

#include "cdtext_private.h"

static lsn_t get_disc_last_lsn_cdrdao (void *p_user_data);

static bool parse_tocfile (_img_private_t *cd, const char *p_toc_name);

static bool

check_track_is_blocksize_multiple(const char *psz_fname,

				  track_t i_track, off_t i_size,

				  uint16_t i_blocksize)

{

  if (i_size % i_blocksize) {

    cdio_info ("image %s track %d size (%" PRId64 ") not a multiple"

	       " of the blocksize (%ld)",

	       psz_fname ? psz_fname : "unknown??", i_track, (int64_t)i_size,

	       (long int) i_blocksize);

    if (i_size % M2RAW_SECTOR_SIZE == 0)

      cdio_info ("this may be a 2336-type disc image");

    else if (i_size % CDIO_CD_FRAMESIZE_RAW == 0)

      cdio_info ("this may be a 2352-type disc image");

    return false;

  }

  return true;

}

/*!

  Initialize image structures.

 */

static bool

_init_cdrdao (_img_private_t *env)

{

  lsn_t lead_lsn;

  if (env->gen.init)

    return false;

  /* Have to set init before calling get_disc_last_lsn_cdrdao() or we will

     get into infinite recursion calling passing right here.

   */

  env->gen.init          = true;

  env->gen.i_first_track = 1;

  env->psz_mcn           = NULL;

  env->disc_mode         = CDIO_DISC_MODE_NO_INFO;

  /* Read in TOC sheet. */

  if ( !parse_tocfile(env, env->psz_cue_name) ) return false;

  lead_lsn = get_disc_last_lsn_cdrdao( (_img_private_t *) env);

  if (-1 == lead_lsn)

    return false;

  /* Fake out leadout track and sector count for last track*/

  cdio_lsn_to_msf (lead_lsn, &env->tocent[env->gen.i_tracks].start_msf);

  env->tocent[env->gen.i_tracks].start_lba = cdio_lsn_to_lba(lead_lsn);

  env->tocent[env->gen.i_tracks-env->gen.i_first_track].sec_count =

    cdio_lsn_to_lba(lead_lsn - env->tocent[env->gen.i_tracks-1].start_lba);

  return true;

}

/*!

  Reads into buf the next size bytes.

  Returns -1 on error.

  Would be libc's seek() but we have to adjust for the extra track header

  information in each sector.

*/

static off_t

_lseek_cdrdao (void *user_data, off_t offset, int whence)

{

  _img_private_t *env = user_data;

  /* real_offset is the real byte offset inside the disk image

     The number below was determined empirically. I'm guessing

     the 1st 24 bytes of a bin file are used for something.

  */

  off_t real_offset=0;

  unsigned int i;

  env->pos.lba = 0;

  for (i=0; i<env->gen.i_tracks; i++) {

    track_info_t  *this_track=&(env->tocent[i]);

    env->pos.index = i;

    if ( (this_track->sec_count*this_track->datasize) >= offset) {

      int blocks            = (int) (offset / this_track->datasize);

      int rem               = (int) (offset % this_track->datasize);

      off_t block_offset    = blocks * this_track->blocksize;

      real_offset          += block_offset + rem;

      env->pos.buff_offset = rem;

      env->pos.lba        += (lba_t)blocks;

      break;

    }

    real_offset   += this_track->sec_count*this_track->blocksize;

    offset        -= this_track->sec_count*this_track->datasize;

    env->pos.lba += this_track->sec_count;

  }

  if (i==env->gen.i_tracks) {

    cdio_warn ("seeking outside range of disk image");

    return -1;

  } else {

    real_offset += env->tocent[i].datastart;

    return cdio_stream_seek(env->tocent[i].data_source, real_offset, whence);

  }

}

/*!

  Reads into buf the next size bytes.

  Returns -1 on error.

  FIXME:

   At present we assume a read doesn't cross sector or track

   boundaries.

*/

static ssize_t

_read_cdrdao (void *user_data, void *data, size_t size)

{

  _img_private_t *env = user_data;

  char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };

  char *p = data;

  ssize_t final_size=0;

  ssize_t this_size;

  track_info_t  *this_track=&(env->tocent[env->pos.index]);

  ssize_t skip_size = this_track->datastart + this_track->endsize;

  while (size > 0) {

    int rem = (int) (this_track->datasize - env->pos.buff_offset);

    if (size <= rem) {

      this_size = cdio_stream_read(this_track->data_source, buf, size, 1);

      final_size += this_size;

      memcpy (p, buf, this_size);

      break;

    }

    /* Finish off reading this sector. */

    cdio_warn ("Reading across block boundaries not finished");

    size -= rem;

    this_size = cdio_stream_read(this_track->data_source, buf, rem, 1);

    final_size += this_size;

    memcpy (p, buf, this_size);

    p += this_size;

    cdio_stream_read(this_track->data_source, buf, rem, 1);

    /* Skip over stuff at end of this sector and the beginning of the next.

     */

    cdio_stream_read(this_track->data_source, buf, skip_size, 1);

    /* Get ready to read another sector. */

    env->pos.buff_offset=0;

    env->pos.lba++;

    /* Have gone into next track. */

    if (env->pos.lba >= env->tocent[env->pos.index+1].start_lba) {

      env->pos.index++;

      this_track=&(env->tocent[env->pos.index]);

      skip_size = this_track->datastart + this_track->endsize;

    }

  }

  return final_size;

}

/*!

   Return the size of the CD in logical block address (LBA) units.

   FIXME: this assumes there is only one source for data or

   one track of silence.

 */

static lsn_t

get_disc_last_lsn_cdrdao (void *p_user_data)

{

  _img_private_t *p_env = p_user_data;

  track_t i_leadout = p_env->gen.i_tracks;

  uint16_t i_blocksize  = p_env->tocent[i_leadout-1].blocksize;

  off_t i_size;

  if (p_env->tocent[i_leadout-1].sec_count) {

    i_size = p_env->tocent[i_leadout-1].sec_count;

  } else {

      if (NULL == p_env->tocent[i_leadout-1].data_source) {

	  if (!p_env->tocent[i_leadout-1].silence) {

	      cdio_warn ("Data source for image %s is null",

			 p_env->gen.source_name);

	      return -1;

	  }

	  /* FIXME: this is only correct if there is one

	     track of silence. */

	  i_size = p_env->tocent[i_leadout-1].silence;

      } else {

	  /* FIXME: this is only correct if there is one data source. */

	  i_size = cdio_stream_stat(p_env->tocent[i_leadout-1].data_source)

	      - p_env->tocent[i_leadout-1].offset;

      }

    if (i_size < 0) {

      cdio_error ("Disc data size too small for track specification in image %s",

		  p_env->gen.source_name);

      return (lsn_t)i_size;

    }

    if (check_track_is_blocksize_multiple(p_env->tocent[i_leadout-1].filename,

					  i_leadout-1, i_size, i_blocksize)) {

      i_size /= i_blocksize;

    } else {

      /* Round up */

      i_size = (i_size / i_blocksize) + 1;

    }

  }

  i_size += p_env->tocent[i_leadout-1].start_lba;

  i_size -= CDIO_PREGAP_SECTORS;

  return (lsn_t)i_size;

}

#define MAXLINE 512

#define UNIMPLIMENTED_MSG \

  cdio_log(log_level, "%s line %d: unimplimented keyword: %s",  \

	   psz_cue_name, i_line, psz_keyword)

static bool

parse_tocfile (_img_private_t *cd, const char *psz_cue_name)

{

  /* The below declarations may be common in other image-parse routines. */

  FILE        *fp;

  char         psz_line[MAXLINE];   /* text of current line read in file fp. */

  unsigned int i_line=0;            /* line number in file of psz_line. */

  int          i = -1;              /* Position in tocent. Same as

				       cd->gen.i_tracks - 1 */

  char *psz_keyword, *psz_field, *psz_cue_name_dup;

  cdio_log_level_t log_level = (cd) ? CDIO_LOG_WARN : CDIO_LOG_INFO ;

  cdtext_field_t cdtext_key;

  /* The below declaration(s) may be unique to this image-parse routine. */

  unsigned int i_cdtext_nest = 0;

  if (NULL == psz_cue_name)

    return false;

  psz_cue_name_dup = _cdio_strdup_fixpath(psz_cue_name);

  if (NULL == psz_cue_name_dup)

    return false;

  fp = CDIO_FOPEN (psz_cue_name_dup, "r");

  cdio_free(psz_cue_name_dup);

  if (fp == NULL) {

    cdio_log(log_level, "error opening %s for reading: %s",

	     psz_cue_name, strerror(errno));

    return false;

  }

  if (cd) {

    cd->gen.b_cdtext_error = false;

  }

  while (fgets(psz_line, MAXLINE, fp)) {

    i_line++;

    /* strip comment from line */

    /* todo: // in quoted strings? */

    /* //comment */

    if ((psz_field = strstr (psz_line, "//")))

      *psz_field = '\0';

    if ((psz_keyword = strtok (psz_line, " \t\n\r"))) {

      /* CATALOG "ddddddddddddd" */

      if (0 == strcmp ("CATALOG", psz_keyword)) {

	if (-1 == i) {

	  if (NULL != (psz_field = strtok (NULL, "\"\t\n\r"))) {

	    if (13 != strlen(psz_field)) {

	      cdio_log(log_level,

		       "%s line %d after word CATALOG:",

		       psz_cue_name, i_line);

	      cdio_log(log_level,

		       "Token %s has length %ld. Should be 13 digits.",

		       psz_field, (long int) strlen(psz_field));

	      goto err_exit;

	    } else {

	      /* Check that we have all digits*/

	      unsigned int j;

	      for (j=0; j<13; j++) {

		if (!isdigit((unsigned char) psz_field[j])) {

		    cdio_log(log_level,

			     "%s line %d after word CATALOG:",

			     psz_cue_name, i_line);

		    cdio_log(log_level,

			     "Character \"%c\" at postition %i of token \"%s\""

			     " is not all digits.",

			     psz_field[j], j+1, psz_field);

		    goto err_exit;

		}

	      }

	      if (NULL != cd) cd->psz_mcn = strdup (psz_field);

	    }

	  } else {

	    cdio_log(log_level,

		     "%s line %d after word CATALOG:",

		     psz_cue_name, i_line);

	    cdio_log(log_level, "Expecting 13 digits; nothing seen.");

	    goto err_exit;

	  }

	} else {

	  goto err_exit;

	}

	/* CD_DA | CD_ROM | CD_ROM_XA */

      } else if (0 == strcmp ("CD_DA", psz_keyword)) {

	if (-1 == i) {

	  if (NULL != cd)

	    cd->disc_mode = CDIO_DISC_MODE_CD_DA;

	} else {

	  goto not_in_global_section;

	}

      } else if (0 == strcmp ("CD_ROM", psz_keyword)) {

	if (-1 == i) {

	  if (NULL != cd)

	    cd->disc_mode = CDIO_DISC_MODE_CD_DATA;

	} else {

	  goto not_in_global_section;

	}

      } else if (0 == strcmp ("CD_ROM_XA", psz_keyword)) {

	if (-1 == i) {

	  if (NULL != cd)

	    cd->disc_mode = CDIO_DISC_MODE_CD_XA;

	} else {

	  goto not_in_global_section;

	}

	/* TRACK <track-mode> [<sub-channel-mode>] */

      } else if (0 == strcmp ("TRACK", psz_keyword)) {

	i++;

	if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	  if (0 == strcmp ("AUDIO", psz_field)) {

	    if (NULL != cd) {

	      cd->tocent[i].track_format = TRACK_FORMAT_AUDIO;

	      cd->tocent[i].blocksize    = CDIO_CD_FRAMESIZE_RAW;

	      cd->tocent[i].datasize     = CDIO_CD_FRAMESIZE_RAW;

	      cd->tocent[i].datastart    = 0;

	      cd->tocent[i].endsize      = 0;

	      switch(cd->disc_mode) {

	      case CDIO_DISC_MODE_NO_INFO:

		cd->disc_mode = CDIO_DISC_MODE_CD_DA;

		break;

	      case CDIO_DISC_MODE_CD_DA:

	      case CDIO_DISC_MODE_CD_MIXED:

	      case CDIO_DISC_MODE_ERROR:

		/* Disc type stays the same. */

		break;

	      case CDIO_DISC_MODE_CD_DATA:

	      case CDIO_DISC_MODE_CD_XA:

		cd->disc_mode = CDIO_DISC_MODE_CD_MIXED;

		break;

	      default:

		cd->disc_mode = CDIO_DISC_MODE_ERROR;

	      }

	    }

	  } else if (0 == strcmp ("MODE1", psz_field)) {

	    if (NULL != cd) {

	      cd->tocent[i].track_format = TRACK_FORMAT_DATA;

	      cd->tocent[i].blocksize    = CDIO_CD_FRAMESIZE_RAW;

	      cd->tocent[i].datastart    = CDIO_CD_SYNC_SIZE

		+ CDIO_CD_HEADER_SIZE;

	      cd->tocent[i].datasize     = CDIO_CD_FRAMESIZE;

	      cd->tocent[i].endsize      = CDIO_CD_EDC_SIZE

		+ CDIO_CD_M1F1_ZERO_SIZE + CDIO_CD_ECC_SIZE;

	      switch(cd->disc_mode) {

	      case CDIO_DISC_MODE_NO_INFO:

		cd->disc_mode = CDIO_DISC_MODE_CD_DATA;

		break;

	      case CDIO_DISC_MODE_CD_DATA:

	      case CDIO_DISC_MODE_CD_MIXED:

	      case CDIO_DISC_MODE_ERROR:

		/* Disc type stays the same. */

		break;

	      case CDIO_DISC_MODE_CD_DA:

	      case CDIO_DISC_MODE_CD_XA:

		cd->disc_mode = CDIO_DISC_MODE_CD_MIXED;

		break;

	      default:

		cd->disc_mode = CDIO_DISC_MODE_ERROR;

	      }

	    }

	  } else if (0 == strcmp ("MODE1_RAW", psz_field)) {

	    if (NULL != cd) {

	      cd->tocent[i].track_format = TRACK_FORMAT_DATA;

	      cd->tocent[i].blocksize = CDIO_CD_FRAMESIZE_RAW;

	      cd->tocent[i].datastart = CDIO_CD_SYNC_SIZE

		+ CDIO_CD_HEADER_SIZE;

	      cd->tocent[i].datasize  = CDIO_CD_FRAMESIZE;

	      cd->tocent[i].endsize   = CDIO_CD_EDC_SIZE

		+ CDIO_CD_M1F1_ZERO_SIZE + CDIO_CD_ECC_SIZE;

	      switch(cd->disc_mode) {

	      case CDIO_DISC_MODE_NO_INFO:

		cd->disc_mode = CDIO_DISC_MODE_CD_DATA;

		break;

	      case CDIO_DISC_MODE_CD_DATA:

	      case CDIO_DISC_MODE_CD_MIXED:

	      case CDIO_DISC_MODE_ERROR:

		/* Disc type stays the same. */

		break;

	      case CDIO_DISC_MODE_CD_DA:

	      case CDIO_DISC_MODE_CD_XA:

		cd->disc_mode = CDIO_DISC_MODE_CD_MIXED;

		break;

	      default:

		cd->disc_mode = CDIO_DISC_MODE_ERROR;

	      }

	    }

	  } else if (0 == strcmp ("MODE2", psz_field)) {

	    if (NULL != cd) {

	      cd->tocent[i].track_format = TRACK_FORMAT_XA;

	      cd->tocent[i].datastart = CDIO_CD_SYNC_SIZE

		+ CDIO_CD_HEADER_SIZE;

	      cd->tocent[i].datasize = M2RAW_SECTOR_SIZE;

	      cd->tocent[i].endsize   = 0;

	      switch(cd->disc_mode) {

	      case CDIO_DISC_MODE_NO_INFO:

		cd->disc_mode = CDIO_DISC_MODE_CD_XA;

		break;

	      case CDIO_DISC_MODE_CD_XA:

	      case CDIO_DISC_MODE_CD_MIXED:

	      case CDIO_DISC_MODE_ERROR:

		/* Disc type stays the same. */

		break;

	      case CDIO_DISC_MODE_CD_DA:

	      case CDIO_DISC_MODE_CD_DATA:

		cd->disc_mode = CDIO_DISC_MODE_CD_MIXED;

		break;

	      default:

		cd->disc_mode = CDIO_DISC_MODE_ERROR;

	      }

	    }

	  } else if (0 == strcmp ("MODE2_FORM1", psz_field)) {

	    if (NULL != cd) {

	      cd->tocent[i].track_format = TRACK_FORMAT_XA;

	      cd->tocent[i].datastart = CDIO_CD_SYNC_SIZE

		+ CDIO_CD_HEADER_SIZE;

	      cd->tocent[i].datasize  = CDIO_CD_FRAMESIZE_RAW;

	      cd->tocent[i].endsize   = 0;

	      switch(cd->disc_mode) {

	      case CDIO_DISC_MODE_NO_INFO:

		cd->disc_mode = CDIO_DISC_MODE_CD_XA;

		break;

	      case CDIO_DISC_MODE_CD_XA:

	      case CDIO_DISC_MODE_CD_MIXED:

	      case CDIO_DISC_MODE_ERROR:

		/* Disc type stays the same. */

		break;

	      case CDIO_DISC_MODE_CD_DA:

	      case CDIO_DISC_MODE_CD_DATA:

		cd->disc_mode = CDIO_DISC_MODE_CD_MIXED;

		break;

	      default:

		cd->disc_mode = CDIO_DISC_MODE_ERROR;

	      }

	    }

	  } else if (0 == strcmp ("MODE2_FORM2", psz_field)) {

	    if (NULL != cd) {

	      cd->tocent[i].track_format = TRACK_FORMAT_XA;

	      cd->tocent[i].datastart    = CDIO_CD_SYNC_SIZE

		+ CDIO_CD_HEADER_SIZE + CDIO_CD_SUBHEADER_SIZE;

	      cd->tocent[i].datasize     = CDIO_CD_FRAMESIZE;

	      cd->tocent[i].endsize      = CDIO_CD_SYNC_SIZE

		+ CDIO_CD_ECC_SIZE;

	      switch(cd->disc_mode) {

	      case CDIO_DISC_MODE_NO_INFO:

		cd->disc_mode = CDIO_DISC_MODE_CD_XA;

		break;

	      case CDIO_DISC_MODE_CD_XA:

	      case CDIO_DISC_MODE_CD_MIXED:

	      case CDIO_DISC_MODE_ERROR:

		/* Disc type stays the same. */

		break;

	      case CDIO_DISC_MODE_CD_DA:

	      case CDIO_DISC_MODE_CD_DATA:

		cd->disc_mode = CDIO_DISC_MODE_CD_MIXED;

		break;

	      default:

		cd->disc_mode = CDIO_DISC_MODE_ERROR;

	      }

	    }

	  } else if (0 == strcmp ("MODE2_FORM_MIX", psz_field)) {

	    if (NULL != cd) {

	      cd->tocent[i].track_format = TRACK_FORMAT_XA;

	      cd->tocent[i].datasize     = M2RAW_SECTOR_SIZE;

	      cd->tocent[i].blocksize    = CDIO_CD_FRAMESIZE_RAW;

	      cd->tocent[i].datastart    = CDIO_CD_SYNC_SIZE +

		CDIO_CD_HEADER_SIZE + CDIO_CD_SUBHEADER_SIZE;

	      cd->tocent[i].track_green  = true;

	      cd->tocent[i].endsize      = 0;

	      switch(cd->disc_mode) {

	      case CDIO_DISC_MODE_NO_INFO:

		cd->disc_mode = CDIO_DISC_MODE_CD_XA;

		break;

	      case CDIO_DISC_MODE_CD_XA:

	      case CDIO_DISC_MODE_CD_MIXED:

	      case CDIO_DISC_MODE_ERROR:

		/* Disc type stays the same. */

		break;

	      case CDIO_DISC_MODE_CD_DA:

	      case CDIO_DISC_MODE_CD_DATA:

		cd->disc_mode = CDIO_DISC_MODE_CD_MIXED;

		break;

	      default:

		cd->disc_mode = CDIO_DISC_MODE_ERROR;

	      }

	    }

	  } else if (0 == strcmp ("MODE2_RAW", psz_field)) {

	    if (NULL != cd) {

	      cd->tocent[i].track_format = TRACK_FORMAT_XA;

	      cd->tocent[i].blocksize    = CDIO_CD_FRAMESIZE_RAW;

	      cd->tocent[i].datastart    = CDIO_CD_SYNC_SIZE +

		CDIO_CD_HEADER_SIZE + CDIO_CD_SUBHEADER_SIZE;

	      cd->tocent[i].datasize     = CDIO_CD_FRAMESIZE;

	      cd->tocent[i].track_green  = true;

	      cd->tocent[i].endsize      = 0;

	      switch(cd->disc_mode) {

	      case CDIO_DISC_MODE_NO_INFO:

		cd->disc_mode = CDIO_DISC_MODE_CD_XA;

		break;

	      case CDIO_DISC_MODE_CD_XA:

	      case CDIO_DISC_MODE_CD_MIXED:

	      case CDIO_DISC_MODE_ERROR:

		/* Disc type stays the same. */

		break;

	      case CDIO_DISC_MODE_CD_DA:

	      case CDIO_DISC_MODE_CD_DATA:

		cd->disc_mode = CDIO_DISC_MODE_CD_MIXED;

		break;

	      default:

		cd->disc_mode = CDIO_DISC_MODE_ERROR;

	      }

	    }

	  } else {

	    cdio_log(log_level, "%s line %d after TRACK:",

		     psz_cue_name, i_line);

	    cdio_log(log_level, "'%s' not a valid mode.", psz_field);

	    goto err_exit;

	  }

	}

	if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	  /* \todo: set sub-channel-mode */

#ifdef TODO

	  if (0 == strcmp ("RW", psz_field))

	    ;

	  else if (0 == strcmp ("RW_RAW", psz_field))

	    ;

#endif

	}

	if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	  goto format_error;

	}

	/* track flags */

	/* [NO] COPY | [NO] PRE_EMPHASIS */

      } else if (0 == strcmp ("NO", psz_keyword)) {

	if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	  if (0 == strcmp ("COPY", psz_field)) {

	    if (NULL != cd)

	      cd->tocent[i].flags &= ~CDIO_TRACK_FLAG_COPY_PERMITTED;

	  } else if (0 == strcmp ("PRE_EMPHASIS", psz_field))

	    if (NULL != cd) {

	      cd->tocent[i].flags &= ~CDIO_TRACK_FLAG_PRE_EMPHASIS;

	    }

	} else {

	  goto format_error;

	}

	if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	  goto format_error;

	}

      } else if (0 == strcmp ("COPY", psz_keyword)) {

	if (NULL != cd && i >= 0)

	  cd->tocent[i].flags |= CDIO_TRACK_FLAG_COPY_PERMITTED;

      } else if (0 == strcmp ("PRE_EMPHASIS", psz_keyword)) {

	if (NULL != cd && i >= 0)

	  cd->tocent[i].flags |= CDIO_TRACK_FLAG_PRE_EMPHASIS;

	/* TWO_CHANNEL_AUDIO */

      } else if (0 == strcmp ("TWO_CHANNEL_AUDIO", psz_keyword)) {

	if (NULL != cd && i >= 0)

	  cd->tocent[i].flags &= ~CDIO_TRACK_FLAG_FOUR_CHANNEL_AUDIO;

	/* FOUR_CHANNEL_AUDIO */

      } else if (0 == strcmp ("FOUR_CHANNEL_AUDIO", psz_keyword)) {

	if (NULL != cd && i >= 0)

	  cd->tocent[i].flags |= CDIO_TRACK_FLAG_FOUR_CHANNEL_AUDIO;

	/* ISRC "CCOOOYYSSSSS" */

      } else if (0 == strcmp ("ISRC", psz_keyword)) {

	if (NULL != (psz_field = strtok (NULL, "\"\t\n\r"))) {

	  if (NULL != cd)

	    cd->tocent[i].isrc = strdup(psz_field);

	} else {

	  goto format_error;

	}

	/* SILENCE <length> */

      } else if (0 == strcmp ("SILENCE", psz_keyword)) {

	  if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	      if (NULL != cd)

		  cd->tocent[i].silence = cdio_mmssff_to_lba (psz_field);

	  } else {

	      goto format_error;

	  }

	  cdio_log(log_level, "%s line %d: SILENCE not fully implimented",

		   psz_cue_name, i_line);

	/* ZERO <length> */

      } else if (0 == strcmp ("ZERO", psz_keyword)) {

	UNIMPLIMENTED_MSG;

	/* [FILE|AUDIOFILE] "<filename>" <start-msf> [<length-msf>] */

      } else if (0 == strcmp ("FILE", psz_keyword)

		 || 0 == strcmp ("AUDIOFILE", psz_keyword)) {

	if (0 <= i) {

	  if (NULL != (psz_field = strtok (NULL, "\"\t\n\r"))) {

	    /* Handle "<filename>" */

	    if (cd) {

	      char *psz_dirname = cdio_dirname(psz_cue_name);

	      char *psz_filename = cdio_abspath(psz_dirname, psz_field);

	      cd->tocent[i].filename = strdup (psz_filename);

	      free(psz_filename);

	      free(psz_dirname);

	      /* To do: do something about reusing existing files. */

	      if (!(cd->tocent[i].data_source = cdio_stdio_new (psz_field))) {

		cdio_log (log_level,

			  "%s line %d: can't open file `%s' for reading",

			   psz_cue_name, i_line, psz_field);

		goto err_exit;

	      }

	    } else {

	      CdioDataSource_t *s = cdio_stdio_new (psz_field);

	      if (!s) {

		cdio_log (log_level,

			  "%s line %d: can't open file `%s' for reading",

			  psz_cue_name, i_line, psz_field);

		cdio_stdio_destroy (s);

		goto err_exit;

	      }

	      cdio_stdio_destroy (s);

	    }

	  }

	  if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	    /* Handle <start-msf> */

	    lba_t i_start_lba =

	      cdio_lsn_to_lba(cdio_mmssff_to_lba (psz_field));

	    if (CDIO_INVALID_LBA == i_start_lba) {

	      cdio_log(log_level, "%s line %d: invalid MSF string %s",

		       psz_cue_name, i_line, psz_field);

	      goto err_exit;

	    }

	    if (NULL != cd) {

	      cd->tocent[i].start_lba = i_start_lba;

	      cdio_lba_to_msf(i_start_lba, &(cd->tocent[i].start_msf));

	    }

	  }

	  if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	    /* Handle <length-msf> */

	    lba_t lba = cdio_mmssff_to_lba (psz_field);

	    if (CDIO_INVALID_LBA == lba) {

	      cdio_log(log_level, "%s line %d: invalid MSF string %s",

		       psz_cue_name, i_line, psz_field);

	      goto err_exit;

	    }

	    if (cd) {

	      off_t i_size = cdio_stream_stat(cd->tocent[i].data_source);

	      if (lba) {

		if ( (lba * cd->tocent[i].datasize) > i_size) {

		  cdio_log(log_level,

			   "%s line %d: MSF length %s exceeds end of file",

			   psz_cue_name, i_line, psz_field);

		  goto err_exit;

		}

	      } else {

		lba = (lba_t) (i_size / cd->tocent[i].blocksize);

	      }

	      cd->tocent[i].sec_count = lba;

	    }

	  }

	  if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	    goto format_error;

	  }

	} else {

	  goto not_in_global_section;

	}

	/* DATAFILE "<filename>" #byte-offset <start-msf> */

      } else if (0 == strcmp ("DATAFILE", psz_keyword)) {

	if (0 <= i) {

	  if (NULL != (psz_field = strtok (NULL, "\"\t\n\r"))) {

	    /* Handle <filename> */

	    char *psz_dirname = cdio_dirname(psz_cue_name);

	    char *psz_filename = cdio_abspath(psz_dirname, psz_field);

	    if (cd) {

	      cd->tocent[i].filename = strdup(psz_filename);

	      /* To do: do something about reusing existing files. */

	      if (!(cd->tocent[i].data_source = cdio_stdio_new (psz_field))) {

		cdio_log (log_level,

			  "%s line %d: can't open file `%s' for reading",

			  psz_cue_name, i_line, psz_field);

		free(psz_filename);

		free(psz_dirname);

		goto err_exit;

	      }

	    } else {

	      CdioDataSource_t *s = cdio_stdio_new (psz_filename);

	      if (!s) {

		cdio_log (log_level,

			  "%s line %d: can't open file `%s' for reading",

			  psz_cue_name, i_line, psz_field);

		free(psz_filename);

		free(psz_dirname);

		goto err_exit;

	      }

	      cdio_stdio_destroy (s);

	    }

	    free(psz_filename);

	    free(psz_dirname);

	  }

	  psz_field = strtok (NULL, " \t\n\r");

	  if (psz_field) {

	    /* Handle optional #byte-offset */

	    if ( psz_field[0] == '#') {

	      long int offset;

	      psz_field++;

	      errno = 0;

	      offset = strtol(psz_field, (char **)NULL, 10);

	      if ( (LONG_MIN == offset || LONG_MAX == offset)

		   && 0 != errno ) {

		cdio_log (log_level,

			  "%s line %d: can't convert `%s' to byte offset",

			  psz_cue_name, i_line, psz_field);

		goto err_exit;

	      } else {

		if (NULL != cd) {

		  cd->tocent[i].offset = offset;

		}

	      }

	      psz_field = strtok (NULL, " \t\n\r");

	    }

	  }

	  if (psz_field) {

	    /* Handle start-msf */

	    lba_t lba = cdio_mmssff_to_lba (psz_field);

	    if (CDIO_INVALID_LBA == lba) {

	      cdio_log(log_level, "%s line %d: invalid MSF string %s",

		       psz_cue_name, i_line, psz_field);

	      goto err_exit;

	    }

	    if (cd) {

	      cd->tocent[i].start_lba = lba;

	      cdio_lba_to_msf(cd->tocent[i].start_lba,

			      &(cd->tocent[i].start_msf));

	    }

	  } else {

	    /* No start-msf. */

	    if (cd) {

	      if (i) {

		uint16_t i_blocksize = cd->tocent[i-1].blocksize;

		off_t i_size      =

		  cdio_stream_stat(cd->tocent[i-1].data_source);

		  check_track_is_blocksize_multiple(cd->tocent[i-1].filename,

						    i-1, i_size, i_blocksize);

		/* Append size of previous datafile. */

		cd->tocent[i].start_lba = (lba_t) (cd->tocent[i-1].start_lba +

		  (i_size / i_blocksize));

	      }

	      cd->tocent[i].offset = 0;

	      cd->tocent[i].start_lba += CDIO_PREGAP_SECTORS;

	      cdio_lba_to_msf(cd->tocent[i].start_lba,

			      &(cd->tocent[i].start_msf));

	    }

	  }

	} else {

	  goto not_in_global_section;

	}

	/* FIFO "<fifo path>" [<length>] */

      } else if (0 == strcmp ("FIFO", psz_keyword)) {

	goto unimplimented_error;

	/* START MM:SS:FF */

      } else if (0 == strcmp ("START", psz_keyword)) {

	if (0 <= i) {

	  if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {

	    /* todo: line is too long! */

	    if (NULL != cd) {

	      cd->tocent[i].pregap = cd->tocent[i].start_lba;

	      cd->tocent[i].start_lba += cdio_mmssff_to_lba (psz_field);

	      cdio_lba_to_msf(cd->tocent[i].start_lba,

			      &(cd->tocent[i].start_msf));

	    }

	  }