1594 lines
51 KiB
C
1594 lines
51 KiB
C
// 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>
|
|
|
|
|
|
#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 )
|
|
{
|
|
/// HZ = 2 * BPM / 5
|
|
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 = fopen(filename, "rb");
|
|
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
|