apps/codecs/mod.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * MOD Codec for rockbox
  11  *
  12  * Written from scratch by Rainer Sinsch
  13  *         exclusivly for Rockbox in February 2008
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  21  * KIND, either express or implied.
  22  *
  23  ****************************************************************************/
  24
  25  /**************
  26   * This version supports large files directly from internal memory management.
  27   * There is a drawback however: It may happen that a song is not completely
  28   * loaded when the internal rockbox-ringbuffer (approx. 28MB) is filled up
  29   * As a workaround make sure you don't have directories with mods larger
  30   * than a total of 28MB
  31   *************/
  32
  33 #include "debug.h"
  34 #include "codeclib.h"
  35 #include <inttypes.h>
  36
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40 #include <ctype.h>
  41
  42
  43 CODEC_HEADER
  44
  45 #define CHUNK_SIZE (1024*2)
  46
  47
  48 /* This codec supports MOD Files:
  49  *
  50  */
  51
  52 static int32_t samples[CHUNK_SIZE] IBSS_ATTR;   /* The sample buffer */
  53
  54 /* Instrument Data */
  55 struct s_instrument {
  56     /* Sample name / description */
  57     /*char description[22];*/
  58
  59     /* Sample length in bytes */
  60     unsigned short length;
  61
  62     /* Sample finetuning (-8 - +7) */
  63     signed char finetune;
  64
  65     /* Sample volume (0 - 64) */
  66     signed char volume;
  67
  68     /* Sample Repeat Position */
  69     unsigned short repeatoffset;
  70
  71     /* Sample Repeat Length  */
  72     unsigned short repeatlength;
  73
  74     /* Offset to sample data */
  75     unsigned int sampledataoffset;
  76 };
  77
  78 /* Song Data */
  79 struct s_song {
  80     /* Song name / title description */
  81     /*char szTitle[20];*/
  82
  83     /* No. of channels in song */
  84     unsigned char noofchannels;
  85
  86     /* No. of instruments used (either 15 or 31) */
  87     unsigned char noofinstruments;
  88
  89     /* How many patterns are beeing played? */
  90     unsigned char songlength;
  91
  92     /* Where to jump after the song end? */
  93     unsigned char songendjumpposition;
  94
  95     /* Pointer to the Pattern Order Table */
  96     unsigned char *patternordertable;
  97
  98     /* Pointer to the pattern data  */
  99     void *patterndata;
 100
 101     /* Pointer to the sample buffer */
 102     signed char *sampledata;
 103
 104     /* Instrument data  */
 105     struct s_instrument instrument[31];
 106 };
 107
 108 struct s_modchannel {
 109     /* Current Volume */
 110     signed char volume;
 111
 112     /* Current Offset to period in PeriodTable of notebeeing played
 113        (can be temporarily negative) */
 114     short periodtableoffset;
 115
 116     /* Current Period beeing played */
 117     short period;
 118
 119     /* Current effect */
 120     unsigned char effect;
 121
 122     /* Current parameters of effect */
 123     unsigned char effectparameter;
 124
 125     /* Current Instrument beeing played */
 126     unsigned char instrument;
 127
 128     /* Current Vibrato Speed */
 129     unsigned char vibratospeed;
 130
 131     /* Current Vibrato Depth */
 132     unsigned char vibratodepth;
 133
 134     /* Current Position for Vibrato in SinTable */
 135     unsigned char vibratosinpos;
 136
 137     /* Current Tremolo Speed */
 138     unsigned char tremolospeed;
 139
 140     /* Current Tremolo Depth */
 141     unsigned char tremolodepth;
 142
 143     /* Current Position for Tremolo in SinTable */
 144     unsigned char tremolosinpos;
 145
 146     /* Current Speed of Effect "Slide Note up" */
 147     unsigned char slideupspeed;
 148
 149     /* Current Speed of Effect "Slide Note down" */
 150     unsigned char slidedownspeed;
 151
 152     /* Current Speed of the "Slide to Note" effect */
 153     unsigned char slidetonotespeed;
 154
 155     /* Current Period of the "Slide to Note" effect */
 156     unsigned short slidetonoteperiod;
 157 };
 158
 159 struct s_modplayer {
 160     /* Ticks per Line */
 161     unsigned char ticksperline;
 162
 163     /* Beats per Minute */
 164     unsigned char bpm;
 165
 166     /* Position of the Song in the Pattern Table (0-127) */
 167     unsigned char patterntableposition;
 168
 169     /* Current Line (may be temporarily < 0) */
 170     signed char currentline;
 171
 172     /* Current Tick */
 173     signed char currenttick;
 174
 175     /* How many samples are required to calculate for each tick? */
 176     unsigned int samplespertick;
 177
 178     /* Information about the channels */
 179     struct s_modchannel modchannel[8];
 180
 181     /* The Amiga Period Table
 182        (+1 because we use index 0 for period 0 = no new note) */
 183     unsigned short periodtable[37*8+1];
 184
 185     /* The sinus table [-255,255] */
 186     signed short sintable[0x40];
 187
 188     /* Is the glissando effect enabled? */
 189     bool glissandoenabled;
 190
 191     /* Is the Amiga Filter enabled? */
 192     bool amigafilterenabled;
 193
 194     /* The pattern-line where the loop is carried out (set with e6 command) */
 195     unsigned char loopstartline;
 196
 197     /* Number of times to loop */
 198     unsigned char looptimes;
 199 };
 200
 201 struct s_channel {
 202     /* Panning (0 = left, 16 = right) */
 203     unsigned char panning;
 204
 205     /* Sample frequency of the channel */
 206     unsigned short frequency;
 207
 208     /* Position of the sample currently played */
 209     unsigned int samplepos;
 210
 211     /* Fractual Position of the sample currently player */
 212     unsigned int samplefractpos;
 213
 214     /* Loop Sample */
 215     bool loopsample;
 216
 217     /* Loop Position Start */
 218     unsigned int loopstart;
 219
 220     /* Loop Position End */
 221     unsigned int loopend;
 222
 223     /* Is The channel beeing played? */
 224     bool channelactive;
 225
 226     /* The Volume (0..64) */
 227     signed char volume;
 228
 229     /* The last sampledata beeing played (required for interpolation) */
 230     signed short lastsampledata;
 231 };
 232
 233 struct s_mixer {
 234     /* The channels */
 235     struct s_channel channel[32];
 236 };
 237
 238 struct s_song modsong IDATA_ATTR;               /* The Song */
 239 struct s_modplayer modplayer IDATA_ATTR;        /* The Module Player */
 240 struct s_mixer mixer IDATA_ATTR;
 241
 242 const unsigned short mixingrate = 44100;
 243
 244 STATICIRAM void mixer_playsample(int channel, int instrument) ICODE_ATTR;
 245 void mixer_playsample(int channel, int instrument)
 246 {
 247     struct s_channel *p_channel = &mixer.channel[channel];
 248     struct s_instrument *p_instrument = &modsong.instrument[instrument];
 249
 250     p_channel->channelactive = true;
 251     p_channel->samplepos = p_instrument->sampledataoffset;
 252     p_channel->samplefractpos = 0;
 253     p_channel->loopsample = (p_instrument->repeatlength > 2) ? true : false;
 254     if (p_channel->loopsample) {
 255         p_channel->loopstart = p_instrument->repeatoffset +
 256             p_instrument->sampledataoffset;
 257         p_channel->loopend = p_channel->loopstart +
 258             p_instrument->repeatlength;
 259     }
 260     else p_channel->loopend = p_instrument->length +
 261             p_instrument->sampledataoffset;
 262
 263     /* Remember the instrument */
 264     modplayer.modchannel[channel].instrument = instrument;
 265 }
 266
 267 static inline void mixer_stopsample(int channel)
 268 {
 269     mixer.channel[channel].channelactive = false;
 270 }
 271
 272 static inline void mixer_continuesample(int channel)
 273 {
 274     mixer.channel[channel].channelactive = true;
 275 }
 276
 277 static inline void mixer_setvolume(int channel, int volume)
 278 {
 279     mixer.channel[channel].volume = volume;
 280 }
 281
 282 static inline void mixer_setpanning(int channel, int panning)
 283 {
 284     mixer.channel[channel].panning = panning;
 285 }
 286
 287 static inline void mixer_setamigaperiod(int channel, int amigaperiod)
 288 {
 289     /* Just to make sure we don't devide by zero
 290      * amigaperiod shouldn't 0 anyway - if it is the case
 291      * then something terribly went wrong */
 292     if (amigaperiod == 0)
 293         return;
 294
 295     mixer.channel[channel].frequency = 3579546 / amigaperiod;
 296 }
 297
 298 /* Initialize the MOD Player with default values and precalc tables */
 299 STATICIRAM void initmodplayer(void) ICODE_ATTR;
 300 void initmodplayer(void)
 301 {
 302     unsigned int i,c;
 303
 304     /* Calculate Amiga Period Values
 305      * Start with Period 907 (= C-1 with Finetune -8) and work upwards */
 306     double f = 907.0f;
 307     /* Index 0 stands for no note (and therefore no period) */
 308     modplayer.periodtable[0] = 0;
 309     for (i=1;i<297;i++)
 310     {
 311         modplayer.periodtable[i] = (unsigned short) f;
 312         f /= 1.0072464122237039; /* = pow(2.0f, 1.0f/(12.0f*8.0f)); */
 313     }
 314
 315     /*
 316      * This is a more accurate but also time more consuming approach
 317      * to calculate the amiga period table
 318      * Commented out for speed purposes
 319     const int finetuning = 8;
 320     const int octaves = 3;
 321     for (int halftone=0;halftone<=finetuning*octaves*12+7;halftone++)
 322         {
 323             float e = pow(2.0f, halftone/(12.0f*8.0f));
 324             float f = 906.55f/e;
 325             modplayer.periodtable[halfetone+1] = (int)(f+0.5f);
 326         }
 327     */
 328
 329     /* Calculate Protracker Vibrato sine table
 330      * The routine makes use of the Harmonical Oscillator Approach
 331      * for calculating sine tables
 332      * (see http://membres.lycos.fr/amycoders/tutorials/sintables.html)
 333      * The routine presented here calculates a complete sine wave
 334      * with 64 values in range [-255,255]
 335      */
 336     float a, b, d, dd;
 337
 338     d = 0.09817475f; /* = 2*PI/64 */
 339     dd = d*d;
 340     a = 0;
 341     b = d;
 342
 343     for (i=0;i<0x40;i++)
 344     {
 345         modplayer.sintable[i] = (int)(255*a);
 346
 347         a = a+b;
 348         b = b-dd*a;
 349     }
 350
 351     /* Set Default Player Values */
 352     modplayer.currentline = 0;
 353     modplayer.currenttick = 0;
 354     modplayer.patterntableposition = 0;
 355     modplayer.bpm = 125;
 356     modplayer.ticksperline = 6;
 357     modplayer.glissandoenabled = false;         /* Disable glissando */
 358     modplayer.amigafilterenabled = false;       /* Disable the Amiga Filter */
 359
 360     /* Default Panning Values */
 361     int panningvalues[8] = {4,12,12,4,4,12,12,4};
 362     for (c=0;c<8;c++)
 363     {
 364         /* Set Default Panning */
 365         mixer_setpanning(c, panningvalues[c]);
 366         /* Reset channels in the MOD Player */
 367         memset(&modplayer.modchannel[c], 0, sizeof(struct s_modchannel));
 368         /* Don't play anything */
 369         mixer.channel[c].channelactive = false;
 370     }
 371
 372 }
 373
 374 /* Load the MOD File from memory */
 375 STATICIRAM bool loadmod(void *modfile) ICODE_ATTR;
 376 bool loadmod(void *modfile)
 377 {
 378     int i;
 379     unsigned char *periodsconverted;
 380
 381     /* We don't support PowerPacker 2.0 Files */
 382     if (memcmp((char*) modfile, "PP20", 4) == 0) return false;
 383
 384     /* Get the File Format Tag */
 385     char *fileformattag = (char*)modfile + 1080;
 386
 387     /* Find out how many channels and instruments are used */
 388     if (memcmp(fileformattag, "2CHN", 4) == 0)
 389         {modsong.noofchannels = 2; modsong.noofinstruments = 31;}
 390     else if (memcmp(fileformattag, "M.K.", 4) == 0)
 391         {modsong.noofchannels = 4; modsong.noofinstruments = 31;}
 392     else if (memcmp(fileformattag, "M!K!", 4) == 0)
 393         {modsong.noofchannels = 4; modsong.noofinstruments = 31;}
 394     else if (memcmp(fileformattag, "4CHN", 4) == 0)
 395         {modsong.noofchannels = 4; modsong.noofinstruments = 31;}
 396     else if (memcmp(fileformattag, "FLT4", 4) == 0)
 397         {modsong.noofchannels = 4; modsong.noofinstruments = 31;}
 398     else if (memcmp(fileformattag, "6CHN", 4) == 0)
 399         {modsong.noofchannels = 6; modsong.noofinstruments = 31;}
 400     else if (memcmp(fileformattag, "8CHN", 4) == 0)
 401         {modsong.noofchannels = 8; modsong.noofinstruments = 31;}
 402     else if (memcmp(fileformattag, "OKTA", 4) == 0)
 403         {modsong.noofchannels = 8; modsong.noofinstruments = 31;}
 404     else if (memcmp(fileformattag, "CD81", 4) == 0)
 405         {modsong.noofchannels = 8; modsong.noofinstruments = 31;}
 406     else {
 407         /* The file has no format tag, so most likely soundtracker */
 408         modsong.noofchannels = 4;
 409         modsong.noofinstruments = 15;
 410     }
 411
 412     /* Get the Song title
 413      * Skipped here
 414      * strncpy(modsong.szTitle, (char*)pMODFile, 20); */
 415
 416     /* Get the Instrument information */
 417     for (i=0;i<modsong.noofinstruments;i++)
 418     {
 419         struct s_instrument *instrument = &modsong.instrument[i];
 420         unsigned char *p = (unsigned char *)modfile + 20 + i*30;
 421
 422         /*strncpy(instrument->description, (char*)p, 22); */
 423         p += 22;
 424         instrument->length = (((p[0])<<8) + p[1]) << 1; p+=2;
 425         instrument->finetune = *p++ & 0x0f;
 426         /* Treat finetuning as signed nibble */
 427         if (instrument->finetune > 7) instrument->finetune -= 16;
 428         instrument->volume = *p++;
 429         instrument->repeatoffset = (((p[0])<<8) + p[1]) << 1; p+= 2;
 430         instrument->repeatlength = (((p[0])<<8) + p[1]) << 1;
 431     }
 432
 433     /* Get the pattern information */
 434     unsigned char *p = (unsigned char *)modfile + 20 +
 435         modsong.noofinstruments*30;
 436     modsong.songlength = *p++;
 437     modsong.songendjumpposition = *p++;
 438     modsong.patternordertable = p;
 439
 440     /* Find out how many patterns are used within this song */
 441     int maxpatterns = 0;
 442     for (i=0;i<128;i++)
 443         if (modsong.patternordertable[i] > maxpatterns)
 444             maxpatterns = modsong.patternordertable[i];
 445     maxpatterns++;
 446
 447     /* use 'restartposition' (historically set to 127) which is not used here
 448        as a marker that periods have already been converted */
 449
 450     periodsconverted = (char*)modfile + 20 + modsong.noofinstruments*30 + 1;
 451
 452     /* Get the pattern data; ST doesn't have fileformattag, so 4 bytes less */
 453     modsong.patterndata = periodsconverted +
 454                           (modsong.noofinstruments==15 ? 129 : 133);
 455
 456     /* Convert the period values in the mod file to offsets
 457      * in our periodtable (but only, if we haven't done this yet) */
 458     p = (unsigned char *) modsong.patterndata;
 459     if (*periodsconverted != 0xfe)
 460     {
 461         int note, note2, channel;
 462         for (note=0;note<maxpatterns*64;note++)
 463             for (channel=0;channel<modsong.noofchannels;channel++)
 464             {
 465                 int period = ((p[0] & 0x0f) << 8) | p[1];
 466                 int periodoffset = 0;
 467
 468                 /* Find the offset of the current period */
 469                 for (note2 = 1; note2 < 12*3+1; note2++)
 470                     if (abs(modplayer.periodtable[note2*8+1]-period) < 4)
 471                     {
 472                         periodoffset = note2*8+1;
 473                         break;
 474                     }
 475                 /* Write back the period offset */
 476                 p[0] = (periodoffset >> 8) | (p[0] & 0xf0);
 477                 p[1] = periodoffset & 0xff;
 478                 p += 4;
 479             }
 480         /* Remember that we already converted the periods,
 481          * in case the file gets reloaded by rewinding
 482          * with 0xfe (arbitary magic value > 127) */
 483         *periodsconverted = 0xfe;
 484     }
 485
 486     /* Get the samples
 487      * Calculation: The Samples come after the pattern data
 488      * We know that there are nMaxPatterns and each pattern requires
 489      * 4 bytes per note and per channel.
 490      * And of course there are always lines in each channel */
 491     modsong.sampledata = (signed char*) modsong.patterndata +
 492                           maxpatterns*4*modsong.noofchannels*64;
 493     int sampledataoffset = 0;
 494     for (i=0;i<modsong.noofinstruments;i++)
 495     {
 496         modsong.instrument[i].sampledataoffset = sampledataoffset;
 497         sampledataoffset += modsong.instrument[i].length;
 498     }
 499
 500     return true;
 501 }
 502
 503 /* Apply vibrato to channel */
 504 STATICIRAM void vibrate(int channel) ICODE_ATTR;
 505 void vibrate(int channel)
 506 {
 507     struct s_modchannel *p_modchannel = &modplayer.modchannel[channel];
 508
 509     /* Apply Vibrato
 510      * >> 7 is used in the original protracker source code */
 511     mixer_setamigaperiod(channel, p_modchannel->period+
 512         ((p_modchannel->vibratodepth *
 513         modplayer.sintable[p_modchannel->vibratosinpos])>>7));
 514
 515     /* Foward in Sine Table */
 516     p_modchannel->vibratosinpos += p_modchannel->vibratospeed;
 517     p_modchannel->vibratosinpos &= 0x3f;
 518 }
 519
 520 /* Apply tremolo to channel
 521  * (same as vibrato, but only apply on volume instead of pitch) */
 522 STATICIRAM void tremolo(int channel) ICODE_ATTR;
 523 void tremolo(int channel)
 524 {
 525     struct s_modchannel *p_modchannel = &modplayer.modchannel[channel];
 526
 527     /* Apply Tremolo
 528      * >> 6 is used in the original protracker source code */
 529     int volume = (p_modchannel->volume *
 530         modplayer.sintable[p_modchannel->tremolosinpos])>>6;
 531     if (volume > 64) volume = 64;
 532     else if (volume < 0) volume = 0;
 533     mixer_setvolume(channel, volume);
 534
 535     /* Foward in Sine Table */
 536     p_modchannel->tremolosinpos += p_modchannel->tremolosinpos;
 537     p_modchannel->tremolosinpos &= 0x3f;
 538 }
 539
 540 /* Apply Slide to Note effect to channel */
 541 STATICIRAM void slidetonote(int channel) ICODE_ATTR;
 542 void slidetonote(int channel)
 543 {
 544     struct s_modchannel *p_modchannel = &modplayer.modchannel[channel];
 545
 546     /* If there hasn't been any slide-to note set up, then return */
 547     if (p_modchannel->slidetonoteperiod == 0) return;
 548
 549     /* Slide note up */
 550     if (p_modchannel->slidetonoteperiod > p_modchannel->period)
 551     {
 552         p_modchannel->period += p_modchannel->slidetonotespeed;
 553         if (p_modchannel->period > p_modchannel->slidetonoteperiod)
 554             p_modchannel->period = p_modchannel->slidetonoteperiod;
 555     }
 556     /* Slide note down */
 557     else if (p_modchannel->slidetonoteperiod < p_modchannel->period)
 558     {
 559         p_modchannel->period -= p_modchannel->slidetonotespeed;
 560         if (p_modchannel->period < p_modchannel->slidetonoteperiod)
 561             p_modchannel->period = p_modchannel->slidetonoteperiod;
 562     }
 563     mixer_setamigaperiod(channel, p_modchannel->period);
 564 }
 565
 566 /* Apply Slide to Note effect on channel,
 567  * but this time with glissando enabled */
 568 STATICIRAM void slidetonoteglissando(int channel) ICODE_ATTR;
 569 void slidetonoteglissando(int channel)
 570 {
 571     struct s_modchannel *p_modchannel = &modplayer.modchannel[channel];
 572
 573     /* Slide note up */
 574     if (p_modchannel->slidetonoteperiod > p_modchannel->period)
 575     {
 576         p_modchannel->period =
 577             modplayer.periodtable[p_modchannel->periodtableoffset+=8];
 578         if (p_modchannel->period > p_modchannel->slidetonoteperiod)
 579             p_modchannel->period = p_modchannel->slidetonoteperiod;
 580     }
 581     /* Slide note down */
 582     else
 583     {
 584         p_modchannel->period =
 585             modplayer.periodtable[p_modchannel->periodtableoffset-=8];
 586         if (p_modchannel->period < p_modchannel->slidetonoteperiod)
 587             p_modchannel->period = p_modchannel->slidetonoteperiod;
 588     }
 589     mixer_setamigaperiod(channel, p_modchannel->period);
 590 }
 591
 592 /* Apply Volume Slide */
 593 STATICIRAM void volumeslide(int channel, int effectx, int effecty) ICODE_ATTR;
 594 void volumeslide(int channel, int effectx, int effecty)
 595 {
 596     struct s_modchannel *p_modchannel = &modplayer.modchannel[channel];
 597
 598     /* If both X and Y Parameters are non-zero, then the y value is ignored */
 599     if (effectx > 0) {
 600         p_modchannel->volume += effectx;
 601         if (p_modchannel->volume > 64) p_modchannel->volume = 64;
 602     }
 603     else {
 604         p_modchannel->volume -= effecty;
 605         if (p_modchannel->volume < 0) p_modchannel->volume = 0;
 606     }
 607
 608     mixer_setvolume(channel, p_modchannel->volume);
 609 }
 610
 611 /* Play the current line (at tick 0) */
 612 STATICIRAM void playline(int pattern, int line) ICODE_ATTR;
 613 void playline(int pattern, int line)
 614 {
 615     int c;
 616
 617     /* Get pointer to the current pattern */
 618     unsigned char *p_line = (unsigned char*)modsong.patterndata;
 619     p_line += pattern*64*4*modsong.noofchannels;
 620     p_line += line*4*modsong.noofchannels;
 621
 622     /* Only allow one Patternbreak Commando per Line */
 623     bool patternbreakdone = false;
 624
 625     for (c=0;c<modsong.noofchannels;c++)
 626     {
 627         struct s_modchannel *p_modchannel = &modplayer.modchannel[c];
 628         unsigned char *p_note = p_line + c*4;
 629         unsigned char samplenumber = (p_note[0] & 0xf0) | (p_note[2] >> 4);
 630         short periodtableoffset = ((p_note[0] & 0x0f) << 8) | p_note[1];
 631
 632         p_modchannel->effect = p_note[2] & 0x0f;
 633         p_modchannel->effectparameter = p_note[3];
 634
 635         /* Remember Instrument and set Volume if new Instrument triggered */
 636         if (samplenumber > 0)
 637         {
 638             /* And trigger new sample, if new instrument was set */
 639             if (samplenumber-1 != p_modchannel->instrument)
 640             {
 641                 /* Advance the new sample to the same offset
 642                  * the old sample was beeing played */
 643                 int oldsampleoffset = mixer.channel[c].samplepos -
 644                     modsong.instrument[
 645                     p_modchannel->instrument].sampledataoffset;
 646                 mixer_playsample(c, samplenumber-1);
 647                 mixer.channel[c].samplepos += oldsampleoffset;
 648             }
 649
 650             /* Remember last played instrument on channel */
 651             p_modchannel->instrument = samplenumber-1;
 652
 653             /* Set Volume to standard instrument volume,
 654              * if not overwritten by volume effect */
 655             if (p_modchannel->effect != 0x0c)
 656             {
 657                 p_modchannel->volume = modsong.instrument[
 658                     p_modchannel->instrument].volume;
 659                 mixer_setvolume(c, p_modchannel->volume);
 660             }
 661         }
 662         /* Trigger new sample if note available */
 663         if (periodtableoffset > 0)
 664         {
 665             /* Restart instrument only when new sample triggered */
 666             if (samplenumber != 0)
 667                 mixer_playsample(c, (samplenumber > 0) ?
 668                     samplenumber-1 : p_modchannel->instrument);
 669
 670             /* Set the new amiga period
 671              * (but only, if there is no slide to note effect) */
 672             if ((p_modchannel->effect != 0x3) &&
 673                 (p_modchannel->effect != 0x5))
 674             {
 675                 /* Apply finetuning to sample */
 676                 p_modchannel->periodtableoffset = periodtableoffset +
 677                     modsong.instrument[p_modchannel->instrument].finetune;
 678                 p_modchannel->period = modplayer.periodtable[
 679                     p_modchannel->periodtableoffset];
 680                 mixer_setamigaperiod(c, p_modchannel->period);
 681                 /* When a new note is played without slide to note setup,
 682                  * then disable slide to note */
 683                 modplayer.modchannel[c].slidetonoteperiod =
 684                     p_modchannel->period;
 685             }
 686         }
 687         int effectx = p_modchannel->effectparameter>>4;
 688         int effecty = p_modchannel->effectparameter&0x0f;
 689
 690         switch (p_modchannel->effect)
 691         {
 692             /* Effect 0: Arpeggio */
 693             case 0x00:
 694                 /* Set the base period on tick 0 */
 695                 if (p_modchannel->effectparameter > 0)
 696                     mixer_setamigaperiod(c,
 697                         modplayer.periodtable[
 698                             p_modchannel->periodtableoffset]);
 699                 break;
 700             /* Slide up (Portamento up) */
 701             case 0x01:
 702                 if (p_modchannel->effectparameter > 0)
 703                     p_modchannel->slideupspeed =
 704                         p_modchannel->effectparameter;
 705                 break;
 706
 707             /* Slide down (Portamento down) */
 708             case 0x02:
 709                 if (p_modchannel->effectparameter > 0)
 710                     p_modchannel->slidedownspeed =
 711                         p_modchannel->effectparameter;
 712                 break;
 713
 714             /* Slide to Note */
 715             case 0x03:
 716                 if (p_modchannel->effectparameter > 0)
 717                     p_modchannel->slidetonotespeed =
 718                         p_modchannel->effectparameter;
 719                 /* Get the slide to note directly from the pattern buffer */
 720                 if (periodtableoffset > 0)
 721                     p_modchannel->slidetonoteperiod =
 722                         modplayer.periodtable[periodtableoffset +
 723                         modsong.instrument[
 724                         p_modchannel->instrument].finetune];
 725                 /* If glissando is enabled apply the effect directly here */
 726                 if (modplayer.glissandoenabled)
 727                     slidetonoteglissando(c);
 728                 break;
 729
 730             /* Set Vibrato */
 731             case 0x04:
 732                 if (effectx > 0) p_modchannel->vibratospeed = effectx;
 733                 if (effecty > 0) p_modchannel->vibratodepth = effecty;
 734                 break;
 735
 736             /* Effect 0x06: Slide to note */
 737             case 0x05:
 738                 /* Get the slide to note directly from the pattern buffer */
 739                 if (periodtableoffset > 0)
 740                     p_modchannel->slidetonoteperiod =
 741                         modplayer.periodtable[periodtableoffset +
 742                             modsong.instrument[
 743                             p_modchannel->instrument].finetune];
 744                 break;
 745
 746             /* Effect 0x06 is "Continue Effects" */
 747             /* It is not processed on tick 0 */
 748             case 0x06:
 749                 break;
 750
 751             /* Set Tremolo */
 752             case 0x07:
 753                 if (effectx > 0) p_modchannel->tremolodepth = effectx;
 754                 if (effecty > 0) p_modchannel->tremolospeed = effecty;
 755                 break;
 756
 757             /* Set fine panning */
 758             case 0x08:
 759                 /* Internal panning goes from 0..15
 760                  * Scale the fine panning value to that range */
 761                 mixer.channel[c].panning = p_modchannel->effectparameter>>4;
 762                 break;
 763
 764             /* Set Sample Offset */
 765             case 0x09:
 766                 {
 767                     struct s_instrument *p_instrument =
 768                         &modsong.instrument[p_modchannel->instrument];
 769                     int sampleoffset = p_instrument->sampledataoffset;
 770                     if (sampleoffset > p_instrument->length)
 771                         sampleoffset = p_instrument->length;
 772                     /* Forward the new offset to the mixer */
 773                     mixer.channel[c].samplepos =
 774                         p_instrument->sampledataoffset +
 775                         (p_modchannel->effectparameter<<8);
 776                     mixer.channel[c].samplefractpos = 0;
 777                 break;
 778                 }
 779
 780             /* Effect 0x0a (Volume slide) is not processed on tick 0 */
 781
 782             /* Position Jump */
 783             case 0x0b:
 784                 modplayer.currentline = -1;
 785                 modplayer.patterntableposition = (effectx<<4)+effecty;
 786                 break;
 787
 788             /* Set Volume */
 789             case 0x0c:
 790                 p_modchannel->volume = p_modchannel->effectparameter;
 791                 mixer_setvolume(c, p_modchannel->volume);
 792                 break;
 793
 794             /* Pattern break */
 795             case 0x0d:
 796                 modplayer.currentline = effectx*10 + effecty - 1;
 797                 if (!patternbreakdone)
 798                 {
 799                     patternbreakdone = true;
 800                     modplayer.patterntableposition++;
 801                 }
 802                 break;
 803
 804             /* Extended Effects */
 805             case 0x0e:
 806                 switch (effectx)
 807                 {
 808                     /* Set Filter */
 809                     case 0x0:
 810                         modplayer.amigafilterenabled =
 811                             (effecty>0) ? false : true;
 812                         break;
 813                     /* Fineslide up */
 814                     case 0x1:
 815                         mixer_setamigaperiod(c, p_modchannel->period -=
 816                             effecty);
 817                         if (p_modchannel->period <
 818                             modplayer.periodtable[37*8]) p_modchannel->period = 100;
 819                         /* Find out the new offset in the period table */
 820                         if (p_modchannel->periodtableoffset < 36*8)
 821                             while (modplayer.periodtable[
 822                                 p_modchannel->periodtableoffset+8] >= p_modchannel->period)
 823                                     p_modchannel->periodtableoffset+=8;
 824                         break;
 825                     /* Fineslide down */
 826                     case 0x2:
 827                         mixer_setamigaperiod(c,
 828                             p_modchannel->period += effecty);
 829                         if (p_modchannel->periodtableoffset > 8)
 830                             while (modplayer.periodtable[
 831                                 p_modchannel->periodtableoffset-8]
 832                                 <= p_modchannel->period)
 833                             p_modchannel->periodtableoffset-=8;
 834                         break;
 835                     /* Set glissando on/off */
 836                     case 0x3:
 837                         modplayer.glissandoenabled =
 838                             (effecty > 0) ? true:false;
 839                         break;
 840                     /* Set Vibrato waveform */
 841                     case 0x4:
 842                         /* Currently not implemented */
 843                         break;
 844                     /* Set Finetune value */
 845                     case 0x5:
 846                         /* Treat as signed nibble */
 847                         if (effecty > 7) effecty -= 16;
 848
 849                         p_modchannel->periodtableoffset +=
 850                             effecty -
 851                                 modsong.instrument[
 852                                 p_modchannel->instrument].finetune;
 853                         p_modchannel->period =
 854                             modplayer.periodtable[
 855                             p_modchannel->periodtableoffset];
 856                         modsong.instrument[
 857                             p_modchannel->instrument].finetune = effecty;
 858                         break;
 859                     /* Pattern loop */
 860                     case 0x6:
 861                         if (effecty == 0)
 862                             modplayer.loopstartline = line-1;
 863                         else
 864                         {
 865                             if (modplayer.looptimes == 0)
 866                             {
 867                                 modplayer.currentline =
 868                                     modplayer.loopstartline;
 869                                 modplayer.looptimes = effecty;
 870                             }
 871                             else modplayer.looptimes--;
 872                             if (modplayer.looptimes > 0)
 873                                 modplayer.currentline =
 874                                     modplayer.loopstartline;
 875                         }
 876                         break;
 877                     /* Set Tremolo waveform */
 878                     case 0x7:
 879                         /* Not yet implemented */
 880                         break;
 881                     /* Enhanced Effect 8 is not used */
 882                     case 0x8:
 883                         break;
 884                     /* Retrigger sample */
 885                     case 0x9:
 886                         /* Only processed on subsequent ticks */
 887                         break;
 888                     /* Fine volume slide up */
 889                     case 0xa:
 890                         p_modchannel->volume += effecty;
 891                         if (p_modchannel->volume > 64)
 892                             p_modchannel->volume = 64;
 893                         mixer_setvolume(c, p_modchannel->volume);
 894                         break;
 895                     /* Fine volume slide down */
 896                     case 0xb:
 897                         p_modchannel->volume -= effecty;
 898                         if (p_modchannel->volume < 0)
 899                             p_modchannel->volume = 0;
 900                         mixer_setvolume(c, p_modchannel->volume);
 901                         break;
 902                     /* Cut sample */
 903                     case 0xc:
 904                         /* Continue sample */
 905                         mixer_continuesample(c);
 906                         break;
 907                     /* Note delay (Usage: $ED + ticks to delay note.) */
 908                     case 0xd:
 909                         /* We stop the sample here on tick 0
 910                          * and restart it later in the effect */
 911                         if (effecty > 0)
 912                             mixer.channel[c].channelactive = false;
 913                         break;
 914                 }
 915                 break;
 916
 917             /* Set Speed */
 918             case 0x0f:
 919                 if (p_modchannel->effectparameter < 32)
 920                     modplayer.ticksperline = p_modchannel->effectparameter;
 921                 else
 922                     modplayer.bpm = p_modchannel->effectparameter;
 923                 break;
 924         }
 925     }
 926 }
 927
 928 /* Play the current effect of the note (ticks 1..speed) */
 929 STATICIRAM void playeffect(int currenttick) ICODE_ATTR;
 930 void playeffect(int currenttick)
 931 {
 932     int c;
 933
 934     for (c=0;c<modsong.noofchannels;c++)
 935     {
 936         struct s_modchannel *p_modchannel = &modplayer.modchannel[c];
 937
 938         /* If there is no note active then there are no effects to play */
 939         if (p_modchannel->period == 0) continue;
 940
 941         unsigned char effectx = p_modchannel->effectparameter>>4;
 942         unsigned char effecty = p_modchannel->effectparameter&0x0f;
 943
 944         switch (p_modchannel->effect)
 945         {
 946             /* Effect 0: Arpeggio */
 947             case 0x00:
 948                 if (p_modchannel->effectparameter > 0)
 949                 {
 950                     unsigned short newperiodtableoffset;
 951                     switch (currenttick % 3)
 952                     {
 953                         case 0:
 954                             mixer_setamigaperiod(c,
 955                                 modplayer.periodtable[
 956                                     p_modchannel->periodtableoffset]);
 957                             break;
 958                         case 1:
 959                             newperiodtableoffset =
 960                                 p_modchannel->periodtableoffset+(effectx<<3);
 961                             if (newperiodtableoffset < 37*8)
 962                                 mixer_setamigaperiod(c,
 963                                     modplayer.periodtable[
 964                                         newperiodtableoffset]);
 965                             break;
 966                         case 2:
 967                             newperiodtableoffset =
 968                                 p_modchannel->periodtableoffset+(effecty<<3);
 969                             if (newperiodtableoffset < 37*8)
 970                                 mixer_setamigaperiod(c,
 971                                     modplayer.periodtable[
 972                                         newperiodtableoffset]);
 973                             break;
 974                     }
 975                 }
 976                 break;
 977
 978             /* Effect 1: Slide Up */
 979             case 0x01:
 980                 mixer_setamigaperiod(c,
 981                     p_modchannel->period -= p_modchannel->slideupspeed);
 982                 /* Find out the new offset in the period table */
 983                 if (p_modchannel->periodtableoffset <= 37*8)
 984                     while (modplayer.periodtable[
 985                         p_modchannel->periodtableoffset] >
 986                         p_modchannel->period)
 987                     {
 988                         p_modchannel->periodtableoffset++;
 989                         /* Make sure we don't go out of range */
 990                         if (p_modchannel->periodtableoffset > 37*8)
 991                         {
 992                             p_modchannel->periodtableoffset = 37*8;
 993                             break;
 994                         }
 995                     }
 996                 break;
 997
 998             /* Effect 2: Slide Down */
 999             case 0x02:
1000                 mixer_setamigaperiod(c, p_modchannel->period +=
1001                     p_modchannel->slidedownspeed);
1002                 /* Find out the new offset in the period table */
1003                 if (p_modchannel->periodtableoffset > 8)
1004                     while (modplayer.periodtable[
1005                         p_modchannel->periodtableoffset] <
1006                         p_modchannel->period)
1007                     {
1008                         p_modchannel->periodtableoffset--;
1009                         /* Make sure we don't go out of range */
1010                         if (p_modchannel->periodtableoffset < 1)
1011                         {
1012                             p_modchannel->periodtableoffset = 1;
1013                             break;
1014                         }
1015                     }
1016                 break;
1017
1018             /* Effect 3: Slide to Note */
1019             case 0x03:
1020                 /* Apply smooth sliding, if no glissando is enabled */
1021                 if (modplayer.glissandoenabled == 0)
1022                     slidetonote(c);
1023                 break;
1024
1025             /* Effect 4: Vibrato */
1026             case 0x04:
1027                 vibrate(c);
1028                 break;
1029
1030             /* Effect 5: Continue effect 3:'Slide to note',
1031              *           but also do Volume slide */
1032             case 0x05:
1033                 slidetonote(c);
1034                 volumeslide(c, effectx, effecty);
1035                 break;
1036
1037             /* Effect 6: Continue effect 4:'Vibrato',
1038              *           but also do Volume slide */
1039             case 0x06:
1040                 vibrate(c);
1041                 volumeslide(c, effectx, effecty);
1042                 break;
1043
1044             /* Effect 7: Tremolo */
1045             case 0x07:
1046                 tremolo(c);
1047                 break;
1048
1049             /* Effect 8 (Set fine panning) is only processed at tick 0 */
1050             /* Effect 9 (Set sample offset) is only processed at tick 0 */
1051
1052             /* Effect A: Volume slide */
1053             case 0x0a:
1054                 volumeslide(c, effectx, effecty);
1055                 break;
1056
1057             /* Effect B (Position jump) is only processed at tick 0 */
1058             /* Effect C (Set Volume) is only processed at tick 0 */
1059             /* Effect D (Pattern Preak) is only processed at tick 0 */
1060             /* Effect E (Enhanced Effect) */
1061             case 0x0e:
1062                 switch (effectx)
1063                 {
1064                     /* Retrigger sample ($E9 + Tick to Retrig note at) */
1065                     case 0x9:
1066                         /* Don't device by zero */
1067                         if (effecty == 0) effecty = 1;
1068                         /* Apply retrig */
1069                         if (currenttick % effecty == 0)
1070                             mixer_playsample(c, p_modchannel->instrument);
1071                         break;
1072                     /* Cut note (Usage: $EC + Tick to Cut note at) */
1073                     case 0xc:
1074                         if (currenttick == effecty)
1075                         mixer_stopsample(c);
1076                         break;
1077                     /* Delay note (Usage: $ED + ticks to delay note) */
1078                     case 0xd:
1079                         /* If this is the correct tick,
1080                          * we start playing the sample now */
1081                         if (currenttick == effecty)
1082                             mixer.channel[c].channelactive = true;
1083                         break;
1084
1085                 }
1086                 break;
1087             /* Effect F (Set Speed) is only processed at tick 0 */
1088
1089         }
1090     }
1091 }
1092
1093 static inline int clip(int i)
1094 {
1095     if (i > 32767) return(32767);
1096     else if (i < -32768) return(-32768);
1097     else return(i);
1098 }
1099
1100 STATICIRAM void synthrender(void *renderbuffer, int samplecount) ICODE_ATTR;
1101 void synthrender(void *renderbuffer, int samplecount)
1102 {
1103     /* 125bpm equals to 50Hz (= 0.02s)
1104      * => one tick = mixingrate/50,
1105      * samples passing in one tick:
1106      * mixingrate/(bpm/2.5) = 2.5*mixingrate/bpm */
1107
1108     int *p_left = (int *) renderbuffer; /* int in rockbox */
1109     int *p_right = p_left+1;
1110     signed short s;
1111     int qf_distance, qf_distance2;
1112
1113     int i;
1114
1115     int c, left, right;
1116
1117     for (i=0;i<samplecount;i++)
1118     {
1119         /* New Tick? */
1120         if ((modplayer.samplespertick-- <= 0) &&
1121             (modplayer.patterntableposition < 127))
1122         {
1123             if (modplayer.currenttick == 0)
1124                 playline(modsong.patternordertable[
1125                     modplayer.patterntableposition], modplayer.currentline);
1126             else playeffect(modplayer.currenttick);
1127
1128             modplayer.currenttick++;
1129
1130             if (modplayer.currenttick >= modplayer.ticksperline)
1131             {
1132                 modplayer.currentline++;
1133                 modplayer.currenttick = 0;
1134                 if (modplayer.currentline == 64)
1135                 {
1136                     modplayer.patterntableposition++;
1137                     if (modplayer.patterntableposition >= modsong.songlength)
1138                         /* This is for Noise Tracker
1139                          * modplayer.patterntableposition =
1140                          *    modsong.songendjumpposition;
1141                          * More compatible approach is restart from 0 */
1142                         modplayer.patterntableposition=0;
1143                     modplayer.currentline = 0;
1144                 }
1145             }
1146
1147             modplayer.samplespertick = (20*mixingrate/modplayer.bpm)>>3;
1148         }
1149         /* Mix buffers from here
1150          * Walk through all channels */
1151         left=0, right=0;
1152
1153         /* If song has not stopped playing */
1154         if (modplayer.patterntableposition < 127)
1155             /* Loop through all channels */
1156             for (c=0;c<modsong.noofchannels;c++)
1157             {
1158                 /* Only mix the sample,
1159                  * if channel there is something played on the channel */
1160                 if (!mixer.channel[c].channelactive) continue;
1161
1162                 /* Loop the sample, if requested? */
1163                 if (mixer.channel[c].samplepos >= mixer.channel[c].loopend)
1164                 {
1165                     if (mixer.channel[c].loopsample)
1166                         mixer.channel[c].samplepos -=
1167                             (mixer.channel[c].loopend-
1168                             mixer.channel[c].loopstart);
1169                     else mixer.channel[c].channelactive = false;
1170                 }
1171
1172                 /* If the sample has stopped playing don't mix it */
1173                 if (!mixer.channel[c].channelactive) continue;
1174
1175                 /* Get the sample */
1176                 s = (signed short)(modsong.sampledata[
1177                     mixer.channel[c].samplepos]*mixer.channel[c].volume);
1178
1179                 /* Interpolate if the sample-frequency is lower
1180                  * than the mixing rate
1181                  * If you don't want interpolation simply skip this part */
1182                 if (mixer.channel[c].frequency < mixingrate)
1183                 {
1184                     /* Low precision linear interpolation
1185                      * (fast integer based) */
1186                     qf_distance = mixer.channel[c].samplefractpos<<16 /
1187                                     mixingrate;
1188                     qf_distance2 = (1<<16)-qf_distance;
1189                     s = (qf_distance*s + qf_distance2*
1190                         mixer.channel[c].lastsampledata)>>16;
1191                 }
1192
1193                 /* Save the last played sample for interpolation purposes */
1194                 mixer.channel[c].lastsampledata = s;
1195
1196                 /* Pan the sample */
1197                 left += s*(16-mixer.channel[c].panning)>>3;
1198                 right += s*mixer.channel[c].panning>>3;
1199
1200                 /* Advance sample */
1201                 mixer.channel[c].samplefractpos += mixer.channel[c].frequency;
1202                 while (mixer.channel[c].samplefractpos > mixingrate)
1203                 {
1204                     mixer.channel[c].samplefractpos -= mixingrate;
1205                     mixer.channel[c].samplepos++;
1206                 }
1207             }
1208         /* If we have more than 4 channels
1209          * we have to make sure that we apply clipping */
1210         if (modsong.noofchannels > 4) {
1211             *p_left = clip(left)<<13;
1212             *p_right = clip(right)<<13;
1213         }
1214         else {
1215             *p_left = left<<13;
1216             *p_right = right<<13;
1217         }
1218         p_left+=2;
1219         p_right+=2;
1220     }
1221 }
1222
1223
1224 enum codec_status codec_main(void)
1225 {
1226     size_t n;
1227     unsigned char *modfile;
1228     int old_patterntableposition;
1229
1230     int bytesdone;
1231
1232 next_track:
1233     if (codec_init()) {
1234         return CODEC_ERROR;
1235     }
1236
1237     while (!*ci->taginfo_ready && !ci->stop_codec)
1238         ci->sleep(1);
1239
1240     codec_set_replaygain(ci->id3);
1241
1242     /* Load MOD file */
1243     /*
1244      * This is the save way
1245
1246     size_t bytesfree;
1247     unsigned int filesize;
1248
1249     p = modfile;
1250     bytesfree=sizeof(modfile);
1251     while ((n = ci->read_filebuf(p, bytesfree)) > 0) {
1252         p += n;
1253         bytesfree -= n;
1254         if (bytesfree == 0)
1255            return CODEC_ERROR;
1256     }
1257     filesize = p-modfile;
1258
1259     if (filesize == 0)
1260         return CODEC_ERROR;
1261     */
1262
1263     /* Directly use mod in buffer */
1264     ci->seek_buffer(0);
1265     modfile = ci->request_buffer(&n, ci->filesize);
1266     if (!modfile || n < (size_t)ci->filesize) {
1267         return CODEC_ERROR;
1268     }
1269
1270     initmodplayer();
1271     loadmod(modfile);
1272
1273     /* Make use of 44.1khz */
1274     ci->configure(DSP_SET_FREQUENCY, 44100);
1275     /* Sample depth is 28 bit host endian */
1276     ci->configure(DSP_SET_SAMPLE_DEPTH, 28);
1277     /* Stereo output */
1278     ci->configure(DSP_SET_STEREO_MODE, STEREO_INTERLEAVED);
1279
1280     /* The main decoder loop */
1281     ci->set_elapsed(0);
1282     bytesdone = 0;
1283     old_patterntableposition = 0;
1284
1285     while (1) {
1286         ci->yield();
1287         if (ci->stop_codec || ci->new_track)
1288             break;
1289
1290         if (ci->seek_time) {
1291             /* New time is ready in ci->seek_time */
1292             modplayer.patterntableposition = ci->seek_time/1000;
1293             modplayer.currentline = 0;
1294             ci->seek_complete();
1295         }
1296
1297         if(old_patterntableposition != modplayer.patterntableposition) {
1298           ci->set_elapsed(modplayer.patterntableposition*1000+500);
1299           old_patterntableposition=modplayer.patterntableposition;
1300         }
1301
1302         synthrender(samples, CHUNK_SIZE/2);
1303
1304         bytesdone += CHUNK_SIZE;
1305
1306         ci->pcmbuf_insert(samples, NULL, CHUNK_SIZE/2);
1307
1308     }
1309
1310     if (ci->request_next_track())
1311         goto next_track;
1312
1313     return CODEC_OK;
1314 }