/*

 * MP3/MPlayer plugin to VDR (C++)

 *

 * (C) 2001-2009 Stefan Huelswitt <s.huelswitt@gmx.de>

 *

 * This code 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 2

 * of the License, or (at your option) any later version.

 *

 * This code 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, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html

 */

#ifdef TEST_MAIN

#define HAVE_SNDFILE

#define REMOTE_LIRC

#define _GNU_SOURCE

#define DEBUG

#endif

#ifdef HAVE_SNDFILE

#include <ctype.h>

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <errno.h>

#include <sys/types.h>

#include <unistd.h>

#include <math.h>

#include "common.h"

#include "setup-mp3.h"

#include "decoder-snd.h"

#include "data.h"

#include "network.h"

#include "menu-async.h"

#include "i18n.h"

#include "version.h"

#ifndef SNDFILE_1

#error You must use libsndfile version 1.x.x

#endif

#define CDFS_TRACK_OFF 150

#define CDFS_PROC      "/proc/cdfs"

#define CDFS_MARK_ID   "CD (discid=%x) contains %d tracks:"

#define CDFS_MARK_TR   "%*[^[][ %d - %d"

#define CDFS_TRACK     "track-"

#define CDDB_PROTO 5                   // used protocol level

#define CDDB_TOUT  30*1000             // connection timeout (ms)

#define CDDB_CHARSET "ISO8859-1"       // data charset

const char *cddbpath="/var/lib/cddb";  // default local cddb path

#define CDDB_DEBUG  // debug cddb queries

//#define DEBUG_CDFS  // debug cdfs parsing

//#define GUARD_DEBUG // enable framebuffer guard

#if !defined(NO_DEBUG) && defined(DEBUG_CDFS)

#define dc(x) { (x); }

#else

#define dc(x) ; 

#endif

#ifndef TEST_MAIN

// --- cSndDecoder -------------------------------------------------------------

#define SF_SAMPLES (sizeof(pcm->samples[0])/sizeof(mad_fixed_t))

cSndDecoder::cSndDecoder(const char *Filename)

:cDecoder(Filename)

,file(Filename)

,info(&file)

{

  pcm=0; framebuff=0; playing=ready=false;

}

cSndDecoder::~cSndDecoder()

{

  Clean();

}

bool cSndDecoder::Valid(void)

{

  bool res=false;

  if(TryLock()) {

    if(file.Open(false)) res=true;

    cDecoder::Unlock();

    }

  return res;

}

cFileInfo *cSndDecoder::FileInfo(void)

{

  cFileInfo *fi=0;

  if(file.HasInfo()) fi=&file;

  else if(TryLock()){

    if(file.Open()) { fi=&file; file.Close(); }

    cDecoder::Unlock();

    }

  return fi;

}

cSongInfo *cSndDecoder::SongInfo(bool get)

{

  cSongInfo *si=0;

  if(info.HasInfo()) si=&info;

  else if(get && TryLock()) {

    if(info.DoScan(false)) si=&info;

    cDecoder::Unlock();

    }

  return si;

}

cPlayInfo *cSndDecoder::PlayInfo(void)

{

  if(playing) {

    pi.Index=index/info.SampleFreq;

    pi.Total=info.Total;

    return π

    }

  return 0;

}

void cSndDecoder::Init(void)

{

  Clean();

  pcm=new struct mad_pcm;

  framebuff=MALLOC(int,2*SF_SAMPLES+8);

#ifdef GUARD_DEBUG

  for(int i=0; i<8; i++) framebuff[i+(SF_SAMPLES*2)-4]=0xdeadbeaf;

#endif

  index=0;

}

bool cSndDecoder::Clean(void)

{

  playing=false;

  buffMutex.Lock();

  run=false; bgCond.Broadcast();

  buffMutex.Unlock();

  cThread::Cancel(3);

  buffMutex.Lock();

  if(!ready) { deferedN=-1; ready=true; }

  fgCond.Broadcast();

  buffMutex.Unlock();

  delete pcm; pcm=0;

#ifdef GUARD_DEBUG

  if(framebuff) {

    printf("snd: bufferguard");

    for(int i=0; i<8; i++) printf(" %08x",framebuff[i+(SF_SAMPLES*2)-4]);

    printf("\n");

    }

#endif

  free(framebuff); framebuff=0;

  file.Close();

  return false;

}

bool cSndDecoder::Start(void)

{

  cDecoder::Lock(true);

  Init(); playing=true;

  if(file.Open() && info.DoScan(true)) {

    d(printf("snd: open rate=%d frames=%lld channels=%d format=0x%x seek=%d\n",

             file.sfi.samplerate,file.sfi.frames,file.sfi.channels,file.sfi.format,file.sfi.seekable))

    if(file.sfi.channels<=2) {

      ready=false; run=true; softCount=0;

      cThread::Start();

      cDecoder::Unlock();

      return true;

      }

    else esyslog("ERROR: cannot play sound file %s: more than 2 channels",filename);

    }

  cDecoder::Unlock();

  return Clean();

}

bool cSndDecoder::Stop(void)

{

  cDecoder::Lock();

  if(playing) Clean();

  cDecoder::Unlock();

  return true;

}

void cSndDecoder::Action(void)

{

  buffMutex.Lock();

  while(run) {

    if(ready) bgCond.Wait(buffMutex);

    if(!ready) {

      buffMutex.Unlock();

      deferedN=file.Stream(framebuff,SF_SAMPLES);

      buffMutex.Lock();

      ready=true; fgCond.Broadcast();

      }

    }

  buffMutex.Unlock();

}

struct Decode *cSndDecoder::Done(eDecodeStatus status)

{

  ds.status=status;

  ds.index=index*1000/info.SampleFreq;

  ds.pcm=pcm;

  cDecoder::Unlock(); // release the lock from Decode()

  return &ds;

}

struct Decode *cSndDecoder::Decode(void)

{

  cDecoder::Lock(); // this is released in Done()

  if(playing) {

    cMutexLock lock(&buffMutex);

    while(!ready)

      if(!softCount || !fgCond.TimedWait(buffMutex,softCount*5)) {

        if(softCount<20) softCount++;

        return Done(dsSoftError);

        }

    softCount=0;

    ready=false; bgCond.Broadcast();

    int n=deferedN;

    if(n<0) return Done(dsError);

    if(n==0) return Done(dsEof);

    pcm->samplerate=file.sfi.samplerate;

    pcm->channels=file.sfi.channels;

    pcm->length=n;

    index+=n;

    int *data=framebuff;

    mad_fixed_t *sam0=pcm->samples[0], *sam1=pcm->samples[1]; 

    const int s=(sizeof(int)*8)-1-MAD_F_FRACBITS; // shift value for mad_fixed conversion

    if(pcm->channels>1) {

      for(; n>0 ; n--) {

        *sam0++=(*data++) >> s;

        *sam1++=(*data++) >> s;

        }

      }

    else {

      for(; n>0 ; n--)

        *sam0++=(*data++) >> s;

      }

    return Done(dsPlay);

    }

  return Done(dsError);

}

bool cSndDecoder::Skip(int Seconds, float bsecs)

{

  cDecoder::Lock();

  bool res=false;

  if(playing && file.sfi.seekable) {

    float fsecs=(float)Seconds-bsecs;

    sf_count_t frames=(sf_count_t)(fsecs*(float)file.sfi.samplerate);

    sf_count_t newpos=file.Seek(0,true)+frames;

    if(newpos>file.sfi.frames) newpos=file.sfi.frames-1;

    if(newpos<0) newpos=0;

    d(printf("snd: skip: secs=%d fsecs=%f frames=%lld current=%lld new=%lld\n",Seconds,fsecs,frames,file.Seek(0,true),newpos))

    buffMutex.Lock();

    frames=file.Seek(newpos,false);

    ready=false; bgCond.Broadcast();

    buffMutex.Unlock();

    if(frames>=0) {

      index=frames;

#ifdef DEBUG

      int i=frames/file.sfi.samplerate;

      printf("snd: skipping to %02d:%02d (frame %lld)\n",i/60,i%60,frames);

#endif

      res=true;

      }

    }

  cDecoder::Unlock();

  return res;

}

#endif //TEST_MAIN

// --- cDiscID -------------------------------------------------------------------

class cDiscID {

public:

  int discid, ntrks, nsecs;

  int *offsets;

  //

  cDiscID(void);

  ~cDiscID();

  bool Get(void);

  };

cDiscID::cDiscID(void)

{

  offsets=0; discid=ntrks=0;

}

cDiscID::~cDiscID()

{

  delete offsets;

}

bool cDiscID::Get(void)

{

  bool res=false;

  FILE *f=fopen(CDFS_PROC,"r");

  if(f) {

    char line[256];

    bool state=false;

    int tr=0;

    while(fgets(line,sizeof(line),f)) {

      if(!state) {

        int id, n;

        if(sscanf(line,CDFS_MARK_ID,&id,&n)==2) {

          d(printf("discid: found id=%08x n=%d\n",id,n))

          if(discid==id && ntrks==n) {

            res=true;

            break;

            }

          else {

            discid=id; ntrks=n;

            delete offsets; offsets=new int[ntrks];

            state=true;

            }

          }

        }

      else {

        int off, end;

        if(sscanf(line,CDFS_MARK_TR,&off,&end)==2) {

          dc(printf("discid: found offset=%d end=%d for track %d\n",off,end,tr+1))

          offsets[tr]=off+CDFS_TRACK_OFF;

          if(++tr==ntrks) {

            nsecs=(end+1)/75;

            dc(printf("discid: nsecs=%d / 0x%x\n",nsecs,nsecs))

            res=true;

            break;

            }

          }

        }

      }

    fclose(f);

    }

  return res;

}

// --- cCDDBSong ---------------------------------------------------------------

// The CDDB code is loosely based on the implementation in mp3c 0.27 which is

// (C) 1999-2001 WSPse, Matthias Hensler, <matthias@wspse.de>

class cCDDBSong : public cListObject {

public:

  cCDDBSong(void);

  ~cCDDBSong();

  //

  int Track;

  char *TTitle, *ExtT;

  char *Title, *Artist;

  };

cCDDBSong::cCDDBSong(void)

{

  Title=Artist=0; TTitle=ExtT=0;

}

cCDDBSong::~cCDDBSong()

{

  free(Title);

  free(Artist);

  free(TTitle);

  free(ExtT);

}

// --- cCDDBDisc ---------------------------------------------------------------

const char *sampler[] = { // some artist names to identify sampler discs

  "various",

  "varios",

  "variété",

  "compilation",

  "sampler",

  "mixed",

  "divers",

  "v.a.",

  "VA",

  "misc",

  "none",

  0 };

class cCDDBDisc : public cList<cCDDBSong> {

private:

  int DiscID;

  //

  bool isSampler;

  char *DTitle, *ExtD;

  //

  cCDDBSong *GetTrack(const char *name, unsigned int pos);

  cCDDBSong *FindTrack(int tr);

  void Strcat(char * &store, const char *value);

  bool Split(const char *source, char div, char * &first, char * &second, bool only3=false);

  void Put(const char *from, char * &to);

  void Clean(void);

public:

  cCDDBDisc(void);

  ~cCDDBDisc();

  bool Load(cDiscID *id, const char *filename);

  bool Cached(cDiscID *id) { return DiscID==id->discid; }

  bool TrackInfo(int tr, cSongInfo *si);

  //

  char *Album, *Artist;

  int Year;

  };

cCDDBDisc::cCDDBDisc(void)

{

  Album=Artist=0; DTitle=ExtD=0; DiscID=0;

}

cCDDBDisc::~cCDDBDisc()

{

  Clean();

}

void cCDDBDisc::Clean(void)

{

  free(DTitle); DTitle=0;

  free(ExtD); ExtD=0;

  free(Artist); Artist=0;

  free(Album); Album=0;

  Year=-1; DiscID=0; isSampler=false;

}

bool cCDDBDisc::TrackInfo(int tr, cSongInfo *si)

{

  cCDDBSong *s=FindTrack(tr);

  if(s) {

    Put(s->Title,si->Title);

    if(s->Artist) Put(s->Artist,si->Artist); else Put(Artist,si->Artist);

    Put(Album,si->Album);

    if(Year>0) si->Year=Year;

    return true;

    }

  return false;

}

void cCDDBDisc::Put(const char *from, char * &to)

{

  free(to);

  to=from ? strdup(from):0;

}

bool cCDDBDisc::Load(cDiscID *id, const char *filename)

{

  char *p;

  Clean(); Clear();

  d(printf("cddb: loading discid %08x from %s\n",id->discid,filename))

  DiscID=id->discid;

  FILE *f=fopen(filename,"r");

  if(f) {

    cCharSetConv csc(CDDB_CHARSET);

    char buff[1024];

    while(fgets(buff,sizeof(buff),f)) {

      int i=strlen(buff);

      while(i && (buff[i-1]=='\n' || buff[i-1]=='\r')) buff[--i]=0;

      if(buff[0]=='#') { // special comment line handling

        }

      else {

        p=strchr(buff,'=');

        if(p) {

           *p=0;

           char *name =compactspace(buff);

           const char *value=csc.Convert(compactspace(p+1));

           if(*name && *value) {

             if(!strcasecmp(name,"DTITLE")) Strcat(DTitle,value);

             else if(!strcasecmp(name,"EXTD")) Strcat(ExtD,value);

             else if(!strcasecmp(name,"DYEAR")) Year=atoi(value);

             else if(!strncasecmp(name,"TTITLE",6)) {

               cCDDBSong *s=GetTrack(name,6);

               if(s) Strcat(s->TTitle,value);

               }

             else if(!strncasecmp(name,"EXTT",4)) {

               cCDDBSong *s=GetTrack(name,4);

               if(s) Strcat(s->ExtT,value);

               }

             }

           }

        }

      }

    fclose(f);

    // read all data, now post-processing

    if(Count()>0) {

      if(DTitle) {

        if(Split(DTitle,'/',Artist,Album)) {

          for(int n=0 ; sampler[n] ; n++)

            if(!strncasecmp(Artist,sampler[n],strlen(sampler[n]))) {

              isSampler=true;

              break;

              }

          }

        else {

          Album=strdup(DTitle);

          isSampler=true;

          }

        }

      d(printf("cddb: found artist='%s' album='%s' isSampler=%d\n",Artist,Album,isSampler))

      free(DTitle); DTitle=0;

      if(!isSampler && Artist && Album && !strncmp(Album,Artist,strlen(Artist))) {

        d(printf("cddb: detecting sampler from Artist==Album\n"))

        isSampler=true;

        }

      if(!isSampler) {

        int nofail1=0, nofail2=0;

        cCDDBSong *s=First();

        while(s) {

          if(s->TTitle) {

            if(strstr(s->TTitle," / ")) nofail1++;

            //if(strstr(s->TTitle," - ")) nofail2++;

            }

          s=Next(s);

          }

        if(nofail1==Count() || nofail2==Count()) {

          d(printf("cddb: detecting sampler from nofail\n"))

          isSampler=true;

          }

        }

      if(Year<0 && ExtD && (p=strstr(ExtD,"YEAR:"))) Year=atoi(p+5);

      free(ExtD); ExtD=0;

      d(printf("cddb: found year=%d\n",Year))

      cCDDBSong *s=First();

      while(s) {

        if(s->TTitle) {

          if(isSampler) {

            if(!Split(s->TTitle,'/',s->Artist,s->Title) && 

               !Split(s->TTitle,'-',s->Artist,s->Title,true)) {

              s->Title=compactspace(strdup(s->TTitle));

              if(s->ExtT) s->Artist=compactspace(strdup(s->ExtT));

              }

            }

          else {

            s->Title=compactspace(strdup(s->TTitle));

            if(Artist) s->Artist=strdup(Artist);

            }

          }

        else s->Title=strdup(tr("unknown"));

        free(s->TTitle); s->TTitle=0;

        free(s->ExtT); s->ExtT=0;

        d(printf("cddb: found track %d title='%s' artist='%s'\n",s->Track,s->Title,s->Artist))

        s=Next(s);

        }

      return true;

      }

    }

  return false;

}

bool cCDDBDisc::Split(const char *source, char div, char * &first, char * &second, bool only3)

{

  int pos=-1, n=0;

  char *p, l[4]={ ' ',div,' ',0 };

  if ((p=strstr(source,l))) { pos=p-source; n=3; }

  else if(!only3 && (p=strchr(source,div)))  { pos=p-source; n=1; }

  if(pos>=0) {

    free(first); first=strdup(source); first[pos]=0; compactspace(first);

    free(second); second=strdup(source+pos+n); compactspace(second);

    return true;

    }

  return false;

}

void cCDDBDisc::Strcat(char * &store, const char *value)

{

  if(store) {

    char *n=MALLOC(char,strlen(store)+strlen(value)+1);

    if(n) {

      strcpy(n,store);

      strcat(n,value);

      free(store); store=n;

      }

    }

  else store=strdup(value);

}

cCDDBSong *cCDDBDisc::GetTrack(const char *name, unsigned int pos)

{

  cCDDBSong *s=0;

  if(strlen(name)>pos) {

    int tr=atoi(&name[pos]);

    s=FindTrack(tr);

    if(!s) {

      s=new cCDDBSong;

      Add(s);

      s->Track=tr;

      }

    }

  return s;

}

cCDDBSong *cCDDBDisc::FindTrack(int tr)

{

  cCDDBSong *s=First();

  while(s) {

    if(s->Track==tr) break;

    s=Next(s);

    }

  return s;

}

#ifndef TEST_MAIN

// --- cCDDB -------------------------------------------------------------------

class cCDDB : public cScanDir, cMutex {

private:

  cCDDBDisc cache;

  cFileSource *src;

  cFileObj *file;

  cNet *net;

  char searchID[10], cddbstr[256];

  //

  virtual void DoItem(cFileSource *src, const char *subdir, const char *name);

  bool LocalQuery(cDiscID *id);

  bool RemoteGet(cDiscID *id);

  bool GetLine(char *buff, int size, bool log=true);

  int GetCddbResponse(void);

  int DoCddbCmd(const char *format, ...);

public:

  cCDDB(void);

  virtual ~cCDDB();

  bool Lookup(cDiscID *id, int track, cSongInfo *si);

  };

cCDDB cddb;

cCDDB::cCDDB(void)

{

  src=0; file=0; net=0;

}

cCDDB::~cCDDB()

{

  delete file;

  delete src;

  delete net;

}

bool cCDDB::Lookup(cDiscID *id, int track, cSongInfo *si)

{

  bool res=false;

  Lock();

  if(!cache.Cached(id)) {

    if(LocalQuery(id) || (MP3Setup.UseCddb>1 && RemoteGet(id) && LocalQuery(id)))

      cache.Load(id,file->FullPath());

    }

  if(cache.Cached(id) && cache.TrackInfo(track,si)) res=true;

  Unlock();

  return res;

}

bool cCDDB::LocalQuery(cDiscID *id)

{

  bool res=false;

  delete file; file=0;

  if(!src) src=new cFileSource(cddbpath,"CDDB database",false);

  if(src) {

    snprintf(searchID,sizeof(searchID),"%08x",id->discid);

    if(ScanDir(src,0,stDir,0,0,false) && file) res=true;

    }

  return res;

}

void cCDDB::DoItem(cFileSource *src, const char *subdir, const char *name)

{

  if(!file) {

    file=new cFileObj(src,name,searchID,otFile);

    if(access(file->FullPath(),R_OK)) { delete file; file=0; }

    }

}

bool cCDDB::RemoteGet(cDiscID *id)

{

  bool res=false;

  asyncStatus.Set(tr("Remote CDDB lookup..."));

  delete net; net=new cNet(16*1024,CDDB_TOUT,CDDB_TOUT);

  if(net->Connect(MP3Setup.CddbHost,MP3Setup.CddbPort)) {

    int code=GetCddbResponse();

    if(code/100==2) {

      const char *host=getenv("HOSTNAME"); if(!host) host="unknown";

      const char *user=getenv("USER"); if(!user) user="nobody";

      code=DoCddbCmd("cddb hello %s %s %s %s\n",user,host,PLUGIN_NAME,PluginVersion);

      if(code/100==2) {

        code=DoCddbCmd("proto %d\n",CDDB_PROTO);

        if(code>0) {

          char off[1024];

          off[0]=0; for(int i=0 ; i<id->ntrks ; i++) sprintf(&off[strlen(off)]," %d",id->offsets[i]);

          code=DoCddbCmd("cddb query %08x %d %s %d\n",id->discid,id->ntrks,off,id->nsecs);

          if(code/100==2) {

            char *cat=0;

            if(code==200) cat=strdup(cddbstr);

            else if(code==210) {

              if(GetLine(off,sizeof(off))) {

                cat=strdup(off);

                while(GetLine(off,sizeof(off)) && off[0]!='.');

                }

              }

            if(cat) {

              char *s=index(cat,' '); if(s) *s=0;

              code=DoCddbCmd("cddb read %s %08x\n",cat,id->discid);

              if(code==210) {

                char *name=aprintf("%s/%s/%08x",cddbpath,cat,id->discid);

                if(MakeDirs(name,false)) {

                  FILE *out=fopen(name,"w");

                  if(out) {

                    while(GetLine(off,sizeof(off),false) && off[0]!='.') fputs(off,out);

                    fclose(out);

                    res=true;

                    }

                  else esyslog("fopen() failed: %s",strerror(errno));

                  }

                free(name);

                }

              else if(code>0) esyslog("server read error: %d %s",code,cddbstr);

              free(cat);

              }

            }

          else if(code>0) esyslog("server query error: %d %s",code,cddbstr);

          }

        else esyslog("server proto error: %d %s",code,cddbstr);

        }

      else if(code>0) esyslog("server hello error: %d %s",code,cddbstr);

      }

    else if(code>0) esyslog("server sign-on error: %d %s",code,cddbstr);

    }

  delete net; net=0;

  asyncStatus.Set(0);

  return res;

}

bool cCDDB::GetLine(char *buff, int size, bool log)

{

  if(net->Gets(buff,size)>0) {

#ifdef CDDB_DEBUG

    if(log) printf("cddb: <- %s",buff);

#endif

    return true;

    }

  return false;

}

int cCDDB::GetCddbResponse(void)

{

  char buf[1024];

  if(GetLine(buf,sizeof(buf))) {

    int code;

    if(sscanf(buf,"%d %255[^\n]",&code,cddbstr)==2) return code;

    else esyslog("Unexpected server response: %s",buf);

    }

  return -1;

}

int cCDDB::DoCddbCmd(const char *format, ...)

{

  va_list ap;

  va_start(ap,format);

  char *buff=0;

  if(vasprintf(&buff,format,ap)<0);

  va_end(ap);

#ifdef CDDB_DEBUG

  printf("cddb: -> %s",buff);

#endif

  int r=net->Puts(buff);

  free(buff);

  if(r<0) return -1;

  return GetCddbResponse();

}

// --- cSndInfo ----------------------------------------------------------------

cSndInfo::cSndInfo(cSndFile *File)

{

  file=File;

  id=new cDiscID;

}

cSndInfo::~cSndInfo()

{

  delete id;

}

bool cSndInfo::Abort(bool result)

{

  if(!keepOpen) file->Close();

  return result;

}

bool cSndInfo::DoScan(bool KeepOpen)

{

  keepOpen=KeepOpen;

  if(!file->Open()) return Abort(false);

  if(HasInfo()) return Abort(true);

  // check the infocache

  cCacheData *dat=InfoCache.Search(file);

  if(dat) {

    Set(dat); dat->Unlock();

    ConvertToSys();

    if(!DecoderID) {

      DecoderID=DEC_SND;

      InfoCache.Cache(this,file);

      }

    return Abort(true);

    }

  Clear();

  if(file->FsType!=CDFS_MAGIC || !MP3Setup.UseCddb || !CDDBLookup(file->Filename))

    FakeTitle(file->Filename);

  Frames=file->sfi.frames;

  SampleFreq=file->sfi.samplerate;

  Channels=file->sfi.channels;

  ChMode=Channels>1 ? 3:0;

  Total=Frames/SampleFreq;

  Bitrate=Total ? file->Filesize*8/Total : 0; //XXX SampleFreq*Channels*file->sfi.pcmbitwidth;

  DecoderID=DEC_SND;

  InfoDone();

  InfoCache.Cache(this,file);

  ConvertToSys();

  return Abort(true);

}

bool cSndInfo::CDDBLookup(const char *filename)

{

  if(id->Get()) {

    int tr;

    char *s=strstr(filename,CDFS_TRACK);

    if(s && sscanf(s+strlen(CDFS_TRACK),"%d",&tr)==1) {

      d(printf("snd: looking up disc id %08x track %d\n",id->discid,tr))

      return cddb.Lookup(id,tr-1,this);

      }

    }

  return false;

}

// --- cSndFile ----------------------------------------------------------------

cSndFile::cSndFile(const char *Filename)

:cFileInfo(Filename)

{

  sf=0;

}

cSndFile::~cSndFile()

{

  Close();

}

bool cSndFile::Open(bool log)

{

  if(sf) return (Seek()>=0);

  if(FileInfo(log)) {

    sf=sf_open(Filename,SFM_READ,&sfi);

    if(!sf && log) Error("open");

    }

  return (sf!=0);

}

void cSndFile::Close(void)

{

  if(sf) { sf_close(sf); sf=0; } 

}

void cSndFile::Error(const char *action)

{

  char buff[128];

  sf_error_str(sf,buff,sizeof(buff));

  esyslog("ERROR: sndfile %s failed on %s: %s",action,Filename,buff);

}

sf_count_t cSndFile::Seek(sf_count_t frames, bool relativ)

{

  int dir=SEEK_CUR;

  if(!relativ) dir=SEEK_SET;

  int n=sf_seek(sf,frames,dir);

  if(n<0) Error("seek");

  return n;

}

sf_count_t cSndFile::Stream(int *buffer, sf_count_t frames)

{

  sf_count_t n=sf_readf_int(sf,buffer,frames);

  if(n<0) Error("read");

  return n;

}

#endif //TEST_MAIN

#endif //HAVE_SNDFILE

#ifdef TEST_MAIN

//

// to compile:

// g++ -g -DTEST_MAIN -o test mp3-decoder-snd.c tools.o thread.o -lpthread

//

// calling:

// test <cddb-file>

//

extern const char *tr(const char *test)

{

  return test;

}

int main (int argc, char *argv[])

{

  cCDDBDisc cddb;

  cddb.Load(1,argv[1]);

  return 0;

}

#endif