/*
 * $Id$
 *
 * This file is part of WorkMan, the civilized CD player library
 * (c) 1991-1997 by Steven Grimm (original author)
 * (c) by Dirk Försterling (current 'author' = maintainer)
 * The maintainer can be contacted by his e-mail address:
 * milliByte@DeathsDoor.com 
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1307  USA
 *
 *
 * Interface between most of WorkMan and the low-level CD-ROM library
 * routines defined in plat_*.c and drv_*.c.  The goal is to have no
 * platform- or drive-dependent code here.
 */

#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
/* #include <sys/time.h> */

#include "config.h"

#include "include/wm_config.h"
#include "include/wm_struct.h"
#include "include/wm_cddb.h"
#include "include/wm_cdrom.h"
#include "include/wm_database.h"
#include "include/wm_platform.h"
#include "include/wm_helpers.h"
#include "include/wm_cdinfo.h"
#include "include/wm_cdtext.h"

#ifdef CAN_CLOSE
#include <fcntl.h>
#endif

/* local prototypes */
int read_toc(void);

#define WM_MSG_CLASS WM_MSG_CLASS_CDROM

/* extern struct wm_drive generic_proto, toshiba_proto, sony_proto; */
/*	toshiba33_proto; <=== Somehow, this got lost */

/*
 * The supported drive types are listed here.  NULL means match anything.
 * The first match in the list is used, and substring matches are done (so
 * put long names before their shorter prefixes.)
 */
struct drivelist {
  const char *ven;
  const char *mod;
  const char *rev;
  struct wm_drive_proto *proto;
} drives[] = {
{	"TOSHIBA",		"XM-3501",		NULL,		&toshiba_proto	},
{	"TOSHIBA",		"XM-3401",		NULL,		&toshiba_proto	},
{	"TOSHIBA",		"XM-3301",		NULL,		&toshiba_proto	},
{	"SONY",			"CDU-8012",		NULL,		&sony_proto	},
{	"SONY",			"CDU 561",		NULL,		&sony_proto	},
{       "SONY",         	"CDU-76S",      	NULL,   	&sony_proto	},
{	WM_STR_GENVENDOR,	WM_STR_GENMODEL,	WM_STR_GENREV,	&generic_proto  },
{	NULL,			NULL,			NULL,		&generic_proto	}
};

/*
 * Solaris 2.2 will remove the device out from under us.  Getting an ENOENT
 * is therefore sometimes not a problem.
 */
int intermittent_dev = 0;

static int wm_cd_cur_balance = 10;
static int wm_cur_cdmode = WM_CDM_UNKNOWN;
static char *wm_cd_device = NULL; /* do not use this extern */

static struct wm_drive drive = {
  0,
  NULL,
  NULL,
  NULL,
  NULL,
  -1,
  -1,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,

  NULL
};

extern struct wm_cdinfo thiscd;

/*
 * Macro magic
 *
 */
#define FREE(x); if(x) free(x); x = NULL;

#define STRDUP(old, neu); \
  if(old) free(old); old = NULL;\
  if(neu) old = strdup(neu);

#define CARRAY(id) ((id)-1)

#define DATATRACK 1
/*
 * init the workmanlib
 */
int wm_cd_init( int cdin, const char *cd_device, const char *soundsystem,
  const char *sounddevice, const char *ctldevice )
{
  drive.cdda = (WM_CDDA == cdin);
#if !defined(BUILD_CDDA)
  if(drive.cdda) {
    wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "Libworkman library was compiled without cdda support\n");
    return -1;
  }
#endif
  wm_cd_destroy();

  STRDUP(wm_cd_device, cd_device);
  drive.cd_device = wm_cd_device;
  STRDUP(drive.soundsystem, soundsystem);
  STRDUP(drive.sounddevice, sounddevice);
  STRDUP(drive.ctldevice, ctldevice);

  return wm_cd_status();
}

int wm_cd_destroy( void )
{
  free_cdtext();

  if(drive.fd != -1) {
    /* first free one old */
    if(drive.proto && drive.proto->gen_close)
      drive.proto->gen_close(&drive);
    else
      close(drive.fd);
  }
  drive.fd = -1;
  FREE(wm_cd_device);
  FREE(drive.soundsystem);
  FREE(drive.sounddevice);
  FREE(drive.ctldevice);
  FREE(drive.vendor);
  FREE(drive.model);
  FREE(drive.revision);
  drive.proto = NULL;

  return 0;
}
/*
 * Give information about the drive we found during wmcd_open()
 */
const char *wm_drive_vendor( void )
{
  return drive.vendor?drive.vendor:"";
}

const char *wm_drive_model( void )
{
  return drive.model?drive.model:"";
}

const char *wm_drive_revision( void )
{
  return drive.revision?drive.revision:"";
}

const char *wm_drive_device( void )
{
  return drive.cd_device ? drive.cd_device : "";
}

/*
 * Figure out which prototype drive structure we should be using based
 * on the vendor, model, and revision of the current drive.
 */
int
find_drive_struct(const char *vendor, const char *model, const char *rev)
{
  struct drivelist *d;

  for (d = drives; d; d++) {
    if(((d->ven != NULL) && strncmp(d->ven, vendor, strlen(d->ven))) ||
       ((d->mod != NULL) && strncmp(d->mod, model, strlen(d->mod))) ||
       ((d->rev != NULL) && strncmp(d->rev, rev, strlen(d->rev))))
      continue;

    if(!(d->proto))
      goto fail;

    STRDUP(drive.vendor, vendor);
    STRDUP(drive.model, model);
    STRDUP(drive.revision, rev);

    drive.proto = d->proto;
    return 0;
  }

fail:
  return -1;
} /* find_drive_struct() */

/*
 * read_toc()
 *
 * Read the table of contents from the CD.  Return a pointer to a wm_cdinfo
 * struct containing the relevant information (minus artist/cdname/etc.)
 * This is a static struct.  Returns NULL if there was an error.
 *
 * XXX allocates one trackinfo too many.
 */
int
read_toc( void )
{
  struct wm_playlist *l;
  int    i;
  int    pos;

  if(!drive.proto)
    return -1;
    
  if(drive.proto && drive.proto->gen_get_trackcount &&
    (drive.proto->gen_get_trackcount)(&drive, &thiscd.ntracks) < 0) {
    return -1 ;
  }

  thiscd.artist[0] = thiscd.cdname[0] = '\0';
  thiscd.whichdb = thiscd.otherrc = thiscd.otherdb = thiscd.user = NULL;
  thiscd.length = 0;
  thiscd.autoplay = thiscd.playmode = thiscd.volume = 0;

  /* Free up any left-over playlists. */
  if (thiscd.lists != NULL) {
    for (l = thiscd.lists; l->name != NULL; l++) {
      free(l->name);
      free(l->list);
    }
    free(thiscd.lists);
    thiscd.lists = NULL;
  }

  if (thiscd.trk != NULL)
    free(thiscd.trk);

  thiscd.trk = malloc((thiscd.ntracks + 1) * sizeof(struct wm_trackinfo));
  if (thiscd.trk == NULL) {
    perror("malloc");
    return -1;
  }

  for (i = 0; i < thiscd.ntracks; i++) {
    if(drive.proto && drive.proto->gen_get_trackinfo &&
      (drive.proto->gen_get_trackinfo)(&drive, i + 1, &thiscd.trk[i].data,
      &thiscd.trk[i].start) < 0) {
      return -1;
    }

    thiscd.trk[i].avoid = thiscd.trk[i].data;
    thiscd.trk[i].length = thiscd.trk[i].start / 75;

    thiscd.trk[i].songname = thiscd.trk[i].otherrc =
    thiscd.trk[i].otherdb = NULL;
    thiscd.trk[i].contd = 0;
    thiscd.trk[i].volume = 0;
    thiscd.trk[i].track = i + 1;
    thiscd.trk[i].section = 0;
    wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "track %i, start frame %i\n",
      thiscd.trk[i].track, thiscd.trk[i].start);
  }

  if(drive.proto && drive.proto->gen_get_cdlen &&
     (drive.proto->gen_get_cdlen)(&drive, &thiscd.trk[i].start) < 0) {
    return -1;
  }
  thiscd.trk[i].length = thiscd.trk[i].start / 75;

/* Now compute actual track lengths. */
  pos = thiscd.trk[0].length;
  for (i = 0; i < thiscd.ntracks; i++) {
    thiscd.trk[i].length = thiscd.trk[i+1].length - pos;
    pos = thiscd.trk[i+1].length;
    if (thiscd.trk[i].data)
      thiscd.trk[i].length = (thiscd.trk[i + 1].start - thiscd.trk[i].start) * 2;
      if (thiscd.trk[i].avoid)
        wm_strmcpy(&thiscd.trk[i].songname, "DATA TRACK");
  }

  thiscd.length = thiscd.trk[thiscd.ntracks].length;
  thiscd.cddbid = cddb_discid();
        
  wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "read_toc() successful\n");
  return 0;
} /* read_toc() */

/*
 * wm_cd_status()
 *
 * Return values:
 *     see wm_cdrom.h
 * 
 * Updates variables.
 */
int
wm_cd_status( void )
{
  static int oldmode = WM_CDM_UNKNOWN;
  int mode, err, tmp;

  if(!drive.proto) {
    oldmode = WM_CDM_UNKNOWN;
    err = wmcd_open( &drive );
    if (err < 0) {
      wm_cur_cdmode = WM_CDM_UNKNOWN;
      return err;
    }
  }

  if(drive.proto && drive.proto->gen_get_drive_status &&
    (drive.proto->gen_get_drive_status)(&drive, oldmode, &mode, &cur_frame,
    &(thiscd.curtrack), &cur_index) < 0) {
    perror("WM gen_get_drive_status");
    return -1;
  } else {
    wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS,
      "gen_get_drive_status returns status %s, track %i, frame %i\n",
      gen_status(mode), thiscd.curtrack, cur_frame);
  }

  if(WM_CDS_NO_DISC(oldmode) && WM_CDS_DISC_READY(mode)) {
    /* device changed */
    thiscd.ntracks = 0;
    if(read_toc() || 0 == thiscd.ntracks)
    {
      close(drive.fd);
      drive.fd = -1;
      mode = WM_CDM_NO_DISC;
    }
    else /* refresh cdtext info */
      get_glob_cdtext(&drive, 1);

    wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "device status changed() from %s to %s\n",
      gen_status(oldmode), gen_status(mode));
  }
  oldmode = mode;

  /*
   * it seems all driver have'nt state for stop
   */
  if(WM_CDM_PAUSED == mode && 0 == cur_frame) {
    mode = WM_CDM_STOPPED;
    thiscd.curtrack = 0;
  }

  switch (mode) {
  case WM_CDM_PLAYING:
  case WM_CDM_PAUSED:
    cur_pos_abs = cur_frame / 75;
    /* search for right track */
    for(tmp = thiscd.ntracks;
        tmp > 1 && cur_frame < thiscd.trk[CARRAY(tmp)].start;
        tmp--)
      ;
    thiscd.curtrack = tmp;
    /* Fall through */


  case WM_CDM_UNKNOWN:
    if (mode == WM_CDM_UNKNOWN)
    {
      mode = WM_CDM_NO_DISC;
      cur_lasttrack = cur_firsttrack = -1;
    }
    /* Fall through */

  case WM_CDM_STOPPED:
    if(thiscd.curtrack >= 1 && thiscd.curtrack <= thiscd.ntracks && thiscd.trk != NULL) {
      cur_trackname = thiscd.trk[CARRAY(thiscd.curtrack)].songname;
      cur_avoid = thiscd.trk[CARRAY(thiscd.curtrack)].avoid;
      cur_contd = thiscd.trk[CARRAY(thiscd.curtrack)].contd;
      cur_pos_rel = (cur_frame - thiscd.trk[CARRAY(thiscd.curtrack)].start) / 75;
      if (cur_pos_rel < 0)
        cur_pos_rel = -cur_pos_rel;
    }
    if((playlist != NULL) && playlist[0].start & (cur_listno > 0)) {
      cur_pos_abs -= thiscd.trk[playlist[CARRAY(cur_listno)].start - 1].start / 75;
      cur_pos_abs += playlist[CARRAY(cur_listno)].starttime;
    }
    if (cur_pos_abs < 0)
      cur_pos_abs = cur_frame = 0;

    if (thiscd.curtrack < 1)
      thiscd.curtracklen = thiscd.length;
    else
      thiscd.curtracklen = thiscd.trk[CARRAY(thiscd.curtrack)].length;
    /* Fall through */

  case WM_CDM_TRACK_DONE:
    wm_cur_cdmode = mode;
    break;
  case WM_CDM_FORWARD:
  case WM_CDM_EJECTED:
    wm_cur_cdmode = mode;
    break;	
  }

  wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS,
    "wm_cd_status returns %s\n", gen_status(wm_cur_cdmode));
  return wm_cur_cdmode;
}

int
wm_cd_getcurtrack( void )
{
  if(WM_CDS_NO_DISC(wm_cur_cdmode))
    return 0;
  return thiscd.curtrack;
}
  
int
wm_cd_getcurtracklen( void )
{
  if(WM_CDS_NO_DISC(wm_cur_cdmode))
    return 0;
    
  return thiscd.curtracklen;
}

int
wm_cd_getcountoftracks( void )
{
  if(WM_CDS_NO_DISC(wm_cur_cdmode))
    return 0;
    
  return thiscd.ntracks;
}

int wm_cd_gettracklen( int track )
{
  if (track < 1 ||
      track > thiscd.ntracks ||
      thiscd.trk == NULL)
    return 0;

  return thiscd.trk[CARRAY(track)].length;
}

/*
 * wm_cd_play(starttrack, pos, endtrack)
 *
 * Start playing the CD or jump to a new position.  "pos" is in seconds,
 * relative to start of track.
 */
int
wm_cd_play( int start, int pos, int end )
{
  int real_start, real_end, status;
  
  status = wm_cd_status();
  if(WM_CDS_NO_DISC(status) || thiscd.ntracks < 1)
    return -1;

  /*
   * check ranges
   */
  for(real_end = thiscd.ntracks; (thiscd.trk[CARRAY(real_end)].data == DATATRACK); real_end--)
    ;
  for(real_start = 1; (thiscd.trk[CARRAY(real_start)].data == DATATRACK); real_start++)
    ;
  
  if(end == WM_ENDTRACK) end = real_end;
  if(end > real_end) end = real_end;
  
  /*
   * handle as overrun
   */
  if(start < real_start) start = real_start;
  if(start > real_end) start = real_end;
  
  /*
   * Try to avoid mixed mode and CD-EXTRA data tracks
   */
  if(start > end || thiscd.trk[CARRAY(start)].data == DATATRACK) {
    wm_cd_stop();
    return -1;
  }
  
  cur_firsttrack = start;
  cur_lasttrack = end;

  wm_cd_play_chunk(thiscd.trk[CARRAY(start)].start + pos * 75, end == thiscd.ntracks ?
    thiscd.length * 75 : thiscd.trk[CARRAY(end)].start - 1, thiscd.trk[CARRAY(start)].start);
  /* So we don't update the display with the old frame number */
  wm_cd_status();

  return thiscd.curtrack;
}
  
/*
 * wm_cd_play_chunk(start, end)
 *
 * Play the CD from one position to another (both in frames.)
 */
int
wm_cd_play_chunk( int start, int end, int realstart )
{
  int status;
  
  status = wm_cd_status();
  if(WM_CDS_NO_DISC(status))
    return -1;
  
  end--;
  if (start >= end)
    start = end-1;
  
  if(!(drive.proto) || !(drive.proto->gen_play)) {
    perror("WM gen_play:  function pointer NULL");
    return -1;
  }

  return (drive.proto->gen_play)(&drive, start, end, realstart);
}
  
/*
 * Set the offset into the current track and play.  -1 means end of track
 * (i.e., go to next track.)
 */
int
wm_cd_play_from_pos( int pos )
{
  int status;
  
  status = wm_cd_status();
  if(WM_CDS_NO_DISC(status))
    return -1;
  
  if (pos == -1)
    pos = thiscd.trk[thiscd.curtrack - 1].length - 1;

  if (wm_cur_cdmode == WM_CDM_PLAYING)
    return wm_cd_play(thiscd.curtrack, pos, playlist[cur_listno-1].end);
  else
    return -1;
} /* wm_cd_play_from_pos() */

/*
 * wm_cd_pause()
 *
 * Pause the CD, if it's in play mode.  If it's already paused, go back to
 * play mode.
 */
int
wm_cd_pause( void )
{
  static int paused_pos;
  int status;
   
  status = wm_cd_status();
  if(WM_CDS_NO_DISC(status))
    return -1;

  if(WM_CDM_PLAYING == wm_cur_cdmode) {
    if(drive.proto && drive.proto->gen_pause)
      (drive.proto->gen_pause)(&drive);

    paused_pos = cur_pos_rel;
  } else if(WM_CDM_PAUSED == status) {
    if(!(drive.proto->gen_resume) || (drive.proto->gen_resume(&drive) > 0)) {
      wm_cd_play(thiscd.curtrack, paused_pos, playlist[cur_listno-1].end);
    }
  } else {
    return -1;
  }
  wm_cd_status();
  return 0;
} /* wm_cd_pause() */

/*
 * wm_cd_stop()
 *
 * Stop the CD if it's not already stopped.
 */
int
wm_cd_stop( void )
{
  int status;
   
  status = wm_cd_status();
  if(WM_CDS_NO_DISC(status))
    return -1;

  if (status != WM_CDM_STOPPED) {
    
    if(drive.proto && drive.proto->gen_stop)
      (drive.proto->gen_stop)(&drive);

    status = wm_cd_status();
  }
  
  return (status != WM_CDM_STOPPED);
} /* wm_cd_stop() */

/*
 * Eject the current CD, if there is one, and set the mode to 5.
 *
 * Returns 0 on success, 1 if the CD couldn't be ejected, or 2 if the
 * CD contains a mounted filesystem.
 */
int
wm_cd_eject( void )
{
  int err = -1;

  wm_cd_stop();
  
  if(drive.proto && drive.proto->gen_eject)
    err = (drive.proto->gen_eject)(&drive);

  if (err < 0) {
    if (err == -3) {
      return 2;
    } else {
      return 1;
    }
  }

  wm_cd_status();

  return 0;
}

int wm_cd_closetray(void)
{
  int status, err = -1;

  status = wm_cd_status();
  if (status == WM_CDM_UNKNOWN || status == WM_CDM_NO_DISC)
    return -1;

  if(drive.proto->gen_closetray)
    err = (drive.proto->gen_closetray)(&drive);

  return(err ? 0 : wm_cd_status()==2 ? 1 : 0);
} /* wm_cd_closetray() */

struct cdtext_info*
wm_cd_get_cdtext( void )
{
  int status;

  status = wm_cd_status();
  
  if(WM_CDS_NO_DISC(status))
    return NULL;
  
  return get_glob_cdtext(&drive, 0);
}

/*
 * find_trkind(track, index, start)
 *
 * Start playing at a particular track and index, optionally using a particular
 * frame as a starting position.  Returns a frame number near the start of the
 * index mark if successful, 0 if the track/index didn't exist.
 *
 * This is made significantly more tedious (though probably easier to port)
 * by the fact that CDROMPLAYTRKIND doesn't work as advertised.  The routine
 * does a binary search of the track, terminating when the interval gets to
 * around 10 frames or when the next track is encountered, at which point
 * it's a fair bet the index in question doesn't exist.
 */
int
wm_find_trkind( int track, int ind, int start )
{
  int top = 0, bottom, current, interval, ret = 0, i, status;

  status = wm_cd_status();
  if(WM_CDS_NO_DISC(status))
    return 0;

  for (i = 0; i < thiscd.ntracks; i++) {
    if (thiscd.trk[i].track == track)
      break;
  }

  bottom = thiscd.trk[i].start;

  for (; i < thiscd.ntracks; i++) {
    if (thiscd.trk[i].track > track)
      break;
  }

  top = i == thiscd.ntracks ? (thiscd.length - 1) * 75 : thiscd.trk[i].start;
  if (start > bottom && start < top)
    bottom = start;

  current = (top + bottom) / 2;
  interval = (top - bottom) / 4;

  do {
    wm_cd_play_chunk(current, current + 75, current);

    if (wm_cd_status() != 1)
      return 0;
    while (cur_frame < current) {
      if(wm_cd_status() != 1 || wm_cur_cdmode != WM_CDM_PLAYING)
        return 0;
      else
       wm_susleep(1);
    }

    if (thiscd.trk[thiscd.curtrack - 1].track > track)
      break;

    if(cur_index >= ind) {
      ret = current;
      current -= interval;
    } else {
      current += interval;
    }

    interval /= 2;

  } while (interval > 2);

  return ret;
} /* find_trkind() */

int
wm_cd_set_verbosity( int level )
{
  wm_lib_set_verbosity(level);
  return wm_lib_get_verbosity();
}

/*
 * volume is valid WM_VOLUME_MUTE <= vol <= WM_VOLUME_MAXIMAL,
 * balance is valid WM_BALANCE_ALL_LEFTS <= balance <= WM_BALANCE_ALL_RIGHTS
 */

int
wm_cd_volume( int vol, int bal )
{
  int left, right;
  const int bal1 = (vol - WM_VOLUME_MUTE)/(WM_BALANCE_ALL_RIGHTS - WM_BALANCE_SYMMETRED);

/*
 * Set "left" and "right" to volume-slider values accounting for the
 * balance setting.
 *
 */
  if(vol < WM_VOLUME_MUTE) vol = WM_VOLUME_MUTE;
  if(vol > WM_VOLUME_MAXIMAL) vol = WM_VOLUME_MAXIMAL;
  if(bal < WM_BALANCE_ALL_LEFTS) bal = WM_BALANCE_ALL_LEFTS;
  if(bal > WM_BALANCE_ALL_RIGHTS) bal = WM_BALANCE_ALL_RIGHTS;
  
  left = vol - (bal * bal1);
  right = vol + (bal * bal1);
  
  wm_lib_message(WM_MSG_LEVEL_DEBUG|WM_MSG_CLASS, "calculate volume left %i, right %i\n", left, right);
  
  if (left > WM_VOLUME_MAXIMAL)
    left = WM_VOLUME_MAXIMAL;
  if (right > WM_VOLUME_MAXIMAL)
    right = WM_VOLUME_MAXIMAL;

  if(!(drive.proto) || !(drive.proto->gen_set_volume))
    return -1;
  else
    return (drive.proto->gen_set_volume)(&drive, left, right);
} /* cd_volume() */

int
wm_cd_getvolume( void )
{
  int left, right;

  if(!(drive.proto) || !(drive.proto->gen_get_volume) ||
    (drive.proto->gen_get_volume)(&drive, &left, &right) < 0 || left == -1)
    return -1;

  if (left < right) {
    wm_cd_cur_balance = (right - left) / 2;
    if (wm_cd_cur_balance > WM_BALANCE_ALL_RIGHTS)
      wm_cd_cur_balance = WM_BALANCE_ALL_RIGHTS;
    return right;
  } else if (left == right) {
    wm_cd_cur_balance = WM_BALANCE_SYMMETRED;
    return left;
  } else {
    wm_cd_cur_balance = (right - left) / 2;
    if (wm_cd_cur_balance < WM_BALANCE_ALL_LEFTS)
      wm_cd_cur_balance = WM_BALANCE_ALL_LEFTS;
    return left;
  }
}

int
wm_cd_getbalance( void )
{
  int left, right;

  if(!(drive.proto) || !(drive.proto->gen_get_volume) ||
    (drive.proto->gen_get_volume)(&drive, &left, &right) < 0 || left == -1)
    return WM_BALANCE_SYMMETRED;

  if (left < right) {
    wm_cd_cur_balance = (right - left) / 2;
    if (wm_cd_cur_balance > WM_BALANCE_ALL_RIGHTS)
      wm_cd_cur_balance = WM_BALANCE_ALL_RIGHTS;
  } else if (left == right) {
    wm_cd_cur_balance = WM_BALANCE_SYMMETRED;
  } else {
    wm_cd_cur_balance = (right - left) / 2;
    if (wm_cd_cur_balance < WM_BALANCE_ALL_LEFTS)
      wm_cd_cur_balance = WM_BALANCE_ALL_LEFTS;
  }
  return wm_cd_cur_balance;
}

/*
 * Prototype wm_drive structure, with generic functions.  The generic functions
 * will be replaced with drive-specific functions as appropriate once the drive
 * type has been sensed.
 */
struct wm_drive_proto generic_proto = {
	gen_init, /* functions... */
	gen_close,
	gen_get_trackcount,
	gen_get_cdlen,
	gen_get_trackinfo,
	gen_get_drive_status,
	gen_get_volume,
	gen_set_volume,
	gen_pause,
	gen_resume,
	gen_stop,
	gen_play,
	gen_eject,
	gen_closetray,
	gen_get_cdtext
};

const char*
gen_status(int status)
{
  static char tmp[250];
  switch(status) {
  case WM_CDM_TRACK_DONE:
    return "WM_CDM_TRACK_DONE";
  case WM_CDM_PLAYING:
    return "WM_CDM_PLAYING";
  case WM_CDM_FORWARD:
    return "WM_CDM_FORWARD";
  case WM_CDM_PAUSED:
    return "WM_CDM_PAUSED";
  case WM_CDM_STOPPED:
    return "WM_CDM_STOPPED";
  case WM_CDM_EJECTED:
    return "WM_CDM_EJECTED";
  case WM_CDM_DEVICECHANGED:
    return "WM_CDM_DEVICECHANGED";
  case WM_CDM_NO_DISC:
    return "WM_CDM_NO_DISC";
  case WM_CDM_UNKNOWN:
    return "WM_CDM_UNKNOWN";
  case WM_CDM_CDDAERROR:
    return "WM_CDM_CDDAERROR";
  case WM_CDM_CDDAACK:
    return "WM_CDM_CDDAACK";
  default:
    {
      sprintf(tmp, "unexpected status %i", status);
      return tmp;
    }
  }
}