mpegsound.h

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

    };
    void putbyte(int c)
    {
	buffer[point & (WINDOWSIZE - 1)] = c;
	point++;
    };
    void wrap(void);
    void rewind(int bits)
    {
	bitindex -= bits;
    };
    void forward(int bits)
    {
	bitindex += bits;
    };
    int getbit(void);
    int getbits9(int bits);
    int getbits(int bits);

  private:
    int point, bitindex;
    char buffer[2 * WINDOWSIZE];
};



// Class for converting mpeg format to raw format
class Mpegtoraw
{

  /*****************************/
    /* Constant tables for layer */
  /*****************************/
  private:
    static const int bitrate[2][3][15], frequencies[2][3];
    static const REAL scalefactorstable[64];
    static const HUFFMANCODETABLE ht[HTN];
    static const REAL filter[512];
    static const REAL hcos_64[16], hcos_32[8], hcos_16[4], hcos_8[2], hcos_4;

  /*************************/
    /* MPEG header variables */
  /*************************/
  private:
    int layer, protection, bitrateindex, padding, extendedmode;
    enum _mpegversion
    { mpeg1, mpeg2 }
    version;
    enum _mode
    { fullstereo, joint, dual, single }
    mode;
    enum _frequency
    { frequency44100, frequency48000, frequency32000 }
    frequency;

  /*******************************************/
    /* Functions getting MPEG header variables */
  /*******************************************/
  public:
    // General
    int getversion(void) const
    {
	return version;
    };
    int getlayer(void) const
    {
	return layer;
    };
    bool getcrccheck(void) const
    {
	return (!protection);
    };
    // Stereo or not
    int getmode(void) const
    {
	return mode;
    };
    bool isstereo(void) const
    {
	return (getmode() != single);
    };
    // Frequency and bitrate
    int getfrequency(void) const
    {
	return frequencies[version][frequency];
    };
    int getbitrate(void) const
    {
	return bitrate[version][layer - 1][bitrateindex];
    };

  /***************************************/
    /* Interface for setting music quality */
  /***************************************/
  private:
      bool forcetomonoflag;
    int downfrequency;

  public:
    void setforcetomono(bool flag);
    void setdownfrequency(int value);

  /******************************************/
    /* Functions getting other MPEG variables */
  /******************************************/
  public:
      bool getforcetomono(void);
    int getdownfrequency(void);
    int getpcmperframe(void);

  /******************************/
    /* Frame management variables */
  /******************************/
  private:
    int currentframe, totalframe;
    int decodeframe;
    int *frameoffsets;

  /******************************/
    /* Frame management functions */
  /******************************/
  public:
    int getcurrentframe(void) const
    {
	return currentframe;
    };
    int gettotalframe(void) const
    {
	return totalframe;
    };
    void setframe(int framenumber);

  /***************************************/
    /* Variables made by MPEG-Audio header */
  /***************************************/
  private:
    int tableindex, channelbitrate;
    int stereobound, subbandnumber, inputstereo, outputstereo;
    REAL scalefactor;
    int framesize;

  /********************/
    /* Song information */
  /********************/
  private:
    struct
    {
	char name[30 + 1];
	char artist[30 + 1];
	char album[30 + 1];
	char year[4 + 1];
	char comment[30 + 1];
	//    char type         ;
    }
    songinfo;

    /* Song information functions */
  public:
    const char *getname(void) const
    {
	return (const char *) songinfo.name;
    };
    const char *getartist(void) const
    {
	return (const char *) songinfo.artist;
    };
    const char *getalbum(void) const
    {
	return (const char *) songinfo.album;
    };
    const char *getyear(void) const
    {
	return (const char *) songinfo.year;
    };
    const char *getcomment(void) const
    {
	return (const char *) songinfo.comment;
    };

  /*******************/
    /* Mpegtoraw class */
  /*******************/
  public:
      Mpegtoraw(Soundinputstream * loader, Soundplayer * player);
     ~Mpegtoraw();
    void initialize(char *filename);
    bool run(int frames);
    int geterrorcode(void)
    {
	return __errorcode;
    };
    void clearbuffer(void);

  private:
    int __errorcode;
    bool seterrorcode(int errorno)
    {
	__errorcode = errorno;
	return false;
    };

  /*****************************/
    /* Loading MPEG-Audio stream */
  /*****************************/
  private:
    Soundinputstream * loader;	// Interface
    union
    {
	unsigned char store[4];
	unsigned int current;
    }
    u;
    char buffer[4096];
    int bitindex;
    bool fillbuffer(int size)
    {
	bitindex = 0;
	return loader->_readbuffer(buffer, size);
    };
    void sync(void)
    {
	bitindex = (bitindex + 7) & 0xFFFFFFF8;
    };
    bool issync(void)
    {
	return (bitindex & 7);
    };
    int getbyte(void);
    int getbits(int bits);
    int getbits9(int bits);
    int getbits8(void);
    int getbit(void);

  /********************/
    /* Global variables */
  /********************/
  private:
    int lastfrequency, laststereo;

    // for Layer3
    int layer3slots, layer3framestart, layer3part2start;
    REAL prevblck[2][2][SBLIMIT][SSLIMIT];
    int currentprevblock;
    layer3sideinfo sideinfo;
    layer3scalefactor scalefactors[2];

    Mpegbitwindow bitwindow;
    int wgetbit(void);
    int wgetbits9(int bits);
    int wgetbits(int bits);


  /*************************************/
    /* Decoding functions for each layer */
  /*************************************/
  private:
    bool loadheader(void);

    //
    // Subbandsynthesis
    //
    REAL calcbufferL[2][CALCBUFFERSIZE], calcbufferR[2][CALCBUFFERSIZE];
    int currentcalcbuffer, calcbufferoffset;

    void computebuffer(REAL * fraction, REAL buffer[2][CALCBUFFERSIZE]);
    void generatesingle(void);
    void generate(void);
    void subbandsynthesis(REAL * fractionL, REAL * fractionR);

    void computebuffer_2(REAL * fraction, REAL buffer[2][CALCBUFFERSIZE]);
    void generatesingle_2(void);
    void generate_2(void);
    void subbandsynthesis_2(REAL * fractionL, REAL * fractionR);

    // Extractor
    void extractlayer1(void);	// MPEG-1
    void extractlayer2(void);
    void extractlayer3(void);
    void extractlayer3_2(void);	// MPEG-2


    // Functions for layer 3
    void layer3initialize(void);
    bool layer3getsideinfo(void);
    bool layer3getsideinfo_2(void);
    void layer3getscalefactors(int ch, int gr);
    void layer3getscalefactors_2(int ch);
    void layer3huffmandecode(int ch, int gr, int out[SBLIMIT][SSLIMIT]);
    REAL layer3twopow2(int scale, int preflag, int pretab_offset, int l);
    REAL layer3twopow2_1(int a, int b, int c);
    void layer3dequantizesample(int ch, int gr, int in[SBLIMIT][SSLIMIT],
				REAL out[SBLIMIT][SSLIMIT]);
    void layer3fixtostereo(int gr, REAL in[2][SBLIMIT][SSLIMIT]);
    void layer3reorderandantialias(int ch, int gr, REAL in[SBLIMIT][SSLIMIT],
				   REAL out[SBLIMIT][SSLIMIT]);

    void layer3hybrid(int ch, int gr, REAL in[SBLIMIT][SSLIMIT],
		      REAL out[SSLIMIT][SBLIMIT]);

    void huffmandecoder_1(const HUFFMANCODETABLE * h, int *x, int *y);
    void huffmandecoder_2(const HUFFMANCODETABLE * h, int *x, int *y, int *v,
			  int *w);

  /********************/
    /* Playing raw data */
  /********************/
  private:
    Soundplayer * player;	// General playing interface
    int rawdataoffset;
    short int rawdata[RAWDATASIZE];

    void clearrawdata(void)
    {
	rawdataoffset = 0;
    };
    void putraw(short int pcm)
    {
	rawdata[rawdataoffset++] = pcm;
    };
    void flushrawdata(void);

  public:
    void *GetRawData()
    {
	return (void *) rawdata;
    };

  /***************************/
    /* Interface for threading */
  /***************************/
#ifdef PTHREADEDMPEG
  private:
    struct
    {
	short int *buffer;
	int framenumber, frametail;
	int head, tail;
	int *sizes;
    }
    threadqueue;

    struct
    {
	bool thread;
	bool quit, done;
	bool pause;
	bool criticallock, criticalflag;
    }
    threadflags;

    pthread_t thread;

  public:
    void threadedplayer(void);
    bool makethreadedplayer(int framenumbers);
    void freethreadedplayer(void);

    void stopthreadedplayer(void);
    void pausethreadedplayer(void);
    void unpausethreadedplayer(void);

    bool existthread(void);
    int getframesaved(void);
#endif
};



/***********************/
/* File player classes */
/***********************/
// Superclass for playing file
class Fileplayer
{
  public:
    Fileplayer();
    virtual ~ Fileplayer();

    int geterrorcode(void)
    {
	return __errorcode;
    };

    virtual bool openfile(char *filename, char *device) = 0;
    virtual void setforcetomono(bool flag) = 0;
    virtual bool playing(int verbose) = 0;

  protected:
    bool seterrorcode(int errorno)
    {
	__errorcode = errorno;
	return false;
    };
    Soundplayer *player;

  private:
    int __errorcode;
};


// Class for playing wave file
class Wavefileplayer:public Fileplayer
{
  public:
    Wavefileplayer();
    ~Wavefileplayer();

    bool openfile(char *filename, char *device);
    void setforcetomono(bool flag);
    bool playing(int verbose);

  private:
      Soundinputstream * loader;
    Wavetoraw *server;
};


// Class for playing MPEG file
class Mpegfileplayer:public Fileplayer
{
  public:
    Mpegfileplayer();
    ~Mpegfileplayer();

    bool openfile(char *filename, char *device);
    void setforcetomono(bool flag);
    void setdownfrequency(int value);
    bool playing(int verbose);
#if PTHREADEDMPEG
    bool playingwiththread(int verbose, int framenumbers);
#endif

  private:
      Soundinputstream * loader;
    Mpegtoraw *server;

    void showverbose(int verbose);
};

typedef struct
{
    char songname[1024];
    char artist[1024];
    char album[1024];
    char year[1024];
    char comment[1024];
}
ID3;

void parseID3(Soundinputstream *, ID3 *);

#endif