generic.h

Go to the documentation of this file.

/***********************************************************************

  FinalMix: generic.h
  by Martin Decky
  
  Redistribution of this file is permitted under the GNU Public License.

  0.9.0     Initial version
  0.9.1     Code cleanup
  0.9.2     Standard WX types
  0.9.3     Standardized types
  0.9.4     Exceptions
  0.9.5     Track volume control

***********************************************************************/


#ifndef _FM_GENERIC_H_
#define _FM_GENERIC_H_


#include <wx/wx.h>
#include <wx/file.h>


#define FM_NAME "FinalMix"
#define FM_VENDOR "MD"
#define FM_NAME_UPPER "FINALMIX"
#define FM_VERSION_STRING "0.9.5"

#define FM_PEAK_TAG "FMPE"
#define FM_PEAK_EXT "fpe"

#define FM_CLIP_TAG "FMCL"
#define FM_CLIP_NAME "clipboard"
#define FM_CLIP_EXT "fcl"
#define FM_CLIP_SUFFIX "-" FM_VERSION_STRING

#define FM_PROJECT_TAG "FMPR"
#define FM_PROJECT_EXT "fpr"

#define FULL_PERCENT 100


enum exception_t {
    EXC_WARN = 0, 
    EXC_RUNTIME,  
    EXC_ASSERT,   
    EXC_FATAL     
};


class Exception {
    public:
        Exception(const enum exception_t severity);                      
        Exception(const enum exception_t severity, const wxString desc); 
        enum exception_t GetSeverity() const; 
        wxString GetDesc() const;             
    private:
        enum exception_t sev; 
        wxString dsc;         
};


class ExceptionZero : public Exception {
    public:
        ExceptionZero(const wxString desc); 
};


class ExceptionIO : public Exception {
    public:
        ExceptionIO(); 
};


enum status_t {
    OK = 0,          
    IO_ERROR = -1,   
    UNK_ERROR = -2,  
    UNK_FORMAT = -3, 
    STRUCT_ERR = -4, 
    UNS_FORMAT = -5  
};


enum encoding_t {
    PCM = 0 
};


enum bitencoding_t {
    UNSIGNED = 0, 
    SIGNED        
};


enum samplewidth_t {
    BIT16 = 0, 
    BIT8       
};


enum endianess_t {
    LITTLE = 0, 
    BIG         
};


typedef wxUint8 volume_t;        
extern const volume_t volume_min; 
extern const volume_t volume_max; 
typedef wxUint8 sample_pcm8u_t;     
typedef wxInt8 sample_pcm8s_t;      
typedef wxUint16 sample_pcm16u_t;   
typedef wxInt16 sample_pcm16s_t;    
typedef wxUint32 sample_pcm8u_w_t;  
typedef wxInt32 sample_pcm8s_w_t;   
typedef wxUint64 sample_pcm16u_w_t; 
typedef wxInt64 sample_pcm16s_w_t;  
typedef wxFloat64 floatsample_t;     
typedef wxUint32 samplerate_t; 
typedef wxUint64 samples_t;    
typedef struct {
    wxUint8 bytes[10];
} wxFloat80; 
extern const sample_pcm8u_t sample_pcm8u_min;
extern const sample_pcm8u_t sample_pcm8u_max;
extern const sample_pcm8u_t sample_pcm8u_0;

extern const sample_pcm8s_t sample_pcm8s_min;
extern const sample_pcm8s_t sample_pcm8s_max;
extern const sample_pcm8s_t sample_pcm8s_0;

extern const sample_pcm16u_t sample_pcm16u_min;
extern const sample_pcm16u_t sample_pcm16u_max;
extern const sample_pcm16u_t sample_pcm16u_0;

extern const sample_pcm16s_t sample_pcm16s_min;
extern const sample_pcm16s_t sample_pcm16s_max;
extern const sample_pcm16s_t sample_pcm16s_0;


typedef wxUint16 version_t;                  
extern const version_t fmfile_version_major; 
extern const version_t fmfile_version_minor; 
typedef wxUint64 length_t;  
typedef wxUint16 track_t;   
typedef wxUint32 ratio_t;   
typedef wxUint8 bool_t;     
typedef struct {
    enum encoding_t encoding;       
    enum bitencoding_t bitencoding; 
    enum endianess_t endianess;     
    enum samplewidth_t samplewidth; 
    samplerate_t rate;              
    samples_t samples;              
} format_t;


typedef struct {
    enum encoding_t encoding;       
    enum bitencoding_t bitencoding; 
    enum endianess_t endianess;     
    enum samplewidth_t samplewidth; 
    samplerate_t rate;              
    track_t channels;               
} format_ex_t;


#if defined(__WXMSW__)
#   define __FUNCTION__ "unknown"
#   define __MSW__INT64_BUG__ (signed __int64)
#   define __MSW__DIRDLG_STYLE__ wxDD_NEW_DIR_BUTTON
#else
#   define __MSW__INT64_BUG__
#   define __MSW__DIRDLG_STYLE__ 0
#endif


#define ASSERT(expr) if (!(expr)) { throw Exception(EXC_ASSERT, wxString::Format("Assertion failed: %s (in %s() at %s on line %d)", #expr, __FUNCTION__, __FILE__, __LINE__)); }


#define FATAL(desc) { throw Exception(EXC_FATAL, wxString::Format("Fatal exception: %s (in %s() at %s on line %d)", desc, __FUNCTION__, __FILE__, __LINE__)); }


wxString SetFilename(const wxString path, const wxString name, const wxString ext, const wxString fsuffix); 
size_t SampleLen(const format_t & format);    
size_t SampleLen(const format_ex_t & format); 
void * AllocSamples(const format_t & format, const samples_t count);    
void * AllocSamples(const format_ex_t & format, const samples_t count); 
void FreeSamples(const format_t & format, const void * data);           
void FreeSamples(const format_ex_t & format, const void * data);        
void SamplesAverage(const format_t & format, const samples_t samples, const void * inbuf, const void * outbuf); 
void SamplesMax(const format_t & format, const samples_t samples, const void * inbuf, const void * outbuf);

floatsample_t NormSample(const format_t & format, const void * sample, const floatsample_t max);                                 
floatsample_t SamplesAverageNorm(const format_t & format, const samples_t samples, const void * inbuf, const floatsample_t max); 
floatsample_t SamplesMaxNorm(const format_t & format, const samples_t samples, const void * inbuf, const floatsample_t max);     
samples_t SamplesCmp(const format_t & infmt, const format_t & outfmt, const samples_t samples);                                  
samples_t SamplesCmpIn(const format_t & infmt, const format_t & outfmt, const samples_t insamples);                              
samples_t SamplesConv(const format_t & infmt, const format_ex_t & outfmt, const samples_t samples, void * inbuf, void * outbuf); 
void ClearSamples(const format_ex_t & format, const samples_t samples, void * buf);                                                                           
bool AddSamples(const format_ex_t & format, const volume_t volume[], const samples_t tsamples, const samples_t samples, const void * tbuf, const void * buf); 
void FormatAlias(const format_ex_t & infmt, format_t & outfmt); 
inline void * GetSample(const format_t & format, const samples_t pos, const void * samples) {
    switch (format.encoding) {
        case PCM:
            switch (format.bitencoding) {
                case UNSIGNED:
                    switch (format.samplewidth) {
                        case BIT8:
                            return (sample_pcm8u_t * ) samples + pos;
                        case BIT16:
                            return (sample_pcm16u_t * ) samples + pos;
                        default:
                            FATAL("Undefined format.samplewidth");
                    }
                    break;
                case SIGNED:
                    switch (format.samplewidth) {
                        case BIT8:
                            return (sample_pcm8s_t * ) samples + pos;
                        case BIT16:
                            return (sample_pcm16s_t * ) samples + pos;
                        default:
                            FATAL("Undefined format.samplewidth");
                    }
                    break;
                default:
                    FATAL("Undefined format.bitencoding");
            }
        default:
            FATAL("Undefined format.encoding");
    }
    
    return NULL; /* Unreachable */
}


inline void * GetSample(const format_ex_t & format, const track_t chan, const samples_t pos, const void * samples) {
    switch (format.encoding) {
        case PCM:
            switch (format.bitencoding) {
                case UNSIGNED:
                    switch (format.samplewidth) {
                        case BIT8:
                            return (sample_pcm8u_t * ) samples + pos * format.channels + chan;
                        case BIT16:
                            return (sample_pcm16u_t * ) samples + pos * format.channels + chan;
                        default:
                            FATAL("Undefined format.samplewidth");
                    }
                    break;
                case SIGNED:
                    switch (format.samplewidth) {
                        case BIT8:
                            return (sample_pcm8s_t * ) samples + pos * format.channels + chan;
                        case BIT16:
                            return (sample_pcm16s_t * ) samples + pos * format.channels + chan;
                        default:
                            FATAL("Undefined format.samplewidth");
                    }
                    break;
                default:
                    FATAL("Undefined format.bitencoding");
            }
        default:
            FATAL("Undefined format.encoding");
    }
    
    return NULL; /* Unreachable */
}


inline void ReadValue(wxFile & file, void * buf, size_t size) {
    size_t ret;

    ret = file.Read(buf, size);
    if (ret != size)
        throw ExceptionIO();
}


inline void ReadTag(wxFile & file, char * str, size_t size) {
    ReadValue(file, str, sizeof(char) * size);
    str[size] = 0;
}


inline void ReadString(wxFile & file, wxString & str) {
    wxUint64 len;
    char * tmp;
    
    ReadValue(file, &len, sizeof(len));
    tmp = new char[len];
    ReadValue(file, tmp, sizeof(char) * len);
    tmp[len] = 0;
    str = tmp;
    delete[] tmp;
}


inline void WriteValue(wxFile & file, const void * buf, const size_t size) {
    size_t ret;
    
    ret = file.Write(buf, size);
    if (ret != size)
        throw ExceptionIO();
}


inline void WriteTag(wxFile & file, const char * str) {
    off_t len = strlen(str);

    WriteValue(file, str, sizeof(char) * len);  
}


inline void WriteString(wxFile & file, const char * str) {
    wxUint64 len = strlen(str);
    
    WriteValue(file, &len, sizeof(len));
    WriteValue(file, str, sizeof(char) * len);
}


inline void Seek(wxFile & file, off_t offset) {
    if (file.Seek(offset) == wxInvalidOffset)
        ExceptionIO();
}


template< class T > inline T min(const T a, const T b) {
    if (a < b)
        return a;
    else
        return b;
}


template< class T > inline T max(const T a, const T b) {
    if (a > b)
        return a;
    else
        return b;
}

#endif

---