#ifndef  _ENCODERCONFIG_CLASS_HPP
#define  _ENCODERCONFIG_CLASS_HPP

/*
**
** EncoderConfigC.hpp
**
** $VER: EncoderConfigC.hpp 1.0 (27.06.98)
**
** $Revision: 1.3 $
** $State: Exp $
** $Date: 1998/08/16 19:03:42 $
**
** $Log: EncoderConfigC.hpp $
** Revision 1.3  1998/08/16 19:03:42  kakace
** Version Beta3+
**
** Revision 1.2  1998/08/02 15:17:08  kakace
** Fonctionnement OK (Layer 1/2 + Stereo/JStereo)
**
** Revision 1.1  1998/07/24 14:26:55  kakace
** Automatic global CheckIn
**
** Revision 1.4  1998/07/24 14:14:30  kakace
** Version intermédiaire (CheckIn global)
**
** Revision 1.2  1998/07/02 15:52:04  kakace
** Automatic global CheckIn
**
**
*/


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

#ifndef  _INCLUDE_STRING_H
#include <string.h>
#endif

#ifndef  _PEGASECOND_HPP
#include "PegaseCond.hpp"
#endif


//----------------------------------------------------------------------------------------------------
//=========================================== Définitions ============================================
//----------------------------------------------------------------------------------------------------

// Définitions de types pour les paramètres de l'encodeur.

enum e_Layer      {LAYER_I, LAYER_II};

enum e_SampFreq   {F_44100, F_48000, F_32000, F_ILLEGAL};
enum e_Encoding   {STEREO, JOINTSTEREO, DUALCHANNEL, MONO};
enum e_Deemphasis {NONE, DEEMP_15US, UNKNOWN, CITT};

enum e_Targets{TARGET_EMPTY, TARGET_DIRECTORY, TARGET_FILE};

const char *asExtensions[] = {".mp1", ".mp2"};


//----------------------------------------------------------------------------------------------------
//====================================== Classe EncoderConfigC =======================================
//----------------------------------------------------------------------------------------------------

class EncoderConfigC
{
    // Drapeaux d'encodage.

    struct s_LayerFlags {BYTEBITS encoding:2;      // Type d'encodage (Mono/stéréo/...)
                         BYTEBITS psycho2:1;       // Modèle psychoacoustique
                         BYTEBITS deemphasis:2;    // Déphasage
                         BYTEBITS copyright:1;     // Copyright
                         BYTEBITS original:1;      // Original
                         BYTEBITS crc:1;           // Somme de contrôle.
                        };

    // Paramètres d'encodage.

    struct s_SamplingModes {BYTEBITS bitrate:4;    // Index du taux de sortie
                            BYTEBITS sampfreq:3;   // Code de la fréquence d'échantillonage.
                           };


    public:

        EncoderConfigC(const EncoderConfigC &roConfig);
        EncoderConfigC() {}

        ~EncoderConfigC() { if (ecfg_cOutputName) delete ecfg_cOutputName; }

    protected:

        void  CopyString(char *cString, char **cPtr)
        {
            if (*cPtr)
            {
                delete *cPtr;
                *cPtr = NULL;
            }

            if (cString && *cString)
            {
                ULONG iStrLen = strlen(cString) + 1;

                if ( (*cPtr = new char[iStrLen]) )
                {
                    strcpy(*cPtr, cString);
                }
            }
        }

    public:

        // Fonctions d'accès aux membres privés.

        void SetOutputName(char *cDest)      {CopyString(cDest, &ecfg_cOutputName);}
        char *GetOutputName()          const {return ecfg_cOutputName;}

        void SetEncodingMode(e_Encoding x)   {ecfg_sFlags.encoding = x;}
        void SetPsycho2Bit(int x)            {ecfg_sFlags.psycho2 = x ? 1 : 0;}
        void SetDeemphasis(ULONG x)          {ecfg_sFlags.deemphasis = (e_Deemphasis) ((x == 2) ? 3 : x);}
        void SetCopyrightBit(int x)          {ecfg_sFlags.copyright = x ? 1 : 0;}
        void SetOriginalBit(int x)           {ecfg_sFlags.original = x ? 1 : 1;}
        void SetCRCBit(int x)                {ecfg_sFlags.crc = x ? 1 : 0;}
        void SetLayer(ULONG iLayer)          {ecfg_iLayer = (e_Layer) --iLayer;}
        void SetCDDAFmt(UWORD fmt)           {ecfg_CDDAFmt = fmt;}

        e_Encoding   GetEncodingMode() const {return (e_Encoding) ecfg_sFlags.encoding;}
        int          IsPsycho2()       const {return ecfg_sFlags.psycho2;}
        e_Deemphasis GetDeemphasis()   const {return (e_Deemphasis) ecfg_sFlags.deemphasis;}
        e_Layer      GetLayer()        const {return (e_Layer) ecfg_iLayer;}
        int          IsCopyrighted()   const {return ecfg_sFlags.copyright;}
        int          IsOriginal()      const {return ecfg_sFlags.original;}
        int          IsCRC()           const {return ecfg_sFlags.crc;}
        UWORD        GetBitRate()      const {return ecfg_wBitrate;}
        UWORD        GetSampleFreq()   const {return ecfg_wSampling;}
        UWORD        GetBitrateIndex() const {return ecfg_sModes.bitrate;}
        UWORD        GetSmplFrqIndex() const {return ecfg_sModes.sampfreq;}
        UWORD        GetCDDAFmt()      const {return ecfg_CDDAFmt;}

        void    SetBitRate(UWORD wBitRate = 160);
        int     SetSampleFreq(UWORD wSampleFreq);

        void      SetTargetType(e_Targets t) {ecfg_wTargetType = t;}
        e_Targets GetTargetType() const      {return (e_Targets) ecfg_wTargetType;}

    protected:

        char           *ecfg_cOutputName;       // Nom du fichier encodé (ou nom de répertoire)
        e_Layer         ecfg_iLayer;            // Numéro de Layer pour l'encodage (0-2 = 1-3)
        UWORD           ecfg_wSampling;         // Fréquence d'échantillonage (Hz)
        UWORD           ecfg_wBitrate;          // Taux de sortie (kbits/s)
        s_LayerFlags    ecfg_sFlags;            // Drapeaux généraux.
        s_SamplingModes ecfg_sModes;            // Mode d'encodage souhaité.
        UWORD           ecfg_wTargetType;       // e_Targets;
        UWORD           ecfg_iIntelFormat;      // TRUE = Format Intel.
        UWORD           ecfg_CDDAFmt;           // 0 = Non spécifié, 1 = Motorola, 2 = Intel.
};

#endif  // _ENCODERCONFIG_CLASS_HPP