jar_mod.h

Go to the documentation of this file.

// jar_mod.h - v0.01 - public domain C0 - Joshua Reisenauer
//
// HISTORY:
//
//   v0.01  2016-03-12  Setup
//
//
// USAGE:
//
// In ONE source file, put:
//
//    #define JAR_MOD_IMPLEMENTATION
//    #include "jar_mod.h"
//
// Other source files should just include jar_mod.h
//
// SAMPLE CODE:
// jar_mod_context_t modctx;
// short samplebuff[4096];
// bool bufferFull = false;
// int intro_load(void)
// {
//     jar_mod_init(&modctx);
//     jar_mod_load_file(&modctx, "file.mod");
//     return 1;
// }
// int intro_unload(void)
// {
//     jar_mod_unload(&modctx);
//     return 1;
// }
// int intro_tick(long counter)
// {
//     if(!bufferFull)
//     {
//         jar_mod_fillbuffer(&modctx, samplebuff, 4096, 0);
//         bufferFull=true;
//     }
//     if(IsKeyDown(KEY_ENTER))
//         return 1;
//     return 0;
// }
//
//
// LISCENSE:
//
// Written by: Jean-François DEL NERO (http://hxc2001.com/) <Email : jeanfrancoisdelnero <> free.fr>
// Adapted to jar_mod by: Joshua Adam Reisenauer <kd7tck@gmail.com>
// This program is free software. It comes without any warranty, to the
// extent permitted by applicable law. You can redistribute it and/or
// modify it under the terms of the Do What The Fuck You Want To Public
// License, Version 2, as published by Sam Hocevar. See
// http://sam.zoy.org/wtfpl/COPYING for more details.
// HxCMOD Core API:
// -------------------------------------------
// int  jar_mod_init(jar_mod_context_t * modctx)
//
// - Initialize the jar_mod_context_t buffer. Must be called before doing anything else.
//   Return 1 if success. 0 in case of error.
// -------------------------------------------
// mulong jar_mod_load_file(jar_mod_context_t * modctx, const char* filename)
//
// - "Load" a MOD from file, context must already be initialized.
//   Return size of file in bytes.
// -------------------------------------------
// void jar_mod_fillbuffer( jar_mod_context_t * modctx, short * outbuffer, unsigned long nbsample, jar_mod_tracker_buffer_state * trkbuf )
//
// - Generate and return the next samples chunk to outbuffer.
//   nbsample specify the number of stereo 16bits samples you want.
//   The output format is by default signed 48000Hz 16-bit Stereo PCM samples, otherwise it is changed with jar_mod_setcfg().
//   The output buffer size in bytes must be equal to ( nbsample * 2 * channels ).
//   The optional trkbuf parameter can be used to get detailed status of the player. Put NULL/0 is unused.
// -------------------------------------------
// void jar_mod_unload( jar_mod_context_t * modctx )
// - "Unload" / clear the player status.
// -------------------------------------------
 
 
#ifndef INCLUDE_JAR_MOD_H
#define INCLUDE_JAR_MOD_H
 
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h> // comment this line out if you have bool defined somewhere else
#include <string.h>  // For memset()
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
 
// Basic type
typedef unsigned char muchar;
typedef unsigned short muint;
typedef short mint;
typedef unsigned long mulong;
 
#define NUMMAXCHANNELS 32
#define MAXNOTES 12*12
#define DEFAULT_SAMPLE_RATE 48000
//
// MOD file structures
//
 
#pragma pack(1)
 
typedef struct {
    muchar  name[22];
    muint   length;
    muchar  finetune;
    muchar  volume;
    muint   reppnt;
    muint   replen;
} sample;
 
typedef struct {
    muchar  sampperiod;
    muchar  period;
    muchar  sampeffect;
    muchar  effect;
} note;
 
typedef struct {
    muchar  title[20];
    sample  samples[31];
    muchar  length; // length of tablepos
    muchar  protracker;
    muchar  patterntable[128];
    muchar  signature[4];
    muchar  speed;
} module;
 
#pragma pack()
 
//
// HxCMod Internal structures
//
typedef struct {
    char*   sampdata;
    muint   sampnum;
    muint   length;
    muint   reppnt;
    muint   replen;
    mulong  samppos;
    muint   period;
    muchar  volume;
    mulong  ticks;
    muchar  effect;
    muchar  parameffect;
    muint   effect_code;
    mint    decalperiod;
    mint    portaspeed;
    mint    portaperiod;
    mint    vibraperiod;
    mint    Arpperiods[3];
    muchar  ArpIndex;
    mint    oldk;
    muchar  volumeslide;
    muchar  vibraparam;
    muchar  vibrapointeur;
    muchar  finetune;
    muchar  cut_param;
    muint   patternloopcnt;
    muint   patternloopstartpoint;
} channel;
 
typedef struct {
    module  song;
    char*   sampledata[31];
    note*   patterndata[128];
 
    mulong  playrate;
    muint   tablepos;
    muint   patternpos;
    muint   patterndelay;
    muint   jump_loop_effect;
    muchar  bpm;
    mulong  patternticks;
    mulong  patterntickse;
    mulong  patternticksaim;
    mulong  sampleticksconst;
    mulong  samplenb;
    channel channels[NUMMAXCHANNELS];
    muint   number_of_channels;
    muint   fullperiod[MAXNOTES * 8];
    muint   mod_loaded;
    mint    last_r_sample;
    mint    last_l_sample;
    mint    stereo;
    mint    stereo_separation;
    mint    bits;
    mint    filter;
    
    muchar *modfile; // the raw mod file
    mulong  modfilesize;
    muint   loopcount;
} jar_mod_context_t;
 
//
// Player states structures
//
typedef struct track_state_
{
    unsigned char instrument_number;
    unsigned short cur_period;
    unsigned char  cur_volume;
    unsigned short cur_effect;
    unsigned short cur_parameffect;
}track_state;
 
typedef struct tracker_state_
{
    int number_of_tracks;
    int bpm;
    int speed;
    int cur_pattern;
    int cur_pattern_pos;
    int cur_pattern_table_pos;
    unsigned int buf_index;
    track_state tracks[32];
}tracker_state;
 
typedef struct tracker_state_instrument_
{
    char name[22];
    int  active;
}tracker_state_instrument;
 
typedef struct jar_mod_tracker_buffer_state_
{
    int  nb_max_of_state;
    int  nb_of_state;
    int  cur_rd_index;
    int  sample_step;
    char name[64];
    tracker_state_instrument instruments[31];
    tracker_state * track_state_buf;
}jar_mod_tracker_buffer_state;
 
 
 
bool   jar_mod_init(jar_mod_context_t * modctx);
bool   jar_mod_setcfg(jar_mod_context_t * modctx, int samplerate, int bits, int stereo, int stereo_separation, int filter);
void   jar_mod_fillbuffer(jar_mod_context_t * modctx, short * outbuffer, unsigned long nbsample, jar_mod_tracker_buffer_state * trkbuf);
void   jar_mod_unload(jar_mod_context_t * modctx);
mulong jar_mod_load_file(jar_mod_context_t * modctx, const char* filename);
mulong jar_mod_current_samples(jar_mod_context_t * modctx);
mulong jar_mod_max_samples(jar_mod_context_t * modctx);
void   jar_mod_seek_start(jar_mod_context_t * ctx);
 
#ifdef __cplusplus
}
#endif
//--------------------------------------------------------------------
 
 
 
//-------------------------------------------------------------------------------
#ifdef JAR_MOD_IMPLEMENTATION
 
// Effects list
#define EFFECT_ARPEGGIO              0x0 // Supported
#define EFFECT_PORTAMENTO_UP         0x1 // Supported
#define EFFECT_PORTAMENTO_DOWN       0x2 // Supported
#define EFFECT_TONE_PORTAMENTO       0x3 // Supported
#define EFFECT_VIBRATO               0x4 // Supported
#define EFFECT_VOLSLIDE_TONEPORTA    0x5 // Supported
#define EFFECT_VOLSLIDE_VIBRATO      0x6 // Supported
#define EFFECT_VOLSLIDE_TREMOLO      0x7 // - TO BE DONE -
#define EFFECT_SET_PANNING           0x8 // - TO BE DONE -
#define EFFECT_SET_OFFSET            0x9 // Supported
#define EFFECT_VOLUME_SLIDE          0xA // Supported
#define EFFECT_JUMP_POSITION         0xB // Supported
#define EFFECT_SET_VOLUME            0xC // Supported
#define EFFECT_PATTERN_BREAK         0xD // Supported
 
#define EFFECT_EXTENDED              0xE
#define EFFECT_E_FINE_PORTA_UP       0x1 // Supported
#define EFFECT_E_FINE_PORTA_DOWN     0x2 // Supported
#define EFFECT_E_GLISSANDO_CTRL      0x3 // - TO BE DONE -
#define EFFECT_E_VIBRATO_WAVEFORM    0x4 // - TO BE DONE -
#define EFFECT_E_SET_FINETUNE        0x5 // - TO BE DONE -
#define EFFECT_E_PATTERN_LOOP        0x6 // Supported
#define EFFECT_E_TREMOLO_WAVEFORM    0x7 // - TO BE DONE -
#define EFFECT_E_SET_PANNING_2       0x8 // - TO BE DONE -
#define EFFECT_E_RETRIGGER_NOTE      0x9 // - TO BE DONE -
#define EFFECT_E_FINE_VOLSLIDE_UP    0xA // Supported
#define EFFECT_E_FINE_VOLSLIDE_DOWN  0xB // Supported
#define EFFECT_E_NOTE_CUT            0xC // Supported
#define EFFECT_E_NOTE_DELAY          0xD // - TO BE DONE -
#define EFFECT_E_PATTERN_DELAY       0xE // Supported
#define EFFECT_E_INVERT_LOOP         0xF // - TO BE DONE -
#define EFFECT_SET_SPEED             0xF0 // Supported
#define EFFECT_SET_TEMPO             0xF2 // Supported
 
#define PERIOD_TABLE_LENGTH  MAXNOTES
#define FULL_PERIOD_TABLE_LENGTH  ( PERIOD_TABLE_LENGTH * 8 )
 
static const short periodtable[]=
{
    27392, 25856, 24384, 23040, 21696, 20480, 19328, 18240, 17216, 16256, 15360, 14496,
    13696, 12928, 12192, 11520, 10848, 10240,  9664,  9120,  8606,  8128,  7680,  7248,
     6848,  6464,  6096,  5760,  5424,  5120,  4832,  4560,  4304,  4064,  3840,  3624,
     3424,  3232,  3048,  2880,  2712,  2560,  2416,  2280,  2152,  2032,  1920,  1812,
     1712,  1616,  1524,  1440,  1356,  1280,  1208,  1140,  1076,  1016,   960,   906,
      856,   808,   762,   720,   678,   640,   604,   570,   538,   508,   480,   453,
      428,   404,   381,   360,   339,   320,   302,   285,   269,   254,   240,   226,
      214,   202,   190,   180,   170,   160,   151,   143,   135,   127,   120,   113,
      107,   101,    95,    90,    85,    80,    75,    71,    67,    63,    60,    56,
       53,    50,    47,    45,    42,    40,    37,    35,    33,    31,    30,    28,
       27,    25,    24,    22,    21,    20,    19,    18,    17,    16,    15,    14,
       13,    13,    12,    11,    11,    10,     9,     9,     8,     8,     7,     7
};
 
static const short sintable[]={
      0,  24,  49,  74,  97, 120, 141,161,
    180, 197, 212, 224, 235, 244, 250,253,
    255, 253, 250, 244, 235, 224, 212,197,
    180, 161, 141, 120,  97,  74,  49, 24
};
 
typedef struct modtype_
{
    unsigned char signature[5];
    int numberofchannels;
}modtype;
 
modtype modlist[]=
{
    { "M!K!",4},
    { "M.K.",4},
    { "FLT4",4},
    { "FLT8",8},
    { "4CHN",4},
    { "6CHN",6},
    { "8CHN",8},
    { "10CH",10},
    { "12CH",12},
    { "14CH",14},
    { "16CH",16},
    { "18CH",18},
    { "20CH",20},
    { "22CH",22},
    { "24CH",24},
    { "26CH",26},
    { "28CH",28},
    { "30CH",30},
    { "32CH",32},
    { "",0}
};
 
 
static void memcopy( void * dest, void *source, unsigned long size )
{
    unsigned long i;
    unsigned char * d,*s;
 
    d=(unsigned char*)dest;
    s=(unsigned char*)source;
    for(i=0;i<size;i++)
    {
        d[i]=s[i];
    }
}
 
static void memclear( void * dest, unsigned char value, unsigned long size )
{
    unsigned long i;
    unsigned char * d;
 
    d=(unsigned char*)dest;
    for(i=0;i<size;i++)
    {
        d[i]=value;
    }
}
 
static int memcompare( unsigned char * buf1, unsigned char * buf2, unsigned int size )
{
    unsigned int i;
 
    i = 0;
 
    while(i<size)
    {
        if(buf1[i] != buf2[i])
        {
            return 0;
        }
        i++;
    }
 
    return 1;
}
 
static int getnote( jar_mod_context_t * mod, unsigned short period, int finetune )
{
    int i;
 
    for(i = 0; i < FULL_PERIOD_TABLE_LENGTH; i++)
    {
        if(period >= mod->fullperiod[i])
        {
            return i;
        }
    }
 
    return MAXNOTES;
}
 
static void worknote( note * nptr, channel * cptr, char t, jar_mod_context_t * mod )
{
    muint sample, period, effect, operiod;
    muint curnote, arpnote;
 
    sample = (nptr->sampperiod & 0xF0) | (nptr->sampeffect >> 4);
    period = ((nptr->sampperiod & 0xF) << 8) | nptr->period;
    effect = ((nptr->sampeffect & 0xF) << 8) | nptr->effect;
 
    operiod = cptr->period;
 
    if ( period || sample )
    {
        if( sample && sample < 32 )
        {
            cptr->sampnum = sample - 1;
        }
 
        if( period || sample )
        {
            cptr->sampdata = (char *) mod->sampledata[cptr->sampnum];
            cptr->length = mod->song.samples[cptr->sampnum].length;
            cptr->reppnt = mod->song.samples[cptr->sampnum].reppnt;
            cptr->replen = mod->song.samples[cptr->sampnum].replen;
 
            cptr->finetune = (mod->song.samples[cptr->sampnum].finetune)&0xF;
 
            if(effect>>8!=4 && effect>>8!=6)
            {
                cptr->vibraperiod=0;
                cptr->vibrapointeur=0;
            }
        }
 
        if( (sample != 0) && ( (effect>>8) != EFFECT_VOLSLIDE_TONEPORTA ) )
        {
            cptr->volume = mod->song.samples[cptr->sampnum].volume;
            cptr->volumeslide = 0;
        }
 
        if( ( (effect>>8) != EFFECT_TONE_PORTAMENTO && (effect>>8)!=EFFECT_VOLSLIDE_TONEPORTA) )
        {
            if (period!=0)
                cptr->samppos = 0;
        }
 
        cptr->decalperiod = 0;
        if( period )
        {
            if(cptr->finetune)
            {
                if( cptr->finetune <= 7 )
                {
                    period = mod->fullperiod[getnote(mod,period,0) + cptr->finetune];
                }
                else
                {
                    period = mod->fullperiod[getnote(mod,period,0) - (16 - (cptr->finetune)) ];
                }
            }
 
            cptr->period = period;
        }
 
    }
 
    cptr->effect = 0;
    cptr->parameffect = 0;
    cptr->effect_code = effect;
 
    switch (effect >> 8)
    {
        case EFFECT_ARPEGGIO:
            /*
            [0]: Arpeggio
            Where [0][x][y] means "play note, note+x semitones, note+y
            semitones, then return to original note". The fluctuations are
            carried out evenly spaced in one pattern division. They are usually
            used to simulate chords, but this doesn't work too well. They are
            also used to produce heavy vibrato. A major chord is when x=4, y=7.
            A minor chord is when x=3, y=7.
            */
 
            if(effect&0xff)
            {
                cptr->effect = EFFECT_ARPEGGIO;
                cptr->parameffect = effect&0xff;
 
                cptr->ArpIndex = 0;
 
                curnote = getnote(mod,cptr->period,cptr->finetune);
 
                cptr->Arpperiods[0] = cptr->period;
 
                arpnote = curnote + (((cptr->parameffect>>4)&0xF)*8);
                if( arpnote >= FULL_PERIOD_TABLE_LENGTH )
                    arpnote = FULL_PERIOD_TABLE_LENGTH - 1;
 
                cptr->Arpperiods[1] = mod->fullperiod[arpnote];
 
                arpnote = curnote + (((cptr->parameffect)&0xF)*8);
                if( arpnote >= FULL_PERIOD_TABLE_LENGTH )
                    arpnote = FULL_PERIOD_TABLE_LENGTH - 1;
 
                cptr->Arpperiods[2] = mod->fullperiod[arpnote];
            }
        break;
 
        case EFFECT_PORTAMENTO_UP:
            /*
            [1]: Slide up
            Where [1][x][y] means "smoothly decrease the period of current
            sample by x*16+y after each tick in the division". The
            ticks/division are set with the 'set speed' effect (see below). If
            the period of the note being played is z, then the final period
            will be z - (x*16 + y)*(ticks - 1). As the slide rate depends on
            the speed, changing the speed will change the slide. You cannot
            slide beyond the note B3 (period 113).
            */
 
            cptr->effect = EFFECT_PORTAMENTO_UP;
            cptr->parameffect = effect&0xff;
        break;
 
        case EFFECT_PORTAMENTO_DOWN:
            /*
            [2]: Slide down
            Where [2][x][y] means "smoothly increase the period of current
            sample by x*16+y after each tick in the division". Similar to [1],
            but lowers the pitch. You cannot slide beyond the note C1 (period
            856).
            */
 
            cptr->effect = EFFECT_PORTAMENTO_DOWN;
            cptr->parameffect = effect&0xff;
        break;
 
        case EFFECT_TONE_PORTAMENTO:
            /*
            [3]: Slide to note
            Where [3][x][y] means "smoothly change the period of current sample
            by x*16+y after each tick in the division, never sliding beyond
            current period". The period-length in this channel's division is a
            parameter to this effect, and hence is not played. Sliding to a
            note is similar to effects [1] and [2], but the slide will not go
            beyond the given period, and the direction is implied by that
            period. If x and y are both 0, then the old slide will continue.
            */
 
            cptr->effect = EFFECT_TONE_PORTAMENTO;
            if( (effect&0xff) != 0 )
            {
                cptr->portaspeed = (short)(effect&0xff);
            }
 
            if(period!=0)
            {
                cptr->portaperiod = period;
                cptr->period = operiod;
            }
        break;
 
        case EFFECT_VIBRATO:
            /*
            [4]: Vibrato
            Where [4][x][y] means "oscillate the sample pitch using a
            particular waveform with amplitude y/16 semitones, such that (x *
            ticks)/64 cycles occur in the division". The waveform is set using
            effect [14][4]. By placing vibrato effects on consecutive
            divisions, the vibrato effect can be maintained. If either x or y
            are 0, then the old vibrato values will be used.
            */
 
            cptr->effect = EFFECT_VIBRATO;
            if( ( effect & 0x0F ) != 0 ) // Depth continue or change ?
                cptr->vibraparam = (cptr->vibraparam & 0xF0) | ( effect & 0x0F );
            if( ( effect & 0xF0 ) != 0 ) // Speed continue or change ?
                cptr->vibraparam = (cptr->vibraparam & 0x0F) | ( effect & 0xF0 );
 
        break;
 
        case EFFECT_VOLSLIDE_TONEPORTA:
            /*
            [5]: Continue 'Slide to note', but also do Volume slide
            Where [5][x][y] means "either slide the volume up x*(ticks - 1) or
            slide the volume down y*(ticks - 1), at the same time as continuing
            the last 'Slide to note'". It is illegal for both x and y to be
            non-zero. You cannot slide outside the volume range 0..64. The
            period-length in this channel's division is a parameter to this
            effect, and hence is not played.
            */
 
            if( period != 0 )
            {
                cptr->portaperiod = period;
                cptr->period = operiod;
            }
 
            cptr->effect = EFFECT_VOLSLIDE_TONEPORTA;
            if( ( effect & 0xFF ) != 0 )
                cptr->volumeslide = ( effect & 0xFF );
 
        break;
 
        case EFFECT_VOLSLIDE_VIBRATO:
            /*
            [6]: Continue 'Vibrato', but also do Volume slide
            Where [6][x][y] means "either slide the volume up x*(ticks - 1) or
            slide the volume down y*(ticks - 1), at the same time as continuing
            the last 'Vibrato'". It is illegal for both x and y to be non-zero.
            You cannot slide outside the volume range 0..64.
            */
 
            cptr->effect = EFFECT_VOLSLIDE_VIBRATO;
            if( (effect & 0xFF) != 0 )
                cptr->volumeslide = (effect & 0xFF);
        break;
 
        case EFFECT_SET_OFFSET:
            /*
            [9]: Set sample offset
            Where [9][x][y] means "play the sample from offset x*4096 + y*256".
            The offset is measured in words. If no sample is given, yet one is
            still playing on this channel, it should be retriggered to the new
            offset using the current volume.
            */
 
            cptr->samppos = ((effect>>4) * 4096) + ((effect&0xF)*256);
 
        break;
 
        case EFFECT_VOLUME_SLIDE:
            /*
            [10]: Volume slide
            Where [10][x][y] means "either slide the volume up x*(ticks - 1) or
            slide the volume down y*(ticks - 1)". If both x and y are non-zero,
            then the y value is ignored (assumed to be 0). You cannot slide
            outside the volume range 0..64.
            */
 
            cptr->effect = EFFECT_VOLUME_SLIDE;
            cptr->volumeslide = (effect & 0xFF);
        break;
 
        case EFFECT_JUMP_POSITION:
            /*
            [11]: Position Jump
            Where [11][x][y] means "stop the pattern after this division, and
            continue the song at song-position x*16+y". This shifts the
            'pattern-cursor' in the pattern table (see above). Legal values for
            x*16+y are from 0 to 127.
            */
 
            mod->tablepos = (effect & 0xFF);
            if(mod->tablepos >= mod->song.length)
            {
                mod->tablepos = 0;
            }
            mod->patternpos = 0;
            mod->jump_loop_effect = 1;
 
        break;
 
        case EFFECT_SET_VOLUME:
            /*
            [12]: Set volume
            Where [12][x][y] means "set current sample's volume to x*16+y".
            Legal volumes are 0..64.
            */
 
            cptr->volume = (effect & 0xFF);
        break;
 
        case EFFECT_PATTERN_BREAK:
            /*
            [13]: Pattern Break
            Where [13][x][y] means "stop the pattern after this division, and
            continue the song at the next pattern at division x*10+y" (the 10
            is not a typo). Legal divisions are from 0 to 63 (note Protracker
            exception above).
            */
 
            mod->patternpos = ( ((effect>>4)&0xF)*10 + (effect&0xF) ) * mod->number_of_channels;
            mod->jump_loop_effect = 1;
            mod->tablepos++;
            if(mod->tablepos >= mod->song.length)
            {
                mod->tablepos = 0;
            }
 
        break;
 
        case EFFECT_EXTENDED:
            switch( (effect>>4) & 0xF )
            {
                case EFFECT_E_FINE_PORTA_UP:
                    /*
                    [14][1]: Fineslide up
                    Where [14][1][x] means "decrement the period of the current sample
                    by x". The incrementing takes place at the beginning of the
                    division, and hence there is no actual sliding. You cannot slide
                    beyond the note B3 (period 113).
                    */
 
                    cptr->period -= (effect & 0xF);
                    if( cptr->period < 113 )
                        cptr->period = 113;
                break;
 
                case EFFECT_E_FINE_PORTA_DOWN:
                    /*
                    [14][2]: Fineslide down
                    Where [14][2][x] means "increment the period of the current sample
                    by x". Similar to [14][1] but shifts the pitch down. You cannot
                    slide beyond the note C1 (period 856).
                    */
 
                    cptr->period += (effect & 0xF);
                    if( cptr->period > 856 )
                        cptr->period = 856;
                break;
 
                case EFFECT_E_FINE_VOLSLIDE_UP:
                    /*
                    [14][10]: Fine volume slide up
                    Where [14][10][x] means "increment the volume of the current sample
                    by x". The incrementing takes place at the beginning of the
                    division, and hence there is no sliding. You cannot slide beyond
                    volume 64.
                    */
 
                    cptr->volume += (effect & 0xF);
                    if( cptr->volume>64 )
                        cptr->volume = 64;
                break;
 
                case EFFECT_E_FINE_VOLSLIDE_DOWN:
                    /*
                    [14][11]: Fine volume slide down
                    Where [14][11][x] means "decrement the volume of the current sample
                    by x". Similar to [14][10] but lowers volume. You cannot slide
                    beyond volume 0.
                    */
 
                    cptr->volume -= (effect & 0xF);
                    if( cptr->volume > 200 )
                        cptr->volume = 0;
                break;
 
                case EFFECT_E_PATTERN_LOOP:
                    /*
                    [14][6]: Loop pattern
                    Where [14][6][x] means "set the start of a loop to this division if
                    x is 0, otherwise after this division, jump back to the start of a
                    loop and play it another x times before continuing". If the start
                    of the loop was not set, it will default to the start of the
                    current pattern. Hence 'loop pattern' cannot be performed across
                    multiple patterns. Note that loops do not support nesting, and you
                    may generate an infinite loop if you try to nest 'loop pattern's.
                    */
 
                    if( effect & 0xF )
                    {
                        if( cptr->patternloopcnt )
                        {
                            cptr->patternloopcnt--;
                            if( cptr->patternloopcnt )
                            {
                                mod->patternpos = cptr->patternloopstartpoint;
                                mod->jump_loop_effect = 1;
                            }
                            else
                            {
                                cptr->patternloopstartpoint = mod->patternpos ;
                            }
                        }
                        else
                        {
                            cptr->patternloopcnt = (effect & 0xF);
                            mod->patternpos = cptr->patternloopstartpoint;
                            mod->jump_loop_effect = 1;
                        }
                    }
                    else // Start point
                    {
                        cptr->patternloopstartpoint = mod->patternpos;
                    }
 
                break;
 
                case EFFECT_E_PATTERN_DELAY:
                    /*
                    [14][14]: Delay pattern
                    Where [14][14][x] means "after this division there will be a delay
                    equivalent to the time taken to play x divisions after which the
                    pattern will be resumed". The delay only relates to the
                    interpreting of new divisions, and all effects and previous notes
                    continue during delay.
                    */
 
                    mod->patterndelay = (effect & 0xF);
                break;
 
                case EFFECT_E_NOTE_CUT:
                    /*
                    [14][12]: Cut sample
                    Where [14][12][x] means "after the current sample has been played
                    for x ticks in this division, its volume will be set to 0". This
                    implies that if x is 0, then you will not hear any of the sample.
                    If you wish to insert "silence" in a pattern, it is better to use a
                    "silence"-sample (see above) due to the lack of proper support for
                    this effect.
                    */
                    cptr->effect = EFFECT_E_NOTE_CUT;
                    cptr->cut_param = (effect & 0xF);
                    if(!cptr->cut_param)
                        cptr->volume = 0;
                break;
 
                default:
 
                break;
            }
        break;
 
        case 0xF:
            /*
            [15]: Set speed
            Where [15][x][y] means "set speed to x*16+y". Though it is nowhere
            near that simple. Let z = x*16+y. Depending on what values z takes,
            different units of speed are set, there being two: ticks/division
            and beats/minute (though this one is only a label and not strictly
            true). If z=0, then what should technically happen is that the
            module stops, but in practice it is treated as if z=1, because
            there is already a method for stopping the module (running out of
            patterns). If z<=32, then it means "set ticks/division to z"
            otherwise it means "set beats/minute to z" (convention says that
            this should read "If z<32.." but there are some composers out there
            that defy conventions). Default values are 6 ticks/division, and
            125 beats/minute (4 divisions = 1 beat). The beats/minute tag is
            only meaningful for 6 ticks/division. To get a more accurate view
            of how things work, use the following formula:
                                     24 * beats/minute
                  divisions/minute = -----------------
                                      ticks/division
            Hence divisions/minute range from 24.75 to 6120, eg. to get a value
            of 2000 divisions/minute use 3 ticks/division and 250 beats/minute.
            If multiple "set speed" effects are performed in a single division,
            the ones on higher-numbered channels take precedence over the ones
            on lower-numbered channels. This effect has a large number of
            different implementations, but the one described here has the
            widest usage.
            */
 
            if( (effect&0xFF) < 0x21 )
            {
                if( effect&0xFF )
                {
                    mod->song.speed = effect&0xFF;
                    mod->patternticksaim = (long)mod->song.speed * ((mod->playrate * 5 ) / (((long)2 * (long)mod->bpm)));
                }
            }
 
            if( (effect&0xFF) >= 0x21 )
            {
                mod->bpm = effect&0xFF;
                mod->patternticksaim = (long)mod->song.speed * ((mod->playrate * 5 ) / (((long)2 * (long)mod->bpm)));
            }
 
        break;
 
        default:
        // Unsupported effect
        break;
 
    }
 
}
 
static void workeffect( note * nptr, channel * cptr )
{
    switch(cptr->effect)
    {
        case EFFECT_ARPEGGIO:
 
            if( cptr->parameffect )
            {
                cptr->decalperiod = cptr->period - cptr->Arpperiods[cptr->ArpIndex];
 
                cptr->ArpIndex++;
                if( cptr->ArpIndex>2 )
                    cptr->ArpIndex = 0;
            }
        break;
 
        case EFFECT_PORTAMENTO_UP:
 
            if(cptr->period)
            {
                cptr->period -= cptr->parameffect;
 
                if( cptr->period < 113 || cptr->period > 20000 )
                    cptr->period = 113;
            }
 
        break;
 
        case EFFECT_PORTAMENTO_DOWN:
 
            if(cptr->period)
            {
                cptr->period += cptr->parameffect;
 
                if( cptr->period > 20000 )
                    cptr->period = 20000;
            }
 
        break;
 
        case EFFECT_VOLSLIDE_TONEPORTA:
        case EFFECT_TONE_PORTAMENTO:
 
            if( cptr->period && ( cptr->period != cptr->portaperiod ) && cptr->portaperiod )
            {
                if( cptr->period > cptr->portaperiod )
                {
                    if( cptr->period - cptr->portaperiod >= cptr->portaspeed )
                    {
                        cptr->period -= cptr->portaspeed;
                    }
                    else
                    {
                        cptr->period = cptr->portaperiod;
                    }
                }
                else
                {
                    if( cptr->portaperiod - cptr->period >= cptr->portaspeed )
                    {
                        cptr->period += cptr->portaspeed;
                    }
                    else
                    {
                        cptr->period = cptr->portaperiod;
                    }
                }
 
                if( cptr->period == cptr->portaperiod )
                {
                    // If the slide is over, don't let it to be retriggered.
                    cptr->portaperiod = 0;
                }
            }
 
            if( cptr->effect == EFFECT_VOLSLIDE_TONEPORTA )
            {
                if( cptr->volumeslide > 0x0F )
                {
                    cptr->volume = cptr->volume + (cptr->volumeslide>>4);
 
                    if(cptr->volume>63)
                        cptr->volume = 63;
                }
                else
                {
                    cptr->volume = cptr->volume - (cptr->volumeslide);
 
                    if(cptr->volume>63)
                        cptr->volume=0;
                }
            }
        break;
 
        case EFFECT_VOLSLIDE_VIBRATO:
        case EFFECT_VIBRATO:
 
            cptr->vibraperiod = ( (cptr->vibraparam&0xF) * sintable[cptr->vibrapointeur&0x1F] )>>7;
 
            if( cptr->vibrapointeur > 31 )
                cptr->vibraperiod = -cptr->vibraperiod;
 
            cptr->vibrapointeur = (cptr->vibrapointeur+(((cptr->vibraparam>>4))&0xf)) & 0x3F;
 
            if( cptr->effect == EFFECT_VOLSLIDE_VIBRATO )
            {
                if( cptr->volumeslide > 0xF )
                {
                    cptr->volume = cptr->volume+(cptr->volumeslide>>4);
 
                    if( cptr->volume > 64 )
                        cptr->volume = 64;
                }
                else
                {
                    cptr->volume = cptr->volume - cptr->volumeslide;
 
                    if( cptr->volume > 64 )
                        cptr->volume = 0;
                }
            }
 
        break;
 
        case EFFECT_VOLUME_SLIDE:
 
            if( cptr->volumeslide > 0xF )
            {
                cptr->volume += (cptr->volumeslide>>4);
 
                if( cptr->volume > 64 )
                    cptr->volume = 64;
            }
            else
            {
                cptr->volume -= (cptr->volumeslide&0xf);
 
                if( cptr->volume > 64 )
                    cptr->volume = 0;
            }
        break;
 
        case EFFECT_E_NOTE_CUT:
            if(cptr->cut_param)
                cptr->cut_param--;
 
            if(!cptr->cut_param)
                cptr->volume = 0;
        break;
 
        default:
        break;
 
    }
 
}
 
bool jar_mod_init(jar_mod_context_t * modctx)
{
    muint i,j;
 
    if( modctx )
    {
        memclear(modctx, 0, sizeof(jar_mod_context_t));
        modctx->playrate = DEFAULT_SAMPLE_RATE;
        modctx->stereo = 1;
        modctx->stereo_separation = 1;
        modctx->bits = 16;
        modctx->filter = 1;
 
        for(i=0; i < PERIOD_TABLE_LENGTH - 1; i++)
        {
            for(j=0; j < 8; j++)
            {
                modctx->fullperiod[(i*8) + j] = periodtable[i] - ((( periodtable[i] - periodtable[i+1] ) / 8) * j);
            }
        }
 
        return 1;
    }
 
    return 0;
}
 
bool jar_mod_setcfg(jar_mod_context_t * modctx, int samplerate, int bits, int stereo, int stereo_separation, int filter)
{
    if( modctx )
    {
        modctx->playrate = samplerate;
 
        if( stereo )
            modctx->stereo = 1;
        else
            modctx->stereo = 0;
            
        if(stereo_separation < 4)
        {
            modctx->stereo_separation = stereo_separation;
        }
 
        if( bits == 8 || bits == 16 )
            modctx->bits = bits;
        else
            modctx->bits = 16;
 
        if( filter )
            modctx->filter = 1;
        else
            modctx->filter = 0;
 
        return 1;
    }
 
    return 0;
}
 
// make certain that mod_data stays in memory while playing
static bool jar_mod_load( jar_mod_context_t * modctx, void * mod_data, int mod_data_size )
{
    muint i, max;
    unsigned short t;
    sample *sptr;
    unsigned char * modmemory,* endmodmemory;
 
    modmemory = (unsigned char *)mod_data;
    endmodmemory = modmemory + mod_data_size;
    
    
 
    if(modmemory)
    {
        if( modctx )
        {
            memcopy(&(modctx->song.title),modmemory,1084);
 
            i = 0;
            modctx->number_of_channels = 0;
            while(modlist[i].numberofchannels)
            {
                if(memcompare(modctx->song.signature,modlist[i].signature,4))
                {
                    modctx->number_of_channels = modlist[i].numberofchannels;
                }
 
                i++;
            }
 
            if( !modctx->number_of_channels )
            {
                // 15 Samples modules support
                // Shift the whole datas to make it look likes a standard 4 channels mod.
                memcopy(&(modctx->song.signature), "M.K.", 4);
                memcopy(&(modctx->song.length), &(modctx->song.samples[15]), 130);
                memclear(&(modctx->song.samples[15]), 0, 480);
                modmemory += 600;
                modctx->number_of_channels = 4;
            }
            else
            {
                modmemory += 1084;
            }
 
            if( modmemory >= endmodmemory )
                return 0; // End passed ? - Probably a bad file !
 
            // Patterns loading
            for (i = max = 0; i < 128; i++)
            {
                while (max <= modctx->song.patterntable[i])
                {
                    modctx->patterndata[max] = (note*)modmemory;
                    modmemory += (256*modctx->number_of_channels);
                    max++;
 
                    if( modmemory >= endmodmemory )
                        return 0; // End passed ? - Probably a bad file !
                }
            }
 
            for (i = 0; i < 31; i++)
                modctx->sampledata[i]=0;
 
            // Samples loading
            for (i = 0, sptr = modctx->song.samples; i <31; i++, sptr++)
            {
                t= (sptr->length &0xFF00)>>8 | (sptr->length &0xFF)<<8;
                sptr->length = t*2;
 
                t= (sptr->reppnt &0xFF00)>>8 | (sptr->reppnt &0xFF)<<8;
                sptr->reppnt = t*2;
 
                t= (sptr->replen &0xFF00)>>8 | (sptr->replen &0xFF)<<8;
                sptr->replen = t*2;
 
 
                if (sptr->length == 0) continue;
 
                modctx->sampledata[i] = (char*)modmemory;
                modmemory += sptr->length;
 
                if (sptr->replen + sptr->reppnt > sptr->length)
                    sptr->replen = sptr->length - sptr->reppnt;
 
                if( modmemory > endmodmemory )
                    return 0; // End passed ? - Probably a bad file !
            }
 
            // States init
 
            modctx->tablepos = 0;
            modctx->patternpos = 0;
            modctx->song.speed = 6;
            modctx->bpm = 125;
            modctx->samplenb = 0;
 
            modctx->patternticks = (((long)modctx->song.speed * modctx->playrate * 5)/ (2 * modctx->bpm)) + 1;
            modctx->patternticksaim = ((long)modctx->song.speed * modctx->playrate * 5) / (2 * modctx->bpm);
 
            modctx->sampleticksconst = 3546894UL / modctx->playrate; //8448*428/playrate;
 
            for(i=0; i < modctx->number_of_channels; i++)
            {
                modctx->channels[i].volume = 0;
                modctx->channels[i].period = 0;
            }
 
            modctx->mod_loaded = 1;
 
            return 1;
        }
    }
 
    return 0;
}
 
void jar_mod_fillbuffer( jar_mod_context_t * modctx, short * outbuffer, unsigned long nbsample, jar_mod_tracker_buffer_state * trkbuf )
{
    unsigned long i, j;
    unsigned long k;
    unsigned char c;
    unsigned int state_remaining_steps;
    int l,r;
    int ll,lr;
    int tl,tr;
    short finalperiod;
    note    *nptr;
    channel *cptr;
 
    if( modctx && outbuffer )
    {
        if(modctx->mod_loaded)
        {
            state_remaining_steps = 0;
 
            if( trkbuf )
            {
                trkbuf->cur_rd_index = 0;
 
                memcopy(trkbuf->name,modctx->song.title,sizeof(modctx->song.title));
 
                for(i=0;i<31;i++)
                {
                    memcopy(trkbuf->instruments[i].name,modctx->song.samples[i].name,sizeof(trkbuf->instruments[i].name));
                }
            }
 
            ll = modctx->last_l_sample;
            lr = modctx->last_r_sample;
 
            for (i = 0; i < nbsample; i++)
            {
                //---------------------------------------
                if( modctx->patternticks++ > modctx->patternticksaim )
                {
                    if( !modctx->patterndelay )
                    {
                        nptr = modctx->patterndata[modctx->song.patterntable[modctx->tablepos]];
                        nptr = nptr + modctx->patternpos;
                        cptr = modctx->channels;
 
                        modctx->patternticks = 0;
                        modctx->patterntickse = 0;
 
                        for(c=0;c<modctx->number_of_channels;c++)
                        {
                            worknote((note*)(nptr+c), (channel*)(cptr+c),(char)(c+1),modctx);
                        }
 
                        if( !modctx->jump_loop_effect )
                            modctx->patternpos += modctx->number_of_channels;
                        else
                            modctx->jump_loop_effect = 0;
 
                        if( modctx->patternpos == 64*modctx->number_of_channels )
                        {
                            modctx->tablepos++;
                            modctx->patternpos = 0;
                            if(modctx->tablepos >= modctx->song.length)
                            {
                                modctx->tablepos = 0;
                                modctx->loopcount++; // count next loop
                            }
                        }
                    }
                    else
                    {
                        modctx->patterndelay--;
                        modctx->patternticks = 0;
                        modctx->patterntickse = 0;
                    }
 
                }
 
                if( modctx->patterntickse++ > (modctx->patternticksaim/modctx->song.speed) )
                {
                    nptr = modctx->patterndata[modctx->song.patterntable[modctx->tablepos]];
                    nptr = nptr + modctx->patternpos;
                    cptr = modctx->channels;
 
                    for(c=0;c<modctx->number_of_channels;c++)
                    {
                        workeffect(nptr+c, cptr+c);
                    }
 
                    modctx->patterntickse = 0;
                }
 
                //---------------------------------------
 
                if( trkbuf && !state_remaining_steps )
                {
                    if( trkbuf->nb_of_state < trkbuf->nb_max_of_state )
                    {
                        memclear(&trkbuf->track_state_buf[trkbuf->nb_of_state], 0, sizeof(tracker_state));
                    }
                }
 
                l=0;
                r=0;
 
                for(j =0, cptr = modctx->channels; j < modctx->number_of_channels ; j++, cptr++)
                {
                    if( cptr->period != 0 )
                    {
                        finalperiod = cptr->period - cptr->decalperiod - cptr->vibraperiod;
                        if( finalperiod )
                        {
                            cptr->samppos += ( (modctx->sampleticksconst<<10) / finalperiod );
                        }
 
                        cptr->ticks++;
 
                        if( cptr->replen<=2 )
                        {
                            if( (cptr->samppos>>10) >= (cptr->length) )
                            {
                                cptr->length = 0;
                                cptr->reppnt = 0;
 
                                if( cptr->length )
                                    cptr->samppos = cptr->samppos % (((unsigned long)cptr->length)<<10);
                                else
                                    cptr->samppos = 0;
                            }
                        }
                        else
                        {
                            if( (cptr->samppos>>10) >= (unsigned long)(cptr->replen+cptr->reppnt) )
                            {
                                cptr->samppos = ((unsigned long)(cptr->reppnt)<<10) + (cptr->samppos % ((unsigned long)(cptr->replen+cptr->reppnt)<<10));
                            }
                        }
 
                        k = cptr->samppos >> 10;
 
                        if( cptr->sampdata!=0 && ( ((j&3)==1) || ((j&3)==2) ) )
                        {
                            r += ( cptr->sampdata[k] *  cptr->volume );
                        }
 
                        if( cptr->sampdata!=0 && ( ((j&3)==0) || ((j&3)==3) ) )
                        {
                            l += ( cptr->sampdata[k] *  cptr->volume );
                        }
 
                        if( trkbuf && !state_remaining_steps )
                        {
                            if( trkbuf->nb_of_state < trkbuf->nb_max_of_state )
                            {
                                trkbuf->track_state_buf[trkbuf->nb_of_state].number_of_tracks = modctx->number_of_channels;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].buf_index = i;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].cur_pattern = modctx->song.patterntable[modctx->tablepos];
                                trkbuf->track_state_buf[trkbuf->nb_of_state].cur_pattern_pos = modctx->patternpos / modctx->number_of_channels;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].cur_pattern_table_pos = modctx->tablepos;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].bpm = modctx->bpm;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].speed = modctx->song.speed;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].cur_effect = cptr->effect_code;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].cur_parameffect = cptr->parameffect;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].cur_period = finalperiod;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].cur_volume = cptr->volume;
                                trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].instrument_number = (unsigned char)cptr->sampnum;
                            }
                        }
                    }
                }
 
                if( trkbuf && !state_remaining_steps )
                {
                    state_remaining_steps = trkbuf->sample_step;
 
                    if(trkbuf->nb_of_state < trkbuf->nb_max_of_state)
                        trkbuf->nb_of_state++;
                }
                else
                {
                    state_remaining_steps--;
                }
 
                tl = (short)l;
                tr = (short)r;
 
                if ( modctx->filter )
                {
                    // Filter
                    l = (l+ll)>>1;
                    r = (r+lr)>>1;
                }
 
                if ( modctx->stereo_separation == 1 )
                {
                    // Left & Right Stereo panning
                    l = (l+(r>>1));
                    r = (r+(l>>1));
                }
 
                // Level limitation
                if( l > 32767 ) l = 32767;
                if( l < -32768 ) l = -32768;
                if( r > 32767 ) r = 32767;
                if( r < -32768 ) r = -32768;
 
                // Store the final sample.
                outbuffer[(i*2)]   = l;
                outbuffer[(i*2)+1] = r;
 
                ll = tl;
                lr = tr;
 
            }
 
            modctx->last_l_sample = ll;
            modctx->last_r_sample = lr;
 
            modctx->samplenb = modctx->samplenb+nbsample;
        }
        else
        {
            for (i = 0; i < nbsample; i++)
            {
                // Mod not loaded. Return blank buffer.
                outbuffer[(i*2)]   = 0;
                outbuffer[(i*2)+1] = 0;
            }
 
            if(trkbuf)
            {
                trkbuf->nb_of_state = 0;
                trkbuf->cur_rd_index = 0;
                trkbuf->name[0] = 0;
                memclear(trkbuf->track_state_buf, 0, sizeof(tracker_state) * trkbuf->nb_max_of_state);
                memclear(trkbuf->instruments, 0, sizeof(trkbuf->instruments));
            }
        }
    }
}
 
//resets internals for mod context
static bool jar_mod_reset( jar_mod_context_t * modctx)
{
    if(modctx)
    {
        memclear(&modctx->song, 0, sizeof(modctx->song));
        memclear(&modctx->sampledata, 0, sizeof(modctx->sampledata));
        memclear(&modctx->patterndata, 0, sizeof(modctx->patterndata));
        modctx->tablepos = 0;
        modctx->patternpos = 0;
        modctx->patterndelay  = 0;
        modctx->jump_loop_effect = 0;
        modctx->bpm = 0;
        modctx->patternticks = 0;
        modctx->patterntickse = 0;
        modctx->patternticksaim = 0;
        modctx->sampleticksconst = 0;
        modctx->samplenb = 0;
        memclear(modctx->channels, 0, sizeof(modctx->channels));
        modctx->number_of_channels = 0;
        modctx->mod_loaded = 0;
        modctx->last_r_sample = 0;
        modctx->last_l_sample = 0;
        
        return jar_mod_init(modctx);
    }
    return 0;
}
 
void jar_mod_unload( jar_mod_context_t * modctx)
{
    if(modctx)
    {
        if(modctx->modfile)
        {
            free(modctx->modfile);
            modctx->modfile = 0;
            modctx->modfilesize = 0;
            modctx->loopcount = 0;
        }
        jar_mod_reset(modctx);
    }
}
 
 
 
mulong jar_mod_load_file(jar_mod_context_t * modctx, const char* filename)
{
    mulong fsize = 0;
    if(modctx->modfile)
    {
        free(modctx->modfile);
        modctx->modfile = 0;
    }
    
    FILE *f = NULL;
#if defined(_MSC_VER) && _MSC_VER >= 1500
    fopen_s(&f, filename, "rb");
#else
    f = fopen(filename, "rb");
#endif
    if(f)
    {
        fseek(f,0,SEEK_END);
        fsize = ftell(f);
        fseek(f,0,SEEK_SET);
        
        if(fsize && fsize < 32*1024*1024)
        {
            modctx->modfile = malloc(fsize);
            modctx->modfilesize = fsize;
            memset(modctx->modfile, 0, fsize);
            fread(modctx->modfile, fsize, 1, f);
            fclose(f);
            
            if(!jar_mod_load(modctx, (void*)modctx->modfile, fsize)) fsize = 0;
        } else fsize = 0;
    }
    return fsize;
}
 
mulong jar_mod_current_samples(jar_mod_context_t * modctx)
{
    if(modctx)
        return modctx->samplenb;
    
    return 0;
}
 
// Works, however it is very slow, this data should be cached to ensure it is run only once per file
mulong jar_mod_max_samples(jar_mod_context_t * ctx)
{
    mint buff[2];
    mulong len;
    mulong lastcount = ctx->loopcount;
    
    while(ctx->loopcount <= lastcount)
        jar_mod_fillbuffer(ctx, buff, 1, 0);
    
    len = ctx->samplenb;
    jar_mod_seek_start(ctx);
    
    return len;
}
 
// move seek_val to sample index, 0 -> jar_mod_max_samples is the range
void jar_mod_seek_start(jar_mod_context_t * ctx)
{
    if(ctx && ctx->modfile)
    {
        muchar* ftmp = ctx->modfile;
        mulong stmp = ctx->modfilesize;
        muint lcnt = ctx->loopcount;
        
        if(jar_mod_reset(ctx)){
            jar_mod_load(ctx, ftmp, stmp);
            ctx->modfile = ftmp;
            ctx->modfilesize = stmp;
            ctx->loopcount = lcnt;
        }
    }
}
 
#endif // end of JAR_MOD_IMPLEMENTATION
//-------------------------------------------------------------------------------
 
 
#endif //end of header file