//====================================================================
// libbank.h
//
// Copyright 1993, Silicon Graphics, Inc.
// All Rights Reserved.
//
// This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
// the contents of this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior written
// permission of Silicon Graphics, Inc.
//
// RESTRICTED RIGHTS LEGEND:
// Use, duplication or disclosure by the Government is subject to restrictions
// as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
// and Computer Software clause at DFARS 252.227-7013, and/or in similar or
// successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
// rights reserved under the Copyright Laws of the United States.
//====================================================================

#pragma once

#include <libaudio.h>
#include <stdio.h>
#include <audiotools.h>

//----------------------------------------------------------------------
// misc stuff
//----------------------------------------------------------------------

#ifndef MIN
#define	MIN(a,b) (((a)<(b))?(a):(b))
#endif

#ifndef MAX
#define	MAX(a,b) (((a)>(b))?(a):(b))
#endif

#define ICBANK          AL_BANK_CLASS
#define ICINST          AL_INST_CLASS
#define ICSOUND         AL_SOUND_CLASS
#define ICKEYMAP        AL_KEYMAP_CLASS
#define ICWAVE          AL_WAVETBL_CLASS
#define ICLOOP          AL_LOOP_CLASS
#define ICBANKFILE      AL_BNKFILE_CLASS
#define ICENVELOPE      AL_ENVLP_CLASS
#define ICBOOK          AL_BOOK_CLASS
#define ICSOUNDFILE     AL_SNDFILE_CLASS

char *icStrip(char *dest, char *src);


//----------------------------------------------------------------------
// error stuff
//----------------------------------------------------------------------
typedef enum {
    IC_INTERNAL_ERR = 0,
    IC_MISC_ERR,
    IC_PARAMETER_ERR,
    IC_TYPE_ERR,
    IC_FILE_ERR,
    IC_SOURCE_FMT_ERR,    
    IC_MAX_ERR
} ICError;

typedef void (*ICErrFunc)(ICError errtype, char *msg);
extern ICErrFunc icErrFunc;

char *icErrStr(char *msg, char *msg1, char *msg2);

#define FailIf(condition, error)        \
            if (condition) {            \
                (*icErrFunc)(error, 0); \
                return; }


#define FailIfMsg(condition, error, msg)  \
            if (condition) {            \
                (*icErrFunc)(error, msg); \
                return; }

extern int objectID;


//----------------------------------------------------------------------
// list stuff
//----------------------------------------------------------------------
class Node {
  public:
    Node        *next;          // must be first
    void        *data;
    int         flags;

    Node();
};

class List {
  public:    
    Node        *head;
    Node        *tail;
    int         count;    

    List();
    
    void Append(void *data);
    void Prepend(void *data);
    Node *Remove(Node *node, Node *prev);
    Node *DeleteFromList(Node *node, List *list);
};

class id {
  public:
    id *	next;		// link to next id
    char        *name;
    int         lextype;
};

//----------------------------------------------------------------------
// declaration stuff
//----------------------------------------------------------------------
class ICDecl
{
  protected:
    id  *declid;
    int size;           /* size of object in bytes      */
    int objid;          /* ic object id                 */
    int declclass;

  public:
    ICDecl();
    void        SetDeclID(id *did)      { declid = did;}
    char        *GetName()              { return declid->name; }
};

class ICIntDecl : public ICDecl
{
  public:
    int value;
    ICIntDecl(int val) { value = val;}
};

class ICObject : public ICDecl
{
  protected:
    void                *thing;
    int                 refCount;
    int                 usedFlag;
    void                *offset;        /* offset in the file image     */  
    
  public:
    
    ICObject();

    int                 GetObjectID()           { return objid;         }
    int                 GetObjectClass()        { return declclass;     }
    int                 GetRefCount()           { return refCount;      }
    int                 GetUsedFlag()           { return usedFlag;      }
    int                 GetObjectOffset()       { return (int)offset;   }
    void                IncRefCount();
    void                DecRefCount();

    virtual int         Size(void);
    virtual void        Print(void);
    virtual void        Write(FILE *f);
    virtual int         LayOut(int offset);
    virtual void        Assemble(void);
    virtual void        Prune(void);
    virtual void        MarkUsed(void);    
};

class ICBook : public ICObject
{
  protected:
    ALADPCMBook *bookp;
    short       *book;
    int         order;
    int         npredictors;
    
  public:
    ICBook();
    ICBook(short *bookPtr, int order, int npredictors);

    void        SetBookData(short *bookPtr, int order, int npredictors);
    
    virtual void        Assemble();
    virtual void        Print();
};

//----------------------------------------------------------------------
// loop stuff
//----------------------------------------------------------------------
typedef short ICLoopState[ADPCMFSIZE];

char *ReadPString(FILE *ifile);

class ICLoop : public ICObject
{
  protected:
    ALADPCMloop *loop;
    u32         start;
    u32         end;
    u32         count;
    ICLoopState state;

  public:

    ICLoop();
    virtual ~ICLoop();
    
    void    SetPoints(u32 start, u32 end, u32 count, ICLoopState state);
    void    Assemble();
    void    Print();
};

class ICWave : public ICObject
{
  protected:  
    ALWaveTable *wave;
    char        *base;
    int         len;
    char        type;
    ICLoop      *loop;
    ICBook      *book;
    
  public:
    ICWave();
    virtual ~ICWave();
    
    void        SetName(char *fname);
    void        SetTable(char *base, int len);
    void        SetBase(char *base);

    int         GetLen() { return this->len; }
    void        SetLen(int len);
    void        SetType(int type);
    
    void        SetLoop(ICLoop *l);
    ICLoop      *GetLoop() { return loop; }
    
    void        SetBook(ICBook *b);
    ICBook      *GetBook() { return book; }
    
    virtual void        Assemble(void);
    virtual void        Print(void);
    virtual void        Prune(void);
    virtual void        MarkUsed(void);
};

class ICEnvelope : public ICObject
{
  protected:
    ALEnvelope  *envelope;
    ALMicroTime attackTime;
    short       attackVol;
    ALMicroTime decayTime;
    short       decayVol;
    ALMicroTime releaseTime;

  public:
    ICEnvelope();

    void    SetAttackTime(ALMicroTime t);
    void    SetAttackVol(short v);
    void    SetDecayTime(ALMicroTime t);
    void    SetDecayVol(short v);
    void    SetReleaseTime(ALMicroTime t);

    virtual void        Assemble(void);
    virtual void        Print(void);
};

class ICKeyMap : public ICObject
{
  public:
    ALKeyMap    *map;           /* file representation          */
    char        velocityMin;
    char        velocityMax;
    char        keyMin;
    char        keyMax;
    char        keyBase;
    char        detune;

    ICKeyMap();
    
    void    SetKeyMin(int min);
    void    SetKeyMax(int max);
    void    SetKeyBase(int base);
    void    SetVelMin(int value);	
    void    SetVelMax(int value);	
    void    SetDetune(int value);	

    virtual void        Assemble(void);
    virtual void        Print(void);
};

class ICSound : public ICObject
{
  protected:
    ALSound     *sound;    
    char        samplePan;
    char        sampleVolume;
    ICEnvelope  *envelope;
    ICKeyMap    *keymap;
    ICWave      *wave;

  public:
    ICSound();
    ICSound(char *file);
    
    void    SetPan(int pan);
    void    SetVol(int vol);

    void        SetKeyMap(ICKeyMap *map);
    ICKeyMap    *GetKeyMap() { return keymap;}
    
    void        SetEnvelope(ICEnvelope *env);
    ICEnvelope  *GetEnvelope() { return envelope;}

    void        SetWaveTable(ICWave *w);
    void        MarkUsed(void);
    
    virtual void        Assemble(void);
    virtual void        Print(void);
    virtual void        Prune(void);
    
};

class ICInst : public ICObject
{
  protected:
    ALInstrument        *inst;
    List                soundList;
    char                volume;
    char                pan;
    char                priority;
    char                tremType;
    char                tremRate;
    char                tremDepth;
    char                tremDelay;
    char                vibType;
    char                vibRate;
    char                vibDepth;
    char                vibDelay;
    int                 soundCount;
    s16                 bendRange;
    int                 sortSounds;
    
  public:
    ICInst();
    
    void        AddSound(ICSound *s, int number);
    void        SetPan(int pan);
    void        SetVol(int vol);
    void        SetPriority(char prior);
    void        SetPitchBendRange(s16 range);
    void        SetTremType(int type);
    void        SetTremRate(int rate);
    void        SetTremDepth(int depth);
    void        SetTremDelay(int delay);
    void        SetVibType(int type);
    void        SetVibRate(int rate);
    void        SetVibDepth(int depth);
    void        SetVibDelay(int delay);
    void        SetSort(int doSort);
    void        ThinSounds(void);
    
    virtual void        Assemble(void);
    virtual void        Print(void);
    virtual void        Prune(void);
    virtual void        MarkUsed(char key);
};


//----------------------------------------------------------------------
// bank object
//----------------------------------------------------------------------
class ICBank : public ICObject
{
  protected:
    ALBank      *bank;          /* file representation          */
    List        progList;       /* list of assigned instruments */
    int         maxPrograms;    /* maximum number of programs   */
    int         sampleRate;     /* sample rate that the bank is designed for */
    ICInst      *percussion;
    int         percActive;

    
  public:
    ICBank();
    
    void   AddProgram(ICInst *i, int number);
    void   SetPercussionDefault(ICInst *i);
    void   SetSampleRate(int srate);
    void   ThinPrograms(void);
    ICInst *GetPercussion(void);
    
    virtual void        Assemble();
    virtual void        Print(void);
    virtual void        Prune(void);
    virtual void        MarkUsed(char program, char key);    
};

class ICBankFile : public ICObject
{
  protected:
    ALBankFile  *bankfile;
    List        bankList;
    int         bankCount;
    int         version;

  public:
    ICBankFile();
    
    void    AddBank(ICBank *b, int number);
    ICBank* GetBank(int number);
    
    virtual void        Assemble(void);
    virtual void        Print(void);
    virtual void        Prune(void);
};

class ICObjTab
{
  protected:
    List objList;
    int  writeCount;    // number of objects written to the bank file
    
  public:
    int     compact;
    
    ICObjTab();
    
    void Append(ICObject *o);
    
    void Print();
    void Write(FILE *f);
    void WriteSymFile(FILE *f);
    void LayOutFile();
    void AssembleFile();
};

class ICWavTab
{
  protected:
    List objList;

  public:
    int     compact;
    
    ICWavTab();
    
    void Append(ICObject *o);
    
    void Print();
    void LayOutFile();
    void AssembleFile();
    void Write(FILE *f);
};

//----------------------------------------------------------------------
// symbol table stuff
//----------------------------------------------------------------------
class ste
{
  public:
    id          *name;
    ICDecl	*decl;
    ste         *prev;
};

class ICSymTab
{
  protected:
    ste	*scopestack[100];	/* stack of saved scopes */
    ste	**stacktop;

    ste	**globalscope;
    
    int offsetstack[100];       /* ??? */
    int *offsettop;
    
  public:
    ICSymTab();
    
    void        Declare(struct id *idptr, ICDecl *declptr);
    void        DeclareGlobal(struct id *idptr, ICDecl *declptr);

    ICDecl      *TestGlobalDecl(id *idptr);
    void        CheckRedecl(id *idptr);
    
    id          *FindName(ICDecl*thedecl);
    ICDecl      *FindCurrentDecl(id *idptr);
    ICDecl      *FindDecl(id *idptr, ste *steptr);
    
    int         InGlobalScope();

    void        PushScope();
    ste         *PopScope();
    
    id          *Enter(int lextype, char *str, int len);
};

class ICSoundFile : public ICObject
{
  protected:
    FILE        *sourceFile;
    ICKeyMap    *keymap;
    ICWave      *wave;
    char        *fileName;
    ICSound     *sound;
    long        dataOffset;
    
  public:
    ICSoundFile(char *name);

    ICKeyMap    *GetKeyMap() { return keymap;}
    ICWave      *GetWaveTable() { return wave; }
    char        *GetName() {return fileName; }
    ICSound     *GetSound() { return sound; }
    
    virtual void Assemble();
    virtual void Print();
    virtual void Prune(void);
    virtual void Write(FILE *file);
};



//----------------------------------------------------------------------
// sequence file stuff
//----------------------------------------------------------------------

#define  IC_NOTE_TYPE   1
#define  IC_PROG_TYPE   2

class ICSeq
{
  protected:
    char         *seqFname; /* the name of the file */
    FILE         *seqFile;  /* the file pointer */
    ALSeqFile    *seqBank;  /* the data pointer */
    char         ChanProgMap[16];    
  public:
    void           loadFile(char *fname);
    void           ResetChanMap(void);
    virtual int    SetSeq(int number);
    virtual int    NextSeqNote(void);
#ifdef OLD_STUFF
    virtual int    NextSeqNote(ICSeqNote /* *theNote */);
#endif
};

//typedef struct {
//    u8  channel;
//    u8  key;
//} ICCNote;

class ICCSeq : public ICSeq
{
  protected:
    ALCMidiHdr  *base;             /* ptr to start of sequence data         */
    int         validTracks;       /* set of flags, showing valid tracks    */
    char        *curLoc[16];       /* ptr to current track location,        */
                                   /* may point to next event, or may point */
                                   /* to a backup code                      */
    char        *curBUPtr[16];     /* ptr to next event if in backup mode   */
    char        curBULen[16];      /* if > 0, then in backup mode           */
    char        lastStatus[16];    /* for running status                    */
//    ICCNote   nextNote[16];      /* Note buffers, one for each track      */

    int         readVarLen(int track);
    char        getTrackByte(int track);
    
  public:
    virtual int SetSeq(int number);
    virtual int NextSeqNote(char *program, char *key);
};

class ICMSeq : public ICSeq
{
  protected:
    char    *seqPtr;
    int     validSeq;
    char    lastStatus;

    char    read8(void);
    short   read16(void);
    int     read32(void);
    int     readVarLen(void);

  public:
    virtual int SetSeq(int number);
    virtual int NextSeqNote(char *program, char *key);
};