/*

  * 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 <stdio.h>

 #include "common.h"

 #include "data-mp3.h"

 #include "decoder-mp3.h"

 #include "stream.h"

 #define MAX_FRAME_ERR 10

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

 int MadStream(struct mad_stream *stream, cStream *str)

 {

   unsigned char *data;

   unsigned long len;

   if(str->Stream(data,len,stream->next_frame)) {

     if(len>0) mad_stream_buffer(stream, data, len);

     return len;

     }

   return -1;

 }

 // --- cMP3Decoder -------------------------------------------------------------

 cMP3Decoder::cMP3Decoder(const char *Filename, bool preinit)

 :cDecoder(Filename)

 {

   str=0; scan=0; isStream=false;

   if(preinit) {

     //d(printf("mp3: preinit\n"))

     str=new cStream(filename);

     scan=new cScanID3(str,&urgentLock);

     }

   fi=0; stream=0; frame=0; synth=0;

 }

 cMP3Decoder::~cMP3Decoder()

 {

   Clean();

   delete scan;

   delete str;

 }

 bool cMP3Decoder::Valid(void)

 {

   bool res=false;

   if(TryLock()) {

     struct mad_stream stream;

     struct mad_header header;

     mad_stream_init(&stream);

     mad_stream_options(&stream,MAD_OPTION_IGNORECRC);

     mad_header_init(&header);

     if(str->Open() && str->Seek()) {

       int count=10;

       do {

         if(mad_header_decode(&header,&stream)<0) {

           if(stream.error==MAD_ERROR_BUFLEN || stream.error==MAD_ERROR_BUFPTR) {

             if(MadStream(&stream,str)<=0) break;

             }

           else if(!MAD_RECOVERABLE(stream.error)) break;

           count++;

           }

         } while(--count);

       if(!count) res=true;

       }

     mad_header_finish(&header);

     mad_stream_finish(&stream);

     str->Close();

     Unlock();

     }

   return res;

 }

 cFileInfo *cMP3Decoder::FileInfo(void)

 {

   cFileInfo *fi=0;

   if(str->HasInfo()) fi=str;

   else if(TryLock()){

     if(str->Open()) { fi=str; str->Close(); }

     Unlock();

     }

   return fi;

 }

 cSongInfo *cMP3Decoder::SongInfo(bool get)

 {

   cSongInfo *si=0;

   if(scan->HasInfo()) si=scan;

   else if(get && TryLock()) {

     if(scan->DoScan()) si=scan;

     Unlock();

     }

   return si;

 }

 cPlayInfo *cMP3Decoder::PlayInfo(void)

 {

   if(playing) {

     pi.Index=mad_timer_count(playtime,MAD_UNITS_SECONDS);

     pi.Total=scan->Total;

     return π

     }

   return 0;

 }

 void cMP3Decoder::Init(void)

 {

   Clean();

   stream=new struct mad_stream;

   mad_stream_init(stream);

   mad_stream_options(stream,MAD_OPTION_IGNORECRC);

   frame=new struct mad_frame;

   mad_frame_init(frame);

   synth=new struct mad_synth;

   mad_synth_init(synth);

   playtime=mad_timer_zero; skiptime=mad_timer_zero;

   framenum=framemax=0; mute=errcount=0;

 }

 void cMP3Decoder::Clean(void)

 {

   playing=false;

   if(synth) { mad_synth_finish(synth); delete synth; synth=0; }

   if(frame) { mad_frame_finish(frame); delete frame; frame=0; }

   if(stream) { mad_stream_finish(stream); delete stream; stream=0; }

   delete[] fi; fi=0;

 }

 bool cMP3Decoder::Start(void)

 {

   Lock(true);

   Init(); playing=true;

   if(str->Open() && scan->DoScan(true)) {

     if(!isStream) {

       str->Seek();

       framemax=scan->Frames+20;

       fi=new struct FrameInfo[framemax];

       if(!fi) esyslog("ERROR: no memory for frame index, rewinding disabled");

       }

     Unlock();

     return true;

     }

   str->Close();

   Clean();

   Unlock();

   return false;

 }

 bool cMP3Decoder::Stop(void)

 {

   Lock();

   if(playing) {

     str->Close();

     Clean();

     }

   Unlock();

   return true;

 }

 struct Decode *cMP3Decoder::Done(eDecodeStatus status)

 {

   ds.status=status;

   ds.index=mad_timer_count(playtime,MAD_UNITS_MILLISECONDS);

   ds.pcm=&synth->pcm;

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

   return &ds;

 }

 eDecodeStatus cMP3Decoder::DecodeError(bool hdr)

 {

   if(stream->error==MAD_ERROR_BUFLEN || stream->error==MAD_ERROR_BUFPTR) {

     int s=MadStream(stream,str);

     if(s<0) return dsError;

     if(s==0) return dsEof;

     }

   else if(!MAD_RECOVERABLE(stream->error)) {

     d(printf("mad: decode %sfailed, frame=%d: %s\n",hdr?"hdr ":"",framenum,mad_stream_errorstr(stream)))

     return dsError;

     }

   else { 

     if(stream->error==MAD_ERROR_LOSTSYNC) { // check for ID3 tags

 #ifdef DEBUG

       char buf[10];

       int buf2[3];

       memcpy(buf,stream->this_frame,8); buf[8]=0;

       memcpy(buf2,stream->this_frame,8);

       printf("mad: lost sync %08x %08x %s\n",buf2[0],buf2[1],buf);

 #endif

       id3_length_t count=stream->bufend-stream->this_frame;

       id3_length_t tagsize=id3_tag_query(stream->this_frame,count);

       if(tagsize>0) {

         d(printf("mad: skipping over ID3 tag\n"))

         if(count>tagsize) count=tagsize;

         mad_stream_skip(stream,count);

         while(count<tagsize) {

           unsigned char *sdata;

           unsigned long slen;

           if(!str->Stream(sdata,slen)) return dsError;

           if(slen<=0) return dsEof;

           unsigned long len=min(tagsize-count,slen);

           count+=len;

           sdata+=len; slen-=len;

           if(slen>0) mad_stream_buffer(stream,sdata,slen);

           }

         return dsOK;

         }

       }

     errcount+=hdr?1:100;

     d(printf("mad: decode %serror, frame=%d count=%d: %s\n",hdr?"hdr ":"",framenum,errcount,mad_stream_errorstr(stream)))

     }

   return dsOK;

 }

 struct Decode *cMP3Decoder::Decode(void)

 {

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

   eDecodeStatus r;

   while(playing) {

     if(errcount>=MAX_FRAME_ERR*100) {

       esyslog("ERROR: excessive decoding errors, aborting file %s",filename);

       return Done(dsError);

       }

     if(mad_header_decode(&frame->header,stream)<0) {

       if((r=DecodeError(true))) return Done(r);

       }

     else {

       if(!isStream) {

 #ifdef DEBUG

         if(framenum>=framemax) printf("mp3: framenum >= framemax!!!!\n");

 #endif

         if(fi && framenum<framemax) {

           fi[framenum].Pos=str->BufferPos() + (stream->this_frame-stream->buffer);

           fi[framenum].Time=playtime;

           }

         }

       mad_timer_add(&playtime,frame->header.duration); framenum++;

       if(mad_timer_compare(playtime,skiptime)>=0) skiptime=mad_timer_zero;

       else return Done(dsSkip);  // skipping, decode next header

       if(mad_frame_decode(frame,stream)<0) {

         if((r=DecodeError(false))) return Done(r);

         }

       else {

         errcount=0;

         scan->InfoHook(&frame->header);

         mad_synth_frame(synth,frame);

         if(mute) { mute--; return Done(dsSkip); }

         return Done(dsPlay);

         }

       }

     }

   return Done(dsError);

 }

 void cMP3Decoder::MakeSkipTime(mad_timer_t *skiptime, mad_timer_t playtime, int secs, float bsecs)

 {

   mad_timer_t time;

   *skiptime=playtime;

   mad_timer_set(&time,abs(secs),0,0);

   if(secs<0) mad_timer_negate(&time);

   mad_timer_add(skiptime,time);

   int full=(int)bsecs; bsecs-=(float)full;

   mad_timer_set(&time,full,(int)(bsecs*1000.0),1000);

   mad_timer_negate(&time);

   mad_timer_add(skiptime,time);

   d(printf("mp3: skip: playtime=%ld secs=%d full=%d bsecs=%f skiptime=%ld\n",

            mad_timer_count(playtime,MAD_UNITS_MILLISECONDS),secs,full,bsecs,mad_timer_count(*skiptime,MAD_UNITS_MILLISECONDS)))

 }

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

 {

   Lock();

   bool res=false;

   if(playing && !isStream) {

     if(!mad_timer_compare(skiptime,mad_timer_zero)) { // allow only one skip at any time

       mad_timer_t time;

       MakeSkipTime(&time,playtime,Seconds,bsecs);

       if(mad_timer_compare(playtime,time)<=0) { // forward skip

 #ifdef DEBUG

         int i=mad_timer_count(time,MAD_UNITS_SECONDS);

         printf("mp3: forward skipping to %02d:%02d\n",i/60,i%60);

 #endif

         skiptime=time; mute=1;

         res=true;

         }

       else {                                    // backward skip

         if(fi) {

 #ifdef DEBUG

           int i=mad_timer_count(time,MAD_UNITS_SECONDS);

           printf("mp3: rewinding to %02d:%02d\n",i/60,i%60);

 #endif

           while(framenum && mad_timer_compare(time,fi[--framenum].Time)<0) ;

           mute=2; if(framenum>=2) framenum-=2;

           playtime=fi[framenum].Time;

           str->Seek(fi[framenum].Pos);

           mad_stream_finish(stream); // reset stream buffer

           mad_stream_init(stream);

 #ifdef DEBUG

           i=mad_timer_count(playtime,MAD_UNITS_MILLISECONDS);

           printf("mp3: new playtime=%d framenum=%d filepos=%lld\n",i,framenum,fi[framenum].Pos);

 #endif

           res=true;

           }

         }

       }

     }

   Unlock();

   return res;

 }

 // --- cScanID3 ----------------------------------------------------------------

 // This function was adapted from mad_timer, from the 

 // libmad distribution

 #define MIN_SCAN_FRAMES 200 // min. number of frames to scan

 cScanID3::cScanID3(cStream *Str, bool *Urgent)

 {

   str=Str;

   urgent=Urgent;

 }

 bool cScanID3::Abort(bool result)

 {

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

   return result;

 }

 bool cScanID3::DoScan(bool KeepOpen)

 {

   mad_timer_t duration=mad_timer_zero;

   unsigned int bitrate=0, minrate=~0, maxrate=0;

   int xframes=0;

   unsigned int id3_vers=0;

   bool is_vbr=false, has_id3=false;

   keepOpen=KeepOpen;

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

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

   // check the infocache

   cCacheData *dat=InfoCache.Search(str);

   if(dat) {

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

     ConvertToSys();

     if(!DecoderID) {

       DecoderID=DEC_MP3;

       InfoCache.Cache(this,str);

       }

     return Abort(true);

     }

   Clear();

   // do a initial check for a ID3v1 tag at the end of the file

   // to speed up the following scan

   if(str->Filesize>=128 && str->Seek(str->Filesize-128)) {

     unsigned char *data;

     unsigned long len;

     if(str->Stream(data,len)) {

       struct id3_tag *tag=id3_tag_parse(data,len);

       if(tag) {

         d(printf("id3-scan: initialy found ID3 V1 tag at EOF\n"))

         ParseID3(tag);

         has_id3=true; id3_vers=tag->version;

         id3_tag_delete(tag);

         }

       }

     }

   if(!str->Seek()) return Abort(false);

   // There are three ways of calculating the length of an mp3:

   // 1) Constant bitrate: One frame can provide the information

   //    needed: # of frames and duration. Just see how long it

   //    is and do the division.

   // 2) Variable bitrate: Xing tag. It provides the number of 

   //    frames. Each frame has the same number of samples, so

   //    just use that.

   // 3) All: Count up the frames and duration of each frames

   //    by decoding each one. We do this if we've no other

   //    choice, i.e. if it's a VBR file with no Xing tag.

   struct mad_stream stream;

   struct mad_header header;

   mad_stream_init(&stream);

   mad_stream_options(&stream,MAD_OPTION_IGNORECRC);

   mad_header_init(&header);

   bool res=true;

   int errcount=0;

   while(1) {

     if(*urgent) {

       d(printf("id3-scan: urgent request, aborting!\n"))

       res=false; break; // abort scan if there is an urgent request for the decoder lock

       }

     if(mad_header_decode(&header,&stream)<0) {

       if(stream.error==MAD_ERROR_BUFLEN || stream.error==MAD_ERROR_BUFPTR) {

         int s=MadStream(&stream,str);

         if(s>0) continue;

         if(s<0) res=false;

         break;

         }

       else if(stream.error==MAD_ERROR_LOSTSYNC) { // check for ID3 tags

 #ifdef DEBUG

         char buf[10];

         int buf2[3];

         memcpy(buf,stream.this_frame,8); buf[8]=0;

         memcpy(buf2,stream.this_frame,8);

         printf("id3-scan: lost sync %08x %08x %s\n",buf2[0],buf2[1],buf);

 #endif

         id3_length_t tagsize=id3_tag_query(stream.this_frame,stream.bufend-stream.this_frame);

         if(tagsize>0) {

 	  struct id3_tag *tag=GetID3(&stream,tagsize);

 	  if(tag) {

             unsigned int vers=id3_tag_version(tag);

             d(printf("id3-scan: found ID3 %s tag (%d.%d)\n",vers==0x100?"V1":"V2",ID3_TAG_VERSION_MAJOR(vers),ID3_TAG_VERSION_MINOR(vers)))

             if(!has_id3 || vers>id3_vers) {

               ParseID3(tag);

               has_id3=true; id3_vers=vers;

               }

 	    id3_tag_delete(tag);

 	    }

           }

         continue;

         }

       else {

         d(printf("id3-scan: decode header error (frame %d): %s\n",Frames,mad_stream_errorstr(&stream)))

         errcount++;

         if(errcount<MAX_FRAME_ERR*100 && MAD_RECOVERABLE(stream.error)) continue;

         res=false; break;

         }

       }

     errcount=0;

     if(header.bitrate>maxrate) maxrate=header.bitrate;

     if(header.bitrate<minrate) minrate=header.bitrate;

     // Limit xing testing to the first frame header

     if(!Frames) {

       if((xframes=ParseXing(&stream.anc_ptr, stream.anc_bitlen))>=0) {

         is_vbr=true;

         }

       }                

     // Test the first n frames to see if this is a VBR file

     if(!is_vbr && Frames<MIN_SCAN_FRAMES) {

       if(bitrate && header.bitrate!=bitrate) is_vbr=true;

       else bitrate=header.bitrate;

       }

     // We have to assume it's not a VBR file if it hasn't already been

     // marked as one and we've checked n frames for different bitrates

     else if(!is_vbr && has_id3)

       {

       break;

       }

     Frames++;

     mad_timer_add(&duration,header.duration);

     }

   mad_header_finish(&header);

   mad_stream_finish(&stream);

   if(res) {

     d(printf("mad: scanned %d frames%s\n",Frames,Frames?"":"(is this really a mp3?)"))

     if(Frames) {

       SampleFreq=header.samplerate;

       Channels=MAD_NCHANNELS(&header);

       ChMode=header.mode;

       DecoderID=DEC_MP3;

       InfoDone();

       if(!is_vbr) {

         d(printf("mad: constant birate\n"))

         double time = (str->Filesize * 8.0) / (header.bitrate);  // time in seconds

         long nsamples = 32 * MAD_NSBSAMPLES(&header);   // samples per frame

         Frames = (long)(time * header.samplerate / nsamples);

         Total  = (long)time;

         Bitrate= (int)bitrate;

         }

       else if(xframes>0) {

         d(printf("mad: vbr, but has Xing frame\n"))

         mad_timer_multiply(&header.duration, xframes);

         Frames = xframes;

         Total  = mad_timer_count(header.duration,MAD_UNITS_SECONDS);

         }

       else {

         // the durations have been added up, and the number of frames counted. We do nothing here.

         d(printf("mad: vbr detected\n"))

         Total      = mad_timer_count(duration,MAD_UNITS_SECONDS);

         Bitrate    = (int)minrate;

         MaxBitrate = (int)maxrate;

         }

       if(!has_id3 || !Title) FakeTitle(str->Filename,".mp3");

       InfoCache.Cache(this,str);

       ConvertToSys();

       }

     }

   return Abort(res);

 }

 // This function was adapted from player.c, from the 

 // libmad distribution

 struct id3_tag *cScanID3::GetID3(struct mad_stream *stream, id3_length_t tagsize) const

 {

   struct id3_tag *tag=0;

   const id3_byte_t *data;

   id3_byte_t *allocated=0;

   id3_length_t count=stream->bufend-stream->this_frame;

   if(count>=tagsize) {

     data=stream->this_frame;

     mad_stream_skip(stream,tagsize);

     }

   else {

     if(!(allocated=(id3_byte_t *)malloc(tagsize))) {

       esyslog("ERROR: not enough memory for id3 tag buffer");

       return 0;

       }

     memcpy(allocated,stream->this_frame,count);

     mad_stream_skip(stream,count);

     while(count<tagsize) {

       unsigned char *sdata;

       unsigned long len, slen;

       if(!str->Stream(sdata,slen) || !slen) {

          d(printf("mad: error or eof on ID3 tag parse\n"))

          free(allocated);

          return 0;

          }

       len=tagsize-count; if(len>slen) len=slen;

       memcpy(allocated+count,sdata,len);

       count+=len;

       sdata+=len; slen-=len;

       if(slen) mad_stream_buffer(stream,sdata,slen);

       }

     data=allocated;

     }

   tag=id3_tag_parse(data,tagsize);

   if(allocated) free(allocated);

   return tag;

 }

 void cScanID3::ParseID3(const struct id3_tag *tag)

 {

   d(printf("id3-scan: parsing ID3 tag\n"))

   ParseStr(tag,ID3_FRAME_TITLE,Title);

   ParseStr(tag,ID3_FRAME_ARTIST,Artist);

   ParseStr(tag,ID3_FRAME_ALBUM,Album);

   char *data=0;

   ParseStr(tag,ID3_FRAME_YEAR,data);

   if(data) Year=atol(data);

   free(data);

   //ParseStr(tag,ID3_FRAME_TRACK,Track);

   //ParseStr(tag,ID3_FRAME_GENRE,Genre);

 }

 /*

 void cScanID3::ParsePic(const struct id3_tag *tag, const char *id, char * &name)

 {

   const struct id3_frame *frame=id3_tag_findframe(tag,id,0);

   if(frame) {

     id3_length_t len;

     const id3_byte_t *data=id3_field_getbinarydata(&frame->fields[1],&len);

     if(data && len>0) {

       static const char salt[] = { "$1$id3__pic$" };

       }

     }

 }

 */

 // This function was adapted from player.c, from the 

 // libmad distribution 

 void cScanID3::ParseStr(const struct id3_tag *tag, const char *id, char * &data)

 {

   const struct id3_frame *frame=id3_tag_findframe(tag,id,0);

   if(!frame) return;

   free(data); data=0;

   const union id3_field *field=&frame->fields[1];

   if(id3_field_getnstrings(field)>0) {

     const id3_ucs4_t *ucs4=id3_field_getstrings(field,0);

     if(!ucs4) return;

     if(!strcmp(id,ID3_FRAME_GENRE)) ucs4=id3_genre_name(ucs4);

     data=(char *)id3_ucs4_utf8duplicate(ucs4);

     }

 }

 // XING parsing was adapted from the MAD winamp input plugin,

 // from the libmad distribution

 #define XING_MAGIC (('X'<<24) | ('i'<<16) | ('n'<<8) | 'g')

 #define XING_FRAMES 0x0001

 // #define XING_BYTES  0x0002

 // #define XING_TOC    0x0004

 // #define XING_SCALE  0x0008

 int cScanID3::ParseXing(struct mad_bitptr *ptr, unsigned int bitlen) const

 {

   if(bitlen>=64 && mad_bit_read(ptr,32)==XING_MAGIC) {

     int flags=mad_bit_read(ptr, 32);

     bitlen-=64;

     return (bitlen>=32 && (flags & XING_FRAMES)) ? mad_bit_read(ptr,32) : 0;

     }

   return -1;

 }