/*

 * 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

 */

#include <stdlib.h>

#include <getopt.h>

#include <strings.h>

#include <typeinfo>

#include "common.h"

#include <vdr/menuitems.h>

#include <vdr/status.h>

#include <vdr/plugin.h>

#include <vdr/interface.h>

#include <vdr/skins.h>

#include "setup.h"

#include "setup-mp3.h"

#include "data-mp3.h"

#include "data-src.h"

#include "player-mp3.h"

#include "menu.h"

#include "menu-async.h"

#include "decoder.h"

#include "i18n.h"

#include "version.h"

#include "service.h"

#ifdef DEBUG

#include <mad.h>

#endif

const char *sourcesSub=0;

cFileSources MP3Sources;

static const char *plugin_name=0;

const char *i18n_name=0;

// --- cMenuSetupMP3 --------------------------------------------------------

class cMenuSetupMP3 : public cMenuSetupPage {

private:

  cMP3Setup data;

  //

  const char *cddb[3], *disp[2], *scan[3], *bgr[3];

  const char *aout[AUDIOOUTMODES];

  int amode, amodes[AUDIOOUTMODES];

protected:

  virtual void Store(void);

public:

  cMenuSetupMP3(void);

  };

cMenuSetupMP3::cMenuSetupMP3(void)

{

  static const char allowed[] = { "abcdefghijklmnopqrstuvwxyz0123456789-_" };

  int numModes=0;

  aout[numModes]=trVDR("DVB"); amodes[numModes]=AUDIOOUTMODE_DVB; numModes++;

#ifdef WITH_OSS

  aout[numModes]=tr("OSS"); amodes[numModes]=AUDIOOUTMODE_OSS; numModes++;

#endif

  data=MP3Setup;

  amode=0;

  for(int i=0; i<numModes; i++)

    if(amodes[i]==data.AudioOutMode) { amode=i; break; }

  SetSection(tr("MP3"));

  Add(new cMenuEditStraItem(tr("Setup.MP3$Audio output mode"),     &amode,numModes,aout));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Audio mode"),            &data.AudioMode, tr("Round"), tr("Dither")));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Use 48kHz mode only"),   &data.Only48kHz));

  disp[0]=tr("classic");

  disp[1]=tr("via skin");

  Add(new cMenuEditStraItem(tr("Setup.MP3$Replay display"),        &data.ReplayDisplay, 2, disp));

  Add(new cMenuEditIntItem( tr("Setup.MP3$Display mode"),          &data.DisplayMode, 1, 3));

  bgr[0]=tr("Black");

  bgr[1]=tr("Live");

  bgr[2]=tr("Images");

  Add(new cMenuEditStraItem(tr("Setup.MP3$Background mode"),       &data.BackgrMode, 3, bgr));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Initial loop mode"),     &data.InitLoopMode));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Initial shuffle mode"),  &data.InitShuffleMode));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Abort player at end of list"),&data.AbortAtEOL));

  scan[0]=tr("disabled");

  scan[1]=tr("ID3 only");

  scan[2]=tr("ID3 & Level");

  Add(new cMenuEditStraItem(tr("Setup.MP3$Background scan"),       &data.BgrScan, 3, scan));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Editor display mode"),   &data.EditorMode, tr("Filenames"), tr("ID3 names")));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Mainmenu mode"),         &data.MenuMode, tr("Playlists"), tr("Browser")));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Keep selection menu"),   &data.KeepSelect));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Title/Artist order"),    &data.TitleArtistOrder, tr("Normal"), tr("Reversed")));

  Add(new cMenuEditBoolItem(tr("Hide mainmenu entry"),             &data.HideMainMenu));

  Add(new cMenuEditIntItem( tr("Setup.MP3$Normalizer level"),      &data.TargetLevel, 0, MAX_TARGET_LEVEL));

  Add(new cMenuEditIntItem( tr("Setup.MP3$Limiter level"),         &data.LimiterLevel, MIN_LIMITER_LEVEL, 100));

  Add(new cMenuEditBoolItem(tr("Setup.MP3$Use HTTP proxy"),        &data.UseProxy));

  Add(new cMenuEditStrItem( tr("Setup.MP3$HTTP proxy host"),       data.ProxyHost,MAX_HOSTNAME,allowed));

  Add(new cMenuEditIntItem( tr("Setup.MP3$HTTP proxy port"),       &data.ProxyPort,1,65535));

  cddb[0]=tr("disabled");

  cddb[1]=tr("local only");

  cddb[2]=tr("local&remote");

  Add(new cMenuEditStraItem(tr("Setup.MP3$CDDB for CD-Audio"),     &data.UseCddb,3,cddb));

  Add(new cMenuEditStrItem( tr("Setup.MP3$CDDB server"),           data.CddbHost,MAX_HOSTNAME,allowed));

  Add(new cMenuEditIntItem( tr("Setup.MP3$CDDB port"),             &data.CddbPort,1,65535));

}

void cMenuSetupMP3::Store(void)

{

  data.AudioOutMode=amodes[amode];

  MP3Setup=data;

  SetupStore("InitLoopMode",     MP3Setup.InitLoopMode   );

  SetupStore("InitShuffleMode",  MP3Setup.InitShuffleMode);

  SetupStore("AudioMode",        MP3Setup.AudioMode      );

  SetupStore("AudioOutMode",     MP3Setup.AudioOutMode   );

  SetupStore("BgrScan",          MP3Setup.BgrScan        );

  SetupStore("EditorMode",       MP3Setup.EditorMode     );

  SetupStore("DisplayMode",      MP3Setup.DisplayMode    );

  SetupStore("BackgrMode",       MP3Setup.BackgrMode     );

  SetupStore("MenuMode",         MP3Setup.MenuMode       );

  SetupStore("TargetLevel",      MP3Setup.TargetLevel    );

  SetupStore("LimiterLevel",     MP3Setup.LimiterLevel   );

  SetupStore("Only48kHz",        MP3Setup.Only48kHz      );

  SetupStore("UseProxy",         MP3Setup.UseProxy       );

  SetupStore("ProxyHost",        MP3Setup.ProxyHost      );

  SetupStore("ProxyPort",        MP3Setup.ProxyPort      );

  SetupStore("UseCddb",          MP3Setup.UseCddb        );

  SetupStore("CddbHost",         MP3Setup.CddbHost       );

  SetupStore("CddbPort",         MP3Setup.CddbPort       );

  SetupStore("AbortAtEOL",       MP3Setup.AbortAtEOL     );

  SetupStore("ReplayDisplay",    MP3Setup.ReplayDisplay  );

  SetupStore("HideMainMenu",     MP3Setup.HideMainMenu   );

  SetupStore("KeepSelect",       MP3Setup.KeepSelect     );

  SetupStore("TitleArtistOrder", MP3Setup.TitleArtistOrder);

}

// --- cAsyncStatus ------------------------------------------------------------

cAsyncStatus asyncStatus;

cAsyncStatus::cAsyncStatus(void)

{

  text=0;

  changed=false;

}

cAsyncStatus::~cAsyncStatus()

{

  free((void *)text);

}

void cAsyncStatus::Set(const char *Text)

{

  Lock();

  free((void *)text);

  text=Text ? strdup(Text) : 0;

  changed=true;

  Unlock();

}

const char *cAsyncStatus::Begin(void)

{

  Lock();

  return text;

}

void cAsyncStatus::Finish(void)

{

  changed=false;

  Unlock();

}

// --- --------------------------------------------------------------------

static const char *TitleArtist(const char *title, const char *artist)

{

  static char buf[256]; // clearly not multi-thread save!

  const char *fmt;

  if(artist && artist[0]) {

    if(MP3Setup.TitleArtistOrder) fmt="%2$s - %1$s";

    else  fmt="%s - %s";

    }

  else fmt="%s";

  snprintf(buf,sizeof(buf),fmt,title,artist);

  return buf;

}

// --- cMP3Control --------------------------------------------------------

#define MAXROWS 120

class cMP3Control : public cControl {

private:

  cOsd *osd;

  const cFont *font;

  cSkinDisplayReplay *disp;

  int bw, bh, bwc, fw, fh;

  //

  cMP3Player *player;

  bool visible, shown, bigwin, statusActive;

  time_t timeoutShow, greentime, oktime;

  int lastkeytime, number;

  bool selecting;

  //

  cMP3PlayInfo *lastMode;

  time_t fliptime, listtime;

  int hashlist[MAXROWS];

  int flip, flipint, top, rows;

  int lastIndex, lastTotal, lastTop;

  int framesPerSecond;

  //

  bool jumpactive, jumphide, jumpsecs;

  int jumpmm;

  //

  void ShowTimed(int Seconds=0);

  void ShowProgress(bool open=false, bool bigWin=false);

  void ShowStatus(bool force);

  void HideStatus(void);

  void DisplayInfo(const char *s=0);

  void JumpDisplay(void);

  void JumpProcess(eKeys Key);

  void Jump(void);

  void Stop(void);

  void Write(int x, int y, int w, const char *text, int fg=clrWhite, int bg=clrGray50);

  void Fill(int x, int y, int w, int h, int fg);

  inline void Flush(void);

public:

  cMP3Control(void);

  virtual ~cMP3Control();

  virtual eOSState ProcessKey(eKeys Key);

  virtual void Show(void) { ShowTimed(); }

  virtual void Hide(void);

  bool Visible(void) { return visible; }

  static bool SetPlayList(cPlayList *plist);

  };

cMP3Control::cMP3Control(void)

:cControl(player=new cMP3Player)

{

  visible=shown=bigwin=selecting=jumpactive=jumphide=statusActive=false;

  timeoutShow=greentime=oktime=0;

  lastkeytime=number=0;

  lastMode=0;

  framesPerSecond=SecondsToFrames(1);

  osd=0; disp=0;

  font=cFont::GetFont(fontOsd);

  cStatus::MsgReplaying(this,"MP3",0,true);

}

cMP3Control::~cMP3Control()

{

  delete lastMode;

  Hide();

  Stop();

}

void cMP3Control::Stop(void)

{

  cStatus::MsgReplaying(this,0,0,false);

  delete player; player=0;

  mgr->Halt();

  mgr->Flush(); //XXX remove later

}

bool cMP3Control::SetPlayList(cPlayList *plist)

{

  bool res;

  cControl *control=cControl::Control();

  // is there a running MP3 player?

  if(control && typeid(*control)==typeid(cMP3Control)) {

    // add songs to running playlist

    mgr->Add(plist);

    res=true;

    }

  else {

    mgr->Flush();

    mgr->Add(plist);

    cControl::Launch(new cMP3Control);

    res=false;

    }

  delete plist;

  return res;

}

void cMP3Control::ShowTimed(int Seconds)

{

  if(!visible) {

    ShowProgress(true);

    timeoutShow=(Seconds>0) ? time(0)+Seconds : 0;

    }

}

void cMP3Control::Hide(void)

{

  HideStatus();

  timeoutShow=0;

  if(visible) {

    delete osd; osd=0;

    delete disp; disp=0;

    visible=bigwin=false;

#if APIVERSNUM >= 10500

    SetNeedsFastResponse(false);

#else

    needsFastResponse=false;

#endif

    }

}

void cMP3Control::ShowStatus(bool force)

{

  if((asyncStatus.Changed() || (force && !statusActive)) && !jumpactive) {

    const char *text=asyncStatus.Begin();

    if(text) {

      if(MP3Setup.ReplayDisplay || !osd) {

        if(statusActive) Skins.Message(mtStatus,0);

        Skins.Message(mtStatus,text);

        }

      else {

        if(!statusActive) osd->SaveRegion(0,bh-2*fh,bw-1,bh-fh-1);

        osd->DrawText(0,bh-2*fh,text,clrBlack,clrCyan,font,bw,fh,taCenter);

        osd->Flush();

        }

      statusActive=true;

      }

    else

      HideStatus();

    asyncStatus.Finish();

    }

}

void cMP3Control::HideStatus(void)

{

  if(statusActive) {

    if(MP3Setup.ReplayDisplay || !osd)

      Skins.Message(mtStatus,0);

    else {

      osd->RestoreRegion();

      osd->Flush();

      }

    }

  statusActive=false;

}

#define CTAB    11 // some tabbing values for the progress display

#define CTAB2   5

void cMP3Control::Write(int x, int y, int w, const char *text, int fg, int bg)

{

  if(osd) {

    x*=fw; if(x<0) x+=bw;

    y*=fh; if(y<0) y+=bh;

    osd->DrawText(x,y,text,fg,bg,font,w*fw);

    }

}

void cMP3Control::Fill(int x, int y, int w, int h, int fg)

{

  if(osd) {

    x*=fw; if(x<0) x+=bw;

    y*=fh; if(y<0) y+=bh;

    osd->DrawRectangle(x,y,x+w*fw-1,y+h*fh-1,fg);

    }

}

void cMP3Control::Flush(void)

{

  if(MP3Setup.ReplayDisplay) Skins.Flush();

  else if(osd) osd->Flush();

}

void cMP3Control::ShowProgress(bool open, bool bigWin)

{

  int index, total;

  if(player->GetIndex(index,total) && total>=0) {

    if(!visible && open) {

      HideStatus();

      if(MP3Setup.ReplayDisplay) {

        disp=Skins.Current()->DisplayReplay(false);

        if(!disp) return;

        bigWin=false;

        }

      else {

        int bt, bp;

        fw=font->Width(' ')*2;

        fh=font->Height();

        if(bigWin) {

          bw=Setup.OSDWidth;

          bh=Setup.OSDHeight;

          bt=0;

          bp=2*fh;

          rows=(bh-bp-fh/3)/fh;

          }

        else {

          bw=Setup.OSDWidth;

          bh=bp=2*fh;

          bt=Setup.OSDHeight-bh;

          rows=0;

          }

        bwc=bw/fw+1;

        //d(printf("mp3: bw=%d bh=%d bt=%d bp=%d bwc=%d rows=%d fw=%d fh=%d\n",

        //  bw,bh,bt,bp,bwc,rows,fw,fh))

        osd=cOsdProvider::NewOsd(Setup.OSDLeft,Setup.OSDTop+bt);

        if(!osd) return;

        if(bigWin) {

          tArea Areas[] = { { 0,0,bw-1,bh-bp-1,2 }, { 0,bh-bp,bw-1,bh-1,4 } };

          osd->SetAreas(Areas,sizeof(Areas)/sizeof(tArea));

          }

        else {

          tArea Areas[] = { { 0,0,bw-1,bh-1,4 } };

          osd->SetAreas(Areas,sizeof(Areas)/sizeof(tArea));

          }

        osd->DrawRectangle(0,0,bw-1,bh-1,clrGray50);

        osd->Flush();

        }

      ShowStatus(true);

      bigwin=bigWin;

      visible=true;

#if APIVERSNUM >= 10500

      SetNeedsFastResponse(true);

#else

      needsFastResponse=true;

#endif

      fliptime=listtime=0; flipint=0; flip=-1; top=lastTop=-1; lastIndex=lastTotal=-1;

      delete lastMode; lastMode=0;

      }

    cMP3PlayInfo *mode=new cMP3PlayInfo;

    bool valid=mgr->Info(-1,mode);

    bool changed=(!lastMode || mode->Hash!=lastMode->Hash);

    char buf[256];

    if(changed) { d(printf("mp3-ctrl: mode change detected\n")) }

    if(valid) { // send progress to status monitor

      if(changed || mode->Loop!=lastMode->Loop || mode->Shuffle!=lastMode->Shuffle) {

        snprintf(buf,sizeof(buf),"[%c%c] (%d/%d) %s",

                  mode->Loop?'L':'.',mode->Shuffle?'S':'.',mode->Num,mode->MaxNum,TitleArtist(mode->Title,mode->Artist));

        cStatus::MsgReplaying(this,buf,mode->Filename[0]?mode->Filename:0,true);

        }

      }

    if(visible) { // refresh the OSD progress display

      bool flush=false;

      if(MP3Setup.ReplayDisplay) {

        if(!statusActive) {

          if(total>0) disp->SetProgress(index,total);

          disp->SetCurrent(IndexToHMSF(index));

          disp->SetTotal(IndexToHMSF(total));

          bool Play, Forward;

          int Speed;

          if(GetReplayMode(Play,Forward,Speed)) 

            disp->SetMode(Play, Forward, Speed);

          flush=true;

          }

        }

      else {

        if(!selecting && changed && !statusActive) {

          snprintf(buf,sizeof(buf),"(%d/%d)",mode->Num,mode->MaxNum);

          Write(0,-2,CTAB,buf);

          flush=true;

          }

        if(!lastMode || mode->Loop!=lastMode->Loop) {

          if(mode->Loop) Write(-4,-1,0,"L",clrBlack,clrYellow);

          else Fill(-4,-1,2,1,clrGray50);

          flush=true;

          }

        if(!lastMode || mode->Shuffle!=lastMode->Shuffle) {

          if(mode->Shuffle) Write(-2,-1,0,"S",clrWhite,clrRed);

          else Fill(-2,-1,2,1,clrGray50);

          flush=true;

          }

        index/=framesPerSecond; total/=framesPerSecond;

        if(index!=lastIndex || total!=lastTotal) {

          if(total>0) {

            cProgressBar ProgressBar(bw-(CTAB+CTAB2)*fw,fh,index,total);

            osd->DrawBitmap(CTAB*fw,bh-fh,ProgressBar);

            }

          snprintf(buf,sizeof(buf),total?"%02d:%02d/%02d:%02d":"%02d:%02d",index/60,index%60,total/60,total%60);

          Write(0,-1,11,buf);

          flush=true;

          }

        }

      if(!jumpactive) {

        bool doflip=false;

        if(MP3Setup.ReplayDisplay && (!lastMode || mode->Loop!=lastMode->Loop || mode->Shuffle!=lastMode->Shuffle))

          doflip=true;

        if(!valid || changed) {

          fliptime=time(0); flip=0;

	  doflip=true;

	  }

        else if(time(0)>fliptime+flipint) {

	  fliptime=time(0);

	  flip++; if(flip>=MP3Setup.DisplayMode) flip=0;

          doflip=true;

	  }

        if(doflip) {

          buf[0]=0;

          switch(flip) {

	    default:

	      flip=0;

	      // fall through

	    case 0:

	      snprintf(buf,sizeof(buf),"%s",TitleArtist(mode->Title,mode->Artist));

	      flipint=6;

	      break;

	    case 1:

              if(mode->Album[0]) {

      	        snprintf(buf,sizeof(buf),mode->Year>0?"from: %s (%d)":"from: %s",mode->Album,mode->Year);

	        flipint=4;

	        }

              else fliptime=0;

              break;

	    case 2:

              if(mode->MaxBitrate>0)

                snprintf(buf,sizeof(buf),"%.1f kHz, %d-%d kbps, %s",mode->SampleFreq/1000.0,mode->Bitrate/1000,mode->MaxBitrate/1000,mode->SMode);

              else

                snprintf(buf,sizeof(buf),"%.1f kHz, %d kbps, %s",mode->SampleFreq/1000.0,mode->Bitrate/1000,mode->SMode);

	      flipint=3;

	      break;

	    }

          if(buf[0]) {

            if(MP3Setup.ReplayDisplay) {

              char buf2[256];

              snprintf(buf2,sizeof(buf2),"[%c%c] (%d/%d) %s",

                       mode->Loop?'L':'.',mode->Shuffle?'S':'.',mode->Num,mode->MaxNum,buf);

              disp->SetTitle(buf2);

              flush=true;

              }

            else {

              if(!statusActive) {

                DisplayInfo(buf);

                flush=true;

                }

              else { d(printf("mp3-ctrl: display info skip due to status active\n")) }

              }

            }

          }

        }

      if(bigwin) {

        bool all=(top!=lastTop || changed);

        if(all || time(0)>listtime+2) {

          int num=(top>0 && mode->Num==lastMode->Num) ? top : mode->Num - rows/2;

          if(num+rows>mode->MaxNum) num=mode->MaxNum-rows+1;

          if(num<1) num=1;

          top=num;

          for(int i=0 ; i<rows && i<MAXROWS && num<=mode->MaxNum ; i++,num++) {

            cMP3PlayInfo pi;

            mgr->Info(num,&pi); if(!pi.Title[0]) break;

            snprintf(buf,sizeof(buf),"%d.\t%s",num,TitleArtist(pi.Title,pi.Artist));

            int fg=clrWhite, bg=clrGray50;

            int hash=MakeHash(buf);

            if(num==mode->Num) { fg=clrBlack; bg=clrCyan; hash=(hash^77) + 23; }

            if(all || hash!=hashlist[i]) {

              char *s=rindex(buf,'\t');

              if(s) {

                *s++=0;

                Write(0,i,5,buf,fg,bg);

                Write(5,i,bwc-5,s,fg,bg);

                }

              else

                Write(0,i,bwc,buf,fg,bg);

              flush=true;

              hashlist[i]=hash;

              }

            }

          listtime=time(0); lastTop=top;

          }

        }

      if(flush) Flush();

      }

    lastIndex=index; lastTotal=total;

    delete lastMode; lastMode=mode;

    }

}

void cMP3Control::DisplayInfo(const char *s)

{

  if(s) Write(CTAB,-2,bwc-CTAB,s);

  else Fill(CTAB,-2,bwc-CTAB,1,clrGray50);

}

void cMP3Control::JumpDisplay(void)

{

  char buf[64];

  const char *j=trVDR("Jump: "), u=jumpsecs?'s':'m';

  if(!jumpmm) sprintf(buf,"%s- %c",  j,u);

  else        sprintf(buf,"%s%d- %c",j,jumpmm,u);

  if(MP3Setup.ReplayDisplay) {

    disp->SetJump(buf);

    }

  else {

    DisplayInfo(buf);

    }

}

void cMP3Control::JumpProcess(eKeys Key)

{

 int n=Key-k0, d=jumpsecs?1:60;

  switch (Key) {

    case k0 ... k9:

      if(jumpmm*10+n <= lastTotal/d) jumpmm=jumpmm*10+n;

      JumpDisplay();

      break;

    case kBlue:

      jumpsecs=!jumpsecs;

      JumpDisplay();

      break;

    case kPlay:

    case kUp:

      jumpmm-=lastIndex/d;

      // fall through

    case kFastRew:

    case kFastFwd:

    case kLeft:

    case kRight:

      player->SkipSeconds(jumpmm*d * ((Key==kLeft || Key==kFastRew) ? -1:1));

      // fall through

    default:

      jumpactive=false;

      break;

    }

  if(!jumpactive) {

    if(jumphide) Hide();

    else if(MP3Setup.ReplayDisplay) disp->SetJump(0);

    }

}

void cMP3Control::Jump(void)

{

  jumpmm=0; jumphide=jumpsecs=false;

  if(!visible) {

    ShowTimed(); if(!visible) return;

    jumphide=true;

    }

  JumpDisplay();

  jumpactive=true; fliptime=0; flip=-1;

}

eOSState cMP3Control::ProcessKey(eKeys Key)

{

  if(!player->Active()) return osEnd;

  if(timeoutShow && time(0)>timeoutShow) Hide();

  ShowProgress();

  ShowStatus(Key==kNone && !Skins.IsOpen());

  if(jumpactive && Key!=kNone) { JumpProcess(Key); return osContinue; }

  switch(Key) {

    case kUp:

    case kUp|k_Repeat:

    case kNext:

    case kNext|k_Repeat:    

      mgr->Next(); player->Play();

      break;

    case kDown:

    case kDown|k_Repeat:

    case kPrev:

    case kPrev|k_Repeat:

      if(!player->PrevCheck()) mgr->Prev();

      player->Play();

      break;

    case kLeft:

    case kLeft|k_Repeat:

      if(bigwin) {

        if(top>0) { top-=rows; if(top<1) top=1; }

        break;

        }

      // fall through

    case kFastRew:

    case kFastRew|k_Repeat:

      if(!player->IsStream()) player->SkipSeconds(-JUMPSIZE);

      break;

    case kRight:

    case kRight|k_Repeat:

      if(bigwin) {

        if(top>0) top+=rows;

        break;

        }

      // fall through

    case kFastFwd:

    case kFastFwd|k_Repeat:

      if(!player->IsStream()) player->SkipSeconds(JUMPSIZE);

      break;

    case kRed:

      if(!player->IsStream()) Jump();

      break;

    case kGreen:

      if(lastMode) {

        if(time(0)>greentime) {

          if(lastMode->Loop || (!lastMode->Loop && !lastMode->Shuffle)) mgr->ToggleLoop();

          if(lastMode->Shuffle) mgr->ToggleShuffle();

          }

        else {

          if(!lastMode->Loop) mgr->ToggleLoop();

          else if(!lastMode->Shuffle) mgr->ToggleShuffle();

          else mgr->ToggleLoop();

          }

        greentime=time(0)+MULTI_TIMEOUT;

        }

      break;

    case kPlay:

      player->Play();

      break;

    case kPause:

    case kYellow:

      if(!player->IsStream()) player->Pause();

      break;

    case kStop:

    case kBlue:

      Hide();

      Stop();

      return osEnd;

    case kBack:

      Hide();

      cRemote::CallPlugin(plugin_name);

      return osBack;

    case k0 ... k9:

      number=number*10+Key-k0;

      if(lastMode && number>0 && number<=lastMode->MaxNum) {

        if(!visible) ShowTimed(SELECTHIDE_TIMEOUT);

        else if(timeoutShow>0) timeoutShow=time(0)+SELECTHIDE_TIMEOUT;

        selecting=true; lastkeytime=time_ms();

        char buf[32];

        if(MP3Setup.ReplayDisplay) {

          snprintf(buf,sizeof(buf),"%s%d-/%d",trVDR("Jump: "),number,lastMode->MaxNum);

          disp->SetJump(buf);

          }

        else {

          snprintf(buf,sizeof(buf),"(%d-/%d)",number,lastMode->MaxNum);

          Write(0,-2,CTAB,buf);

          }

        Flush();

        break;

        }

      number=0; lastkeytime=0;

      // fall through

    case kNone:

      if(selecting && time_ms()-lastkeytime>SELECT_TIMEOUT) {

        if(number>0) { mgr->Goto(number); player->Play();  }

        if(lastMode) lastMode->Hash=-1;

        number=0; selecting=false;

        if(MP3Setup.ReplayDisplay && disp) disp->SetJump(0);

        }

      break;

    case kOk:

      if(time(0)>oktime || MP3Setup.ReplayDisplay) {

        visible ? Hide() : ShowTimed();

        }

      else {

        if(visible && !bigwin) { Hide(); ShowProgress(true,true); }

        else { Hide(); ShowTimed(); }

        }

      oktime=time(0)+MULTI_TIMEOUT;

      ShowStatus(true);

      break;

    default:

      return osUnknown;

    }

  return osContinue;

}

// --- cMenuID3Info ------------------------------------------------------------

class cMenuID3Info : public cOsdMenu {

private:

  cOsdItem *Item(const char *name, const char *text);

  cOsdItem *Item(const char *name, const char *format, const float num);

  void Build(cSongInfo *info, const char *name);

public:

  cMenuID3Info(cSong *song);

  cMenuID3Info(cSongInfo *si, const char *name);

  virtual eOSState ProcessKey(eKeys Key);

  };

cMenuID3Info::cMenuID3Info(cSong *song)

:cOsdMenu(tr("ID3 information"),12)

{

  Build(song->Info(),song->Name());

}

cMenuID3Info::cMenuID3Info(cSongInfo *si, const char *name)

:cOsdMenu(tr("ID3 information"),12)

{

  Build(si,name);

}

void cMenuID3Info::Build(cSongInfo *si, const char *name)

{

  if(si) {

    Item(tr("Filename"),name);

    if(si->HasInfo() && si->Total>0) {

      char *buf=0;

      asprintf(&buf,"%02d:%02d",si->Total/60,si->Total%60);

      Item(tr("Length"),buf);

      free(buf);

      Item(tr("Title"),si->Title);

      Item(tr("Artist"),si->Artist);

      Item(tr("Album"),si->Album);

      Item(tr("Year"),0,(float)si->Year);

      Item(tr("Samplerate"),"%.1f kHz",si->SampleFreq/1000.0);

      Item(tr("Bitrate"),"%.f kbit/s",si->Bitrate/1000.0);

      Item(trVDR("Channels"),0,(float)si->Channels);

      }

    Display();

    }

}

cOsdItem *cMenuID3Info::Item(const char *name, const char *format, const float num)

{

  cOsdItem *item;

  if(num>=0.0) {

    char *buf=0;

    asprintf(&buf,format?format:"%.f",num);

    item=Item(name,buf);

    free(buf);

    }

  else item=Item(name,"");

  return item;

}

cOsdItem *cMenuID3Info::Item(const char *name, const char *text)

{

  char *buf=0;

  asprintf(&buf,"%s:\t%s",name,text?text:"");

  cOsdItem *item = new cOsdItem(buf,osBack);

  item->SetSelectable(false);

  free(buf);

  Add(item); return item;

}

eOSState cMenuID3Info::ProcessKey(eKeys Key)

{

  eOSState state = cOsdMenu::ProcessKey(Key);

  if(state==osUnknown) {

     switch(Key) {

       case kRed:

       case kGreen:

       case kYellow:

       case kBlue:   return osContinue;

       case kMenu:   return osEnd;

       default: break;

       }

     }

  return state;

}

// --- cMenuInstantBrowse -------------------------------------------------------

class cMenuInstantBrowse : public cMenuBrowse {

private:

  const char *selecttext, *alltext;

  virtual void SetButtons(void);

  virtual eOSState ID3Info(void);

public:

  cMenuInstantBrowse(cFileSource *Source, const char *Selecttext, const char *Alltext);

  virtual eOSState ProcessKey(eKeys Key);

  };

cMenuInstantBrowse::cMenuInstantBrowse(cFileSource *Source, const char *Selecttext, const char *Alltext)

:cMenuBrowse(Source,true,true,tr("Directory browser"),excl_br)

{

  selecttext=Selecttext; alltext=Alltext;

  SetButtons();

}

void cMenuInstantBrowse::SetButtons(void)

{

  SetHelp(selecttext, currentdir?tr("Parent"):0, currentdir?0:alltext, tr("ID3 info"));

  Display();

}

eOSState cMenuInstantBrowse::ID3Info(void)

{

  cFileObj *item=CurrentItem();

  if(item && item->Type()==otFile) {

    cSong *song=new cSong(item);

    cSongInfo *si;

    if(song && (si=song->Info())) {

      AddSubMenu(new cMenuID3Info(si,item->Path()));

      }

    delete song;

    }

  return osContinue;

}

eOSState cMenuInstantBrowse::ProcessKey(eKeys Key)

{

  eOSState state=cOsdMenu::ProcessKey(Key);

  if(state==osUnknown) {

     switch (Key) {

       case kYellow: lastselect=new cFileObj(source,0,0,otBase);

                     return osBack;

       default: break;

       }

     }

  if(state==osUnknown) state=cMenuBrowse::ProcessStdKey(Key,state);

  return state;

}

// --- cMenuPlayListItem -------------------------------------------------------

class cMenuPlayListItem : public cOsdItem {

  private:

  bool showID3;

  cSong *song;

public:

  cMenuPlayListItem(cSong *Song, bool showid3);

  cSong *Song(void) { return song; }

  virtual void Set(void);

  void Set(bool showid3);

  };

cMenuPlayListItem::cMenuPlayListItem(cSong *Song, bool showid3)

{

  song=Song;

  Set(showid3);

}

void cMenuPlayListItem::Set(bool showid3)

{

  showID3=showid3;

  Set();

}

void cMenuPlayListItem::Set(void)

{

  char *buffer=0;

  cSongInfo *si=song->Info(false);

  if(showID3 && !si) si=song->Info();

  if(showID3 && si && si->Title)

    asprintf(&buffer, "%d.\t%s",song->Index()+1,TitleArtist(si->Title,si->Artist));

  else

    asprintf(&buffer, "%d.\t<%s>",song->Index()+1,song->Name());

  SetText(buffer,false);

}

// --- cMenuPlayList ------------------------------------------------------

class cMenuPlayList : public cOsdMenu {

private:

  cPlayList *playlist;

  bool browsing, showid3;

  void Buttons(void);

  void Refresh(bool all = false);

  void Add(void);

  virtual void Move(int From, int To);

  eOSState Remove(void);

  eOSState ShowID3(void);

  eOSState ID3Info(void);

public:

  cMenuPlayList(cPlayList *Playlist);

  virtual eOSState ProcessKey(eKeys Key);

  };

cMenuPlayList::cMenuPlayList(cPlayList *Playlist)

:cOsdMenu(tr("Playlist editor"),4)

{

  browsing=showid3=false;

  playlist=Playlist;

  if(MP3Setup.EditorMode) showid3=true;

  cSong *mp3 = playlist->First();

  while(mp3) {

    cOsdMenu::Add(new cMenuPlayListItem(mp3,showid3));

    mp3 = playlist->cList<cSong>::Next(mp3);

    }

  Buttons(); Display();