jar_mod.h (51991B)
1 // jar_mod.h - v0.01 - public domain C0 - Joshua Reisenauer 2 // 3 // HISTORY: 4 // 5 // v0.01 2016-03-12 Setup 6 // 7 // 8 // USAGE: 9 // 10 // In ONE source file, put: 11 // 12 // #define JAR_MOD_IMPLEMENTATION 13 // #include "jar_mod.h" 14 // 15 // Other source files should just include jar_mod.h 16 // 17 // SAMPLE CODE: 18 // jar_mod_context_t modctx; 19 // short samplebuff[4096]; 20 // bool bufferFull = false; 21 // int intro_load(void) 22 // { 23 // jar_mod_init(&modctx); 24 // jar_mod_load_file(&modctx, "file.mod"); 25 // return 1; 26 // } 27 // int intro_unload(void) 28 // { 29 // jar_mod_unload(&modctx); 30 // return 1; 31 // } 32 // int intro_tick(long counter) 33 // { 34 // if(!bufferFull) 35 // { 36 // jar_mod_fillbuffer(&modctx, samplebuff, 4096, 0); 37 // bufferFull=true; 38 // } 39 // if(IsKeyDown(KEY_ENTER)) 40 // return 1; 41 // return 0; 42 // } 43 // 44 // 45 // LISCENSE: 46 // 47 // Written by: Jean-François DEL NERO (http://hxc2001.com/) <Email : jeanfrancoisdelnero <> free.fr> 48 // Adapted to jar_mod by: Joshua Adam Reisenauer <kd7tck@gmail.com> 49 // This program is free software. It comes without any warranty, to the 50 // extent permitted by applicable law. You can redistribute it and/or 51 // modify it under the terms of the Do What The Fuck You Want To Public 52 // License, Version 2, as published by Sam Hocevar. See 53 // http://sam.zoy.org/wtfpl/COPYING for more details. 54 /////////////////////////////////////////////////////////////////////////////////// 55 // HxCMOD Core API: 56 // ------------------------------------------- 57 // int jar_mod_init(jar_mod_context_t * modctx) 58 // 59 // - Initialize the jar_mod_context_t buffer. Must be called before doing anything else. 60 // Return 1 if success. 0 in case of error. 61 // ------------------------------------------- 62 // mulong jar_mod_load_file(jar_mod_context_t * modctx, const char* filename) 63 // 64 // - "Load" a MOD from file, context must already be initialized. 65 // Return size of file in bytes. 66 // ------------------------------------------- 67 // void jar_mod_fillbuffer( jar_mod_context_t * modctx, short * outbuffer, unsigned long nbsample, jar_mod_tracker_buffer_state * trkbuf ) 68 // 69 // - Generate and return the next samples chunk to outbuffer. 70 // nbsample specify the number of stereo 16bits samples you want. 71 // The output format is by default signed 48000Hz 16-bit Stereo PCM samples, otherwise it is changed with jar_mod_setcfg(). 72 // The output buffer size in bytes must be equal to ( nbsample * 2 * channels ). 73 // The optional trkbuf parameter can be used to get detailed status of the player. Put NULL/0 is unused. 74 // ------------------------------------------- 75 // void jar_mod_unload( jar_mod_context_t * modctx ) 76 // - "Unload" / clear the player status. 77 // ------------------------------------------- 78 /////////////////////////////////////////////////////////////////////////////////// 79 80 81 #ifndef INCLUDE_JAR_MOD_H 82 #define INCLUDE_JAR_MOD_H 83 84 // Allow custom memory allocators 85 #ifndef JARMOD_MALLOC 86 #define JARMOD_MALLOC(sz) malloc(sz) 87 #endif 88 #ifndef JARMOD_FREE 89 #define JARMOD_FREE(p) free(p) 90 #endif 91 92 93 // Basic type 94 typedef unsigned char muchar; 95 typedef unsigned short muint; 96 typedef short mint; 97 typedef unsigned long mulong; 98 99 #define NUMMAXCHANNELS 32 100 #define MAXNOTES 12*12 101 #define DEFAULT_SAMPLE_RATE 48000 102 // 103 // MOD file structures 104 // 105 106 #pragma pack(1) 107 108 typedef struct { 109 muchar name[22]; 110 muint length; 111 muchar finetune; 112 muchar volume; 113 muint reppnt; 114 muint replen; 115 } sample; 116 117 typedef struct { 118 muchar sampperiod; 119 muchar period; 120 muchar sampeffect; 121 muchar effect; 122 } note; 123 124 typedef struct { 125 muchar title[20]; 126 sample samples[31]; 127 muchar length; // length of tablepos 128 muchar protracker; 129 muchar patterntable[128]; 130 muchar signature[4]; 131 muchar speed; 132 } module; 133 134 #pragma pack() 135 136 // 137 // HxCMod Internal structures 138 // 139 typedef struct { 140 char* sampdata; 141 muint sampnum; 142 muint length; 143 muint reppnt; 144 muint replen; 145 mulong samppos; 146 muint period; 147 muchar volume; 148 mulong ticks; 149 muchar effect; 150 muchar parameffect; 151 muint effect_code; 152 mint decalperiod; 153 mint portaspeed; 154 mint portaperiod; 155 mint vibraperiod; 156 mint Arpperiods[3]; 157 muchar ArpIndex; 158 mint oldk; 159 muchar volumeslide; 160 muchar vibraparam; 161 muchar vibrapointeur; 162 muchar finetune; 163 muchar cut_param; 164 muint patternloopcnt; 165 muint patternloopstartpoint; 166 } channel; 167 168 typedef struct { 169 module song; 170 char* sampledata[31]; 171 note* patterndata[128]; 172 173 mulong playrate; 174 muint tablepos; 175 muint patternpos; 176 muint patterndelay; 177 muint jump_loop_effect; 178 muchar bpm; 179 mulong patternticks; 180 mulong patterntickse; 181 mulong patternticksaim; 182 mulong sampleticksconst; 183 mulong samplenb; 184 channel channels[NUMMAXCHANNELS]; 185 muint number_of_channels; 186 muint fullperiod[MAXNOTES * 8]; 187 muint mod_loaded; 188 mint last_r_sample; 189 mint last_l_sample; 190 mint stereo; 191 mint stereo_separation; 192 mint bits; 193 mint filter; 194 195 muchar *modfile; // the raw mod file 196 mulong modfilesize; 197 muint loopcount; 198 } jar_mod_context_t; 199 200 // 201 // Player states structures 202 // 203 typedef struct track_state_ 204 { 205 unsigned char instrument_number; 206 unsigned short cur_period; 207 unsigned char cur_volume; 208 unsigned short cur_effect; 209 unsigned short cur_parameffect; 210 }track_state; 211 212 typedef struct tracker_state_ 213 { 214 int number_of_tracks; 215 int bpm; 216 int speed; 217 int cur_pattern; 218 int cur_pattern_pos; 219 int cur_pattern_table_pos; 220 unsigned int buf_index; 221 track_state tracks[32]; 222 }tracker_state; 223 224 typedef struct tracker_state_instrument_ 225 { 226 char name[22]; 227 int active; 228 }tracker_state_instrument; 229 230 typedef struct jar_mod_tracker_buffer_state_ 231 { 232 int nb_max_of_state; 233 int nb_of_state; 234 int cur_rd_index; 235 int sample_step; 236 char name[64]; 237 tracker_state_instrument instruments[31]; 238 tracker_state * track_state_buf; 239 }jar_mod_tracker_buffer_state; 240 241 #ifdef __cplusplus 242 extern "C" { 243 #endif 244 245 bool jar_mod_init(jar_mod_context_t * modctx); 246 bool jar_mod_setcfg(jar_mod_context_t * modctx, int samplerate, int bits, int stereo, int stereo_separation, int filter); 247 void jar_mod_fillbuffer(jar_mod_context_t * modctx, short * outbuffer, unsigned long nbsample, jar_mod_tracker_buffer_state * trkbuf); 248 void jar_mod_unload(jar_mod_context_t * modctx); 249 mulong jar_mod_load_file(jar_mod_context_t * modctx, const char* filename); 250 mulong jar_mod_current_samples(jar_mod_context_t * modctx); 251 mulong jar_mod_max_samples(jar_mod_context_t * modctx); 252 void jar_mod_seek_start(jar_mod_context_t * ctx); 253 254 #ifdef __cplusplus 255 } 256 #endif 257 //-------------------------------------------------------------------- 258 259 260 261 //------------------------------------------------------------------------------- 262 #ifdef JAR_MOD_IMPLEMENTATION 263 264 #include <stdio.h> 265 #include <stdlib.h> 266 //#include <stdbool.h> 267 268 // Effects list 269 #define EFFECT_ARPEGGIO 0x0 // Supported 270 #define EFFECT_PORTAMENTO_UP 0x1 // Supported 271 #define EFFECT_PORTAMENTO_DOWN 0x2 // Supported 272 #define EFFECT_TONE_PORTAMENTO 0x3 // Supported 273 #define EFFECT_VIBRATO 0x4 // Supported 274 #define EFFECT_VOLSLIDE_TONEPORTA 0x5 // Supported 275 #define EFFECT_VOLSLIDE_VIBRATO 0x6 // Supported 276 #define EFFECT_VOLSLIDE_TREMOLO 0x7 // - TO BE DONE - 277 #define EFFECT_SET_PANNING 0x8 // - TO BE DONE - 278 #define EFFECT_SET_OFFSET 0x9 // Supported 279 #define EFFECT_VOLUME_SLIDE 0xA // Supported 280 #define EFFECT_JUMP_POSITION 0xB // Supported 281 #define EFFECT_SET_VOLUME 0xC // Supported 282 #define EFFECT_PATTERN_BREAK 0xD // Supported 283 284 #define EFFECT_EXTENDED 0xE 285 #define EFFECT_E_FINE_PORTA_UP 0x1 // Supported 286 #define EFFECT_E_FINE_PORTA_DOWN 0x2 // Supported 287 #define EFFECT_E_GLISSANDO_CTRL 0x3 // - TO BE DONE - 288 #define EFFECT_E_VIBRATO_WAVEFORM 0x4 // - TO BE DONE - 289 #define EFFECT_E_SET_FINETUNE 0x5 // - TO BE DONE - 290 #define EFFECT_E_PATTERN_LOOP 0x6 // Supported 291 #define EFFECT_E_TREMOLO_WAVEFORM 0x7 // - TO BE DONE - 292 #define EFFECT_E_SET_PANNING_2 0x8 // - TO BE DONE - 293 #define EFFECT_E_RETRIGGER_NOTE 0x9 // - TO BE DONE - 294 #define EFFECT_E_FINE_VOLSLIDE_UP 0xA // Supported 295 #define EFFECT_E_FINE_VOLSLIDE_DOWN 0xB // Supported 296 #define EFFECT_E_NOTE_CUT 0xC // Supported 297 #define EFFECT_E_NOTE_DELAY 0xD // - TO BE DONE - 298 #define EFFECT_E_PATTERN_DELAY 0xE // Supported 299 #define EFFECT_E_INVERT_LOOP 0xF // - TO BE DONE - 300 #define EFFECT_SET_SPEED 0xF0 // Supported 301 #define EFFECT_SET_TEMPO 0xF2 // Supported 302 303 #define PERIOD_TABLE_LENGTH MAXNOTES 304 #define FULL_PERIOD_TABLE_LENGTH ( PERIOD_TABLE_LENGTH * 8 ) 305 306 static const short periodtable[]= 307 { 308 27392, 25856, 24384, 23040, 21696, 20480, 19328, 18240, 17216, 16256, 15360, 14496, 309 13696, 12928, 12192, 11520, 10848, 10240, 9664, 9120, 8606, 8128, 7680, 7248, 310 6848, 6464, 6096, 5760, 5424, 5120, 4832, 4560, 4304, 4064, 3840, 3624, 311 3424, 3232, 3048, 2880, 2712, 2560, 2416, 2280, 2152, 2032, 1920, 1812, 312 1712, 1616, 1524, 1440, 1356, 1280, 1208, 1140, 1076, 1016, 960, 906, 313 856, 808, 762, 720, 678, 640, 604, 570, 538, 508, 480, 453, 314 428, 404, 381, 360, 339, 320, 302, 285, 269, 254, 240, 226, 315 214, 202, 190, 180, 170, 160, 151, 143, 135, 127, 120, 113, 316 107, 101, 95, 90, 85, 80, 75, 71, 67, 63, 60, 56, 317 53, 50, 47, 45, 42, 40, 37, 35, 33, 31, 30, 28, 318 27, 25, 24, 22, 21, 20, 19, 18, 17, 16, 15, 14, 319 13, 13, 12, 11, 11, 10, 9, 9, 8, 8, 7, 7 320 }; 321 322 static const short sintable[]={ 323 0, 24, 49, 74, 97, 120, 141,161, 324 180, 197, 212, 224, 235, 244, 250,253, 325 255, 253, 250, 244, 235, 224, 212,197, 326 180, 161, 141, 120, 97, 74, 49, 24 327 }; 328 329 typedef struct modtype_ 330 { 331 unsigned char signature[5]; 332 int numberofchannels; 333 }modtype; 334 335 modtype modlist[]= 336 { 337 { "M!K!",4}, 338 { "M.K.",4}, 339 { "FLT4",4}, 340 { "FLT8",8}, 341 { "4CHN",4}, 342 { "6CHN",6}, 343 { "8CHN",8}, 344 { "10CH",10}, 345 { "12CH",12}, 346 { "14CH",14}, 347 { "16CH",16}, 348 { "18CH",18}, 349 { "20CH",20}, 350 { "22CH",22}, 351 { "24CH",24}, 352 { "26CH",26}, 353 { "28CH",28}, 354 { "30CH",30}, 355 { "32CH",32}, 356 { "",0} 357 }; 358 359 /////////////////////////////////////////////////////////////////////////////////// 360 361 static void memcopy( void * dest, void *source, unsigned long size ) 362 { 363 unsigned long i; 364 unsigned char * d,*s; 365 366 d=(unsigned char*)dest; 367 s=(unsigned char*)source; 368 for(i=0;i<size;i++) 369 { 370 d[i]=s[i]; 371 } 372 } 373 374 static void memclear( void * dest, unsigned char value, unsigned long size ) 375 { 376 unsigned long i; 377 unsigned char * d; 378 379 d=(unsigned char*)dest; 380 for(i=0;i<size;i++) 381 { 382 d[i]=value; 383 } 384 } 385 386 static int memcompare( unsigned char * buf1, unsigned char * buf2, unsigned int size ) 387 { 388 unsigned int i; 389 390 i = 0; 391 392 while(i<size) 393 { 394 if(buf1[i] != buf2[i]) 395 { 396 return 0; 397 } 398 i++; 399 } 400 401 return 1; 402 } 403 404 static int getnote( jar_mod_context_t * mod, unsigned short period, int finetune ) 405 { 406 int i; 407 408 for(i = 0; i < FULL_PERIOD_TABLE_LENGTH; i++) 409 { 410 if(period >= mod->fullperiod[i]) 411 { 412 return i; 413 } 414 } 415 416 return MAXNOTES; 417 } 418 419 static void worknote( note * nptr, channel * cptr, char t, jar_mod_context_t * mod ) 420 { 421 muint sample, period, effect, operiod; 422 muint curnote, arpnote; 423 424 sample = (nptr->sampperiod & 0xF0) | (nptr->sampeffect >> 4); 425 period = ((nptr->sampperiod & 0xF) << 8) | nptr->period; 426 effect = ((nptr->sampeffect & 0xF) << 8) | nptr->effect; 427 428 operiod = cptr->period; 429 430 if ( period || sample ) 431 { 432 if( sample && sample < 32 ) 433 { 434 cptr->sampnum = sample - 1; 435 } 436 437 if( period || sample ) 438 { 439 cptr->sampdata = (char *) mod->sampledata[cptr->sampnum]; 440 cptr->length = mod->song.samples[cptr->sampnum].length; 441 cptr->reppnt = mod->song.samples[cptr->sampnum].reppnt; 442 cptr->replen = mod->song.samples[cptr->sampnum].replen; 443 444 cptr->finetune = (mod->song.samples[cptr->sampnum].finetune)&0xF; 445 446 if(effect>>8!=4 && effect>>8!=6) 447 { 448 cptr->vibraperiod=0; 449 cptr->vibrapointeur=0; 450 } 451 } 452 453 if( (sample != 0) && ( (effect>>8) != EFFECT_VOLSLIDE_TONEPORTA ) ) 454 { 455 cptr->volume = mod->song.samples[cptr->sampnum].volume; 456 cptr->volumeslide = 0; 457 } 458 459 if( ( (effect>>8) != EFFECT_TONE_PORTAMENTO && (effect>>8)!=EFFECT_VOLSLIDE_TONEPORTA) ) 460 { 461 if (period!=0) 462 cptr->samppos = 0; 463 } 464 465 cptr->decalperiod = 0; 466 if( period ) 467 { 468 if(cptr->finetune) 469 { 470 if( cptr->finetune <= 7 ) 471 { 472 period = mod->fullperiod[getnote(mod,period,0) + cptr->finetune]; 473 } 474 else 475 { 476 period = mod->fullperiod[getnote(mod,period,0) - (16 - (cptr->finetune)) ]; 477 } 478 } 479 480 cptr->period = period; 481 } 482 483 } 484 485 cptr->effect = 0; 486 cptr->parameffect = 0; 487 cptr->effect_code = effect; 488 489 switch (effect >> 8) 490 { 491 case EFFECT_ARPEGGIO: 492 /* 493 [0]: Arpeggio 494 Where [0][x][y] means "play note, note+x semitones, note+y 495 semitones, then return to original note". The fluctuations are 496 carried out evenly spaced in one pattern division. They are usually 497 used to simulate chords, but this doesn't work too well. They are 498 also used to produce heavy vibrato. A major chord is when x=4, y=7. 499 A minor chord is when x=3, y=7. 500 */ 501 502 if(effect&0xff) 503 { 504 cptr->effect = EFFECT_ARPEGGIO; 505 cptr->parameffect = effect&0xff; 506 507 cptr->ArpIndex = 0; 508 509 curnote = getnote(mod,cptr->period,cptr->finetune); 510 511 cptr->Arpperiods[0] = cptr->period; 512 513 arpnote = curnote + (((cptr->parameffect>>4)&0xF)*8); 514 if( arpnote >= FULL_PERIOD_TABLE_LENGTH ) 515 arpnote = FULL_PERIOD_TABLE_LENGTH - 1; 516 517 cptr->Arpperiods[1] = mod->fullperiod[arpnote]; 518 519 arpnote = curnote + (((cptr->parameffect)&0xF)*8); 520 if( arpnote >= FULL_PERIOD_TABLE_LENGTH ) 521 arpnote = FULL_PERIOD_TABLE_LENGTH - 1; 522 523 cptr->Arpperiods[2] = mod->fullperiod[arpnote]; 524 } 525 break; 526 527 case EFFECT_PORTAMENTO_UP: 528 /* 529 [1]: Slide up 530 Where [1][x][y] means "smoothly decrease the period of current 531 sample by x*16+y after each tick in the division". The 532 ticks/division are set with the 'set speed' effect (see below). If 533 the period of the note being played is z, then the final period 534 will be z - (x*16 + y)*(ticks - 1). As the slide rate depends on 535 the speed, changing the speed will change the slide. You cannot 536 slide beyond the note B3 (period 113). 537 */ 538 539 cptr->effect = EFFECT_PORTAMENTO_UP; 540 cptr->parameffect = effect&0xff; 541 break; 542 543 case EFFECT_PORTAMENTO_DOWN: 544 /* 545 [2]: Slide down 546 Where [2][x][y] means "smoothly increase the period of current 547 sample by x*16+y after each tick in the division". Similar to [1], 548 but lowers the pitch. You cannot slide beyond the note C1 (period 549 856). 550 */ 551 552 cptr->effect = EFFECT_PORTAMENTO_DOWN; 553 cptr->parameffect = effect&0xff; 554 break; 555 556 case EFFECT_TONE_PORTAMENTO: 557 /* 558 [3]: Slide to note 559 Where [3][x][y] means "smoothly change the period of current sample 560 by x*16+y after each tick in the division, never sliding beyond 561 current period". The period-length in this channel's division is a 562 parameter to this effect, and hence is not played. Sliding to a 563 note is similar to effects [1] and [2], but the slide will not go 564 beyond the given period, and the direction is implied by that 565 period. If x and y are both 0, then the old slide will continue. 566 */ 567 568 cptr->effect = EFFECT_TONE_PORTAMENTO; 569 if( (effect&0xff) != 0 ) 570 { 571 cptr->portaspeed = (short)(effect&0xff); 572 } 573 574 if(period!=0) 575 { 576 cptr->portaperiod = period; 577 cptr->period = operiod; 578 } 579 break; 580 581 case EFFECT_VIBRATO: 582 /* 583 [4]: Vibrato 584 Where [4][x][y] means "oscillate the sample pitch using a 585 particular waveform with amplitude y/16 semitones, such that (x * 586 ticks)/64 cycles occur in the division". The waveform is set using 587 effect [14][4]. By placing vibrato effects on consecutive 588 divisions, the vibrato effect can be maintained. If either x or y 589 are 0, then the old vibrato values will be used. 590 */ 591 592 cptr->effect = EFFECT_VIBRATO; 593 if( ( effect & 0x0F ) != 0 ) // Depth continue or change ? 594 cptr->vibraparam = (cptr->vibraparam & 0xF0) | ( effect & 0x0F ); 595 if( ( effect & 0xF0 ) != 0 ) // Speed continue or change ? 596 cptr->vibraparam = (cptr->vibraparam & 0x0F) | ( effect & 0xF0 ); 597 598 break; 599 600 case EFFECT_VOLSLIDE_TONEPORTA: 601 /* 602 [5]: Continue 'Slide to note', but also do Volume slide 603 Where [5][x][y] means "either slide the volume up x*(ticks - 1) or 604 slide the volume down y*(ticks - 1), at the same time as continuing 605 the last 'Slide to note'". It is illegal for both x and y to be 606 non-zero. You cannot slide outside the volume range 0..64. The 607 period-length in this channel's division is a parameter to this 608 effect, and hence is not played. 609 */ 610 611 if( period != 0 ) 612 { 613 cptr->portaperiod = period; 614 cptr->period = operiod; 615 } 616 617 cptr->effect = EFFECT_VOLSLIDE_TONEPORTA; 618 if( ( effect & 0xFF ) != 0 ) 619 cptr->volumeslide = ( effect & 0xFF ); 620 621 break; 622 623 case EFFECT_VOLSLIDE_VIBRATO: 624 /* 625 [6]: Continue 'Vibrato', but also do Volume slide 626 Where [6][x][y] means "either slide the volume up x*(ticks - 1) or 627 slide the volume down y*(ticks - 1), at the same time as continuing 628 the last 'Vibrato'". It is illegal for both x and y to be non-zero. 629 You cannot slide outside the volume range 0..64. 630 */ 631 632 cptr->effect = EFFECT_VOLSLIDE_VIBRATO; 633 if( (effect & 0xFF) != 0 ) 634 cptr->volumeslide = (effect & 0xFF); 635 break; 636 637 case EFFECT_SET_OFFSET: 638 /* 639 [9]: Set sample offset 640 Where [9][x][y] means "play the sample from offset x*4096 + y*256". 641 The offset is measured in words. If no sample is given, yet one is 642 still playing on this channel, it should be retriggered to the new 643 offset using the current volume. 644 */ 645 646 cptr->samppos = ((effect>>4) * 4096) + ((effect&0xF)*256); 647 648 break; 649 650 case EFFECT_VOLUME_SLIDE: 651 /* 652 [10]: Volume slide 653 Where [10][x][y] means "either slide the volume up x*(ticks - 1) or 654 slide the volume down y*(ticks - 1)". If both x and y are non-zero, 655 then the y value is ignored (assumed to be 0). You cannot slide 656 outside the volume range 0..64. 657 */ 658 659 cptr->effect = EFFECT_VOLUME_SLIDE; 660 cptr->volumeslide = (effect & 0xFF); 661 break; 662 663 case EFFECT_JUMP_POSITION: 664 /* 665 [11]: Position Jump 666 Where [11][x][y] means "stop the pattern after this division, and 667 continue the song at song-position x*16+y". This shifts the 668 'pattern-cursor' in the pattern table (see above). Legal values for 669 x*16+y are from 0 to 127. 670 */ 671 672 mod->tablepos = (effect & 0xFF); 673 if(mod->tablepos >= mod->song.length) 674 { 675 mod->tablepos = 0; 676 } 677 mod->patternpos = 0; 678 mod->jump_loop_effect = 1; 679 680 break; 681 682 case EFFECT_SET_VOLUME: 683 /* 684 [12]: Set volume 685 Where [12][x][y] means "set current sample's volume to x*16+y". 686 Legal volumes are 0..64. 687 */ 688 689 cptr->volume = (effect & 0xFF); 690 break; 691 692 case EFFECT_PATTERN_BREAK: 693 /* 694 [13]: Pattern Break 695 Where [13][x][y] means "stop the pattern after this division, and 696 continue the song at the next pattern at division x*10+y" (the 10 697 is not a typo). Legal divisions are from 0 to 63 (note Protracker 698 exception above). 699 */ 700 701 mod->patternpos = ( ((effect>>4)&0xF)*10 + (effect&0xF) ) * mod->number_of_channels; 702 mod->jump_loop_effect = 1; 703 mod->tablepos++; 704 if(mod->tablepos >= mod->song.length) 705 { 706 mod->tablepos = 0; 707 } 708 709 break; 710 711 case EFFECT_EXTENDED: 712 switch( (effect>>4) & 0xF ) 713 { 714 case EFFECT_E_FINE_PORTA_UP: 715 /* 716 [14][1]: Fineslide up 717 Where [14][1][x] means "decrement the period of the current sample 718 by x". The incrementing takes place at the beginning of the 719 division, and hence there is no actual sliding. You cannot slide 720 beyond the note B3 (period 113). 721 */ 722 723 cptr->period -= (effect & 0xF); 724 if( cptr->period < 113 ) 725 cptr->period = 113; 726 break; 727 728 case EFFECT_E_FINE_PORTA_DOWN: 729 /* 730 [14][2]: Fineslide down 731 Where [14][2][x] means "increment the period of the current sample 732 by x". Similar to [14][1] but shifts the pitch down. You cannot 733 slide beyond the note C1 (period 856). 734 */ 735 736 cptr->period += (effect & 0xF); 737 if( cptr->period > 856 ) 738 cptr->period = 856; 739 break; 740 741 case EFFECT_E_FINE_VOLSLIDE_UP: 742 /* 743 [14][10]: Fine volume slide up 744 Where [14][10][x] means "increment the volume of the current sample 745 by x". The incrementing takes place at the beginning of the 746 division, and hence there is no sliding. You cannot slide beyond 747 volume 64. 748 */ 749 750 cptr->volume += (effect & 0xF); 751 if( cptr->volume>64 ) 752 cptr->volume = 64; 753 break; 754 755 case EFFECT_E_FINE_VOLSLIDE_DOWN: 756 /* 757 [14][11]: Fine volume slide down 758 Where [14][11][x] means "decrement the volume of the current sample 759 by x". Similar to [14][10] but lowers volume. You cannot slide 760 beyond volume 0. 761 */ 762 763 cptr->volume -= (effect & 0xF); 764 if( cptr->volume > 200 ) 765 cptr->volume = 0; 766 break; 767 768 case EFFECT_E_PATTERN_LOOP: 769 /* 770 [14][6]: Loop pattern 771 Where [14][6][x] means "set the start of a loop to this division if 772 x is 0, otherwise after this division, jump back to the start of a 773 loop and play it another x times before continuing". If the start 774 of the loop was not set, it will default to the start of the 775 current pattern. Hence 'loop pattern' cannot be performed across 776 multiple patterns. Note that loops do not support nesting, and you 777 may generate an infinite loop if you try to nest 'loop pattern's. 778 */ 779 780 if( effect & 0xF ) 781 { 782 if( cptr->patternloopcnt ) 783 { 784 cptr->patternloopcnt--; 785 if( cptr->patternloopcnt ) 786 { 787 mod->patternpos = cptr->patternloopstartpoint; 788 mod->jump_loop_effect = 1; 789 } 790 else 791 { 792 cptr->patternloopstartpoint = mod->patternpos ; 793 } 794 } 795 else 796 { 797 cptr->patternloopcnt = (effect & 0xF); 798 mod->patternpos = cptr->patternloopstartpoint; 799 mod->jump_loop_effect = 1; 800 } 801 } 802 else // Start point 803 { 804 cptr->patternloopstartpoint = mod->patternpos; 805 } 806 807 break; 808 809 case EFFECT_E_PATTERN_DELAY: 810 /* 811 [14][14]: Delay pattern 812 Where [14][14][x] means "after this division there will be a delay 813 equivalent to the time taken to play x divisions after which the 814 pattern will be resumed". The delay only relates to the 815 interpreting of new divisions, and all effects and previous notes 816 continue during delay. 817 */ 818 819 mod->patterndelay = (effect & 0xF); 820 break; 821 822 case EFFECT_E_NOTE_CUT: 823 /* 824 [14][12]: Cut sample 825 Where [14][12][x] means "after the current sample has been played 826 for x ticks in this division, its volume will be set to 0". This 827 implies that if x is 0, then you will not hear any of the sample. 828 If you wish to insert "silence" in a pattern, it is better to use a 829 "silence"-sample (see above) due to the lack of proper support for 830 this effect. 831 */ 832 cptr->effect = EFFECT_E_NOTE_CUT; 833 cptr->cut_param = (effect & 0xF); 834 if(!cptr->cut_param) 835 cptr->volume = 0; 836 break; 837 838 default: 839 840 break; 841 } 842 break; 843 844 case 0xF: 845 /* 846 [15]: Set speed 847 Where [15][x][y] means "set speed to x*16+y". Though it is nowhere 848 near that simple. Let z = x*16+y. Depending on what values z takes, 849 different units of speed are set, there being two: ticks/division 850 and beats/minute (though this one is only a label and not strictly 851 true). If z=0, then what should technically happen is that the 852 module stops, but in practice it is treated as if z=1, because 853 there is already a method for stopping the module (running out of 854 patterns). If z<=32, then it means "set ticks/division to z" 855 otherwise it means "set beats/minute to z" (convention says that 856 this should read "If z<32.." but there are some composers out there 857 that defy conventions). Default values are 6 ticks/division, and 858 125 beats/minute (4 divisions = 1 beat). The beats/minute tag is 859 only meaningful for 6 ticks/division. To get a more accurate view 860 of how things work, use the following formula: 861 24 * beats/minute 862 divisions/minute = ----------------- 863 ticks/division 864 Hence divisions/minute range from 24.75 to 6120, eg. to get a value 865 of 2000 divisions/minute use 3 ticks/division and 250 beats/minute. 866 If multiple "set speed" effects are performed in a single division, 867 the ones on higher-numbered channels take precedence over the ones 868 on lower-numbered channels. This effect has a large number of 869 different implementations, but the one described here has the 870 widest usage. 871 */ 872 873 if( (effect&0xFF) < 0x21 ) 874 { 875 if( effect&0xFF ) 876 { 877 mod->song.speed = effect&0xFF; 878 mod->patternticksaim = (long)mod->song.speed * ((mod->playrate * 5 ) / (((long)2 * (long)mod->bpm))); 879 } 880 } 881 882 if( (effect&0xFF) >= 0x21 ) 883 { 884 /// HZ = 2 * BPM / 5 885 mod->bpm = effect&0xFF; 886 mod->patternticksaim = (long)mod->song.speed * ((mod->playrate * 5 ) / (((long)2 * (long)mod->bpm))); 887 } 888 889 break; 890 891 default: 892 // Unsupported effect 893 break; 894 895 } 896 897 } 898 899 static void workeffect( note * nptr, channel * cptr ) 900 { 901 switch(cptr->effect) 902 { 903 case EFFECT_ARPEGGIO: 904 905 if( cptr->parameffect ) 906 { 907 cptr->decalperiod = cptr->period - cptr->Arpperiods[cptr->ArpIndex]; 908 909 cptr->ArpIndex++; 910 if( cptr->ArpIndex>2 ) 911 cptr->ArpIndex = 0; 912 } 913 break; 914 915 case EFFECT_PORTAMENTO_UP: 916 917 if(cptr->period) 918 { 919 cptr->period -= cptr->parameffect; 920 921 if( cptr->period < 113 || cptr->period > 20000 ) 922 cptr->period = 113; 923 } 924 925 break; 926 927 case EFFECT_PORTAMENTO_DOWN: 928 929 if(cptr->period) 930 { 931 cptr->period += cptr->parameffect; 932 933 if( cptr->period > 20000 ) 934 cptr->period = 20000; 935 } 936 937 break; 938 939 case EFFECT_VOLSLIDE_TONEPORTA: 940 case EFFECT_TONE_PORTAMENTO: 941 942 if( cptr->period && ( cptr->period != cptr->portaperiod ) && cptr->portaperiod ) 943 { 944 if( cptr->period > cptr->portaperiod ) 945 { 946 if( cptr->period - cptr->portaperiod >= cptr->portaspeed ) 947 { 948 cptr->period -= cptr->portaspeed; 949 } 950 else 951 { 952 cptr->period = cptr->portaperiod; 953 } 954 } 955 else 956 { 957 if( cptr->portaperiod - cptr->period >= cptr->portaspeed ) 958 { 959 cptr->period += cptr->portaspeed; 960 } 961 else 962 { 963 cptr->period = cptr->portaperiod; 964 } 965 } 966 967 if( cptr->period == cptr->portaperiod ) 968 { 969 // If the slide is over, don't let it to be retriggered. 970 cptr->portaperiod = 0; 971 } 972 } 973 974 if( cptr->effect == EFFECT_VOLSLIDE_TONEPORTA ) 975 { 976 if( cptr->volumeslide > 0x0F ) 977 { 978 cptr->volume = cptr->volume + (cptr->volumeslide>>4); 979 980 if(cptr->volume>63) 981 cptr->volume = 63; 982 } 983 else 984 { 985 cptr->volume = cptr->volume - (cptr->volumeslide); 986 987 if(cptr->volume>63) 988 cptr->volume=0; 989 } 990 } 991 break; 992 993 case EFFECT_VOLSLIDE_VIBRATO: 994 case EFFECT_VIBRATO: 995 996 cptr->vibraperiod = ( (cptr->vibraparam&0xF) * sintable[cptr->vibrapointeur&0x1F] )>>7; 997 998 if( cptr->vibrapointeur > 31 ) 999 cptr->vibraperiod = -cptr->vibraperiod; 1000 1001 cptr->vibrapointeur = (cptr->vibrapointeur+(((cptr->vibraparam>>4))&0xf)) & 0x3F; 1002 1003 if( cptr->effect == EFFECT_VOLSLIDE_VIBRATO ) 1004 { 1005 if( cptr->volumeslide > 0xF ) 1006 { 1007 cptr->volume = cptr->volume+(cptr->volumeslide>>4); 1008 1009 if( cptr->volume > 64 ) 1010 cptr->volume = 64; 1011 } 1012 else 1013 { 1014 cptr->volume = cptr->volume - cptr->volumeslide; 1015 1016 if( cptr->volume > 64 ) 1017 cptr->volume = 0; 1018 } 1019 } 1020 1021 break; 1022 1023 case EFFECT_VOLUME_SLIDE: 1024 1025 if( cptr->volumeslide > 0xF ) 1026 { 1027 cptr->volume += (cptr->volumeslide>>4); 1028 1029 if( cptr->volume > 64 ) 1030 cptr->volume = 64; 1031 } 1032 else 1033 { 1034 cptr->volume -= (cptr->volumeslide&0xf); 1035 1036 if( cptr->volume > 64 ) 1037 cptr->volume = 0; 1038 } 1039 break; 1040 1041 case EFFECT_E_NOTE_CUT: 1042 if(cptr->cut_param) 1043 cptr->cut_param--; 1044 1045 if(!cptr->cut_param) 1046 cptr->volume = 0; 1047 break; 1048 1049 default: 1050 break; 1051 1052 } 1053 1054 } 1055 1056 /////////////////////////////////////////////////////////////////////////////////// 1057 bool jar_mod_init(jar_mod_context_t * modctx) 1058 { 1059 muint i,j; 1060 1061 if( modctx ) 1062 { 1063 memclear(modctx, 0, sizeof(jar_mod_context_t)); 1064 modctx->playrate = DEFAULT_SAMPLE_RATE; 1065 modctx->stereo = 1; 1066 modctx->stereo_separation = 1; 1067 modctx->bits = 16; 1068 modctx->filter = 1; 1069 1070 for(i=0; i < PERIOD_TABLE_LENGTH - 1; i++) 1071 { 1072 for(j=0; j < 8; j++) 1073 { 1074 modctx->fullperiod[(i*8) + j] = periodtable[i] - ((( periodtable[i] - periodtable[i+1] ) / 8) * j); 1075 } 1076 } 1077 1078 return 1; 1079 } 1080 1081 return 0; 1082 } 1083 1084 bool jar_mod_setcfg(jar_mod_context_t * modctx, int samplerate, int bits, int stereo, int stereo_separation, int filter) 1085 { 1086 if( modctx ) 1087 { 1088 modctx->playrate = samplerate; 1089 1090 if( stereo ) 1091 modctx->stereo = 1; 1092 else 1093 modctx->stereo = 0; 1094 1095 if(stereo_separation < 4) 1096 { 1097 modctx->stereo_separation = stereo_separation; 1098 } 1099 1100 if( bits == 8 || bits == 16 ) 1101 modctx->bits = bits; 1102 else 1103 modctx->bits = 16; 1104 1105 if( filter ) 1106 modctx->filter = 1; 1107 else 1108 modctx->filter = 0; 1109 1110 return 1; 1111 } 1112 1113 return 0; 1114 } 1115 1116 // make certain that mod_data stays in memory while playing 1117 static bool jar_mod_load( jar_mod_context_t * modctx, void * mod_data, int mod_data_size ) 1118 { 1119 muint i, max; 1120 unsigned short t; 1121 sample *sptr; 1122 unsigned char * modmemory,* endmodmemory; 1123 1124 modmemory = (unsigned char *)mod_data; 1125 endmodmemory = modmemory + mod_data_size; 1126 1127 1128 1129 if(modmemory) 1130 { 1131 if( modctx ) 1132 { 1133 memcopy(&(modctx->song.title),modmemory,1084); 1134 1135 i = 0; 1136 modctx->number_of_channels = 0; 1137 while(modlist[i].numberofchannels) 1138 { 1139 if(memcompare(modctx->song.signature,modlist[i].signature,4)) 1140 { 1141 modctx->number_of_channels = modlist[i].numberofchannels; 1142 } 1143 1144 i++; 1145 } 1146 1147 if( !modctx->number_of_channels ) 1148 { 1149 // 15 Samples modules support 1150 // Shift the whole datas to make it look likes a standard 4 channels mod. 1151 memcopy(&(modctx->song.signature), "M.K.", 4); 1152 memcopy(&(modctx->song.length), &(modctx->song.samples[15]), 130); 1153 memclear(&(modctx->song.samples[15]), 0, 480); 1154 modmemory += 600; 1155 modctx->number_of_channels = 4; 1156 } 1157 else 1158 { 1159 modmemory += 1084; 1160 } 1161 1162 if( modmemory >= endmodmemory ) 1163 return 0; // End passed ? - Probably a bad file ! 1164 1165 // Patterns loading 1166 for (i = max = 0; i < 128; i++) 1167 { 1168 while (max <= modctx->song.patterntable[i]) 1169 { 1170 modctx->patterndata[max] = (note*)modmemory; 1171 modmemory += (256*modctx->number_of_channels); 1172 max++; 1173 1174 if( modmemory >= endmodmemory ) 1175 return 0; // End passed ? - Probably a bad file ! 1176 } 1177 } 1178 1179 for (i = 0; i < 31; i++) 1180 modctx->sampledata[i]=0; 1181 1182 // Samples loading 1183 for (i = 0, sptr = modctx->song.samples; i <31; i++, sptr++) 1184 { 1185 t= (sptr->length &0xFF00)>>8 | (sptr->length &0xFF)<<8; 1186 sptr->length = t*2; 1187 1188 t= (sptr->reppnt &0xFF00)>>8 | (sptr->reppnt &0xFF)<<8; 1189 sptr->reppnt = t*2; 1190 1191 t= (sptr->replen &0xFF00)>>8 | (sptr->replen &0xFF)<<8; 1192 sptr->replen = t*2; 1193 1194 1195 if (sptr->length == 0) continue; 1196 1197 modctx->sampledata[i] = (char*)modmemory; 1198 modmemory += sptr->length; 1199 1200 if (sptr->replen + sptr->reppnt > sptr->length) 1201 sptr->replen = sptr->length - sptr->reppnt; 1202 1203 if( modmemory > endmodmemory ) 1204 return 0; // End passed ? - Probably a bad file ! 1205 } 1206 1207 // States init 1208 1209 modctx->tablepos = 0; 1210 modctx->patternpos = 0; 1211 modctx->song.speed = 6; 1212 modctx->bpm = 125; 1213 modctx->samplenb = 0; 1214 1215 modctx->patternticks = (((long)modctx->song.speed * modctx->playrate * 5)/ (2 * modctx->bpm)) + 1; 1216 modctx->patternticksaim = ((long)modctx->song.speed * modctx->playrate * 5) / (2 * modctx->bpm); 1217 1218 modctx->sampleticksconst = 3546894UL / modctx->playrate; //8448*428/playrate; 1219 1220 for(i=0; i < modctx->number_of_channels; i++) 1221 { 1222 modctx->channels[i].volume = 0; 1223 modctx->channels[i].period = 0; 1224 } 1225 1226 modctx->mod_loaded = 1; 1227 1228 return 1; 1229 } 1230 } 1231 1232 return 0; 1233 } 1234 1235 void jar_mod_fillbuffer( jar_mod_context_t * modctx, short * outbuffer, unsigned long nbsample, jar_mod_tracker_buffer_state * trkbuf ) 1236 { 1237 unsigned long i, j; 1238 unsigned long k; 1239 unsigned char c; 1240 unsigned int state_remaining_steps; 1241 int l,r; 1242 int ll,lr; 1243 int tl,tr; 1244 short finalperiod; 1245 note *nptr; 1246 channel *cptr; 1247 1248 if( modctx && outbuffer ) 1249 { 1250 if(modctx->mod_loaded) 1251 { 1252 state_remaining_steps = 0; 1253 1254 if( trkbuf ) 1255 { 1256 trkbuf->cur_rd_index = 0; 1257 1258 memcopy(trkbuf->name,modctx->song.title,sizeof(modctx->song.title)); 1259 1260 for(i=0;i<31;i++) 1261 { 1262 memcopy(trkbuf->instruments[i].name,modctx->song.samples[i].name,sizeof(trkbuf->instruments[i].name)); 1263 } 1264 } 1265 1266 ll = modctx->last_l_sample; 1267 lr = modctx->last_r_sample; 1268 1269 for (i = 0; i < nbsample; i++) 1270 { 1271 //--------------------------------------- 1272 if( modctx->patternticks++ > modctx->patternticksaim ) 1273 { 1274 if( !modctx->patterndelay ) 1275 { 1276 nptr = modctx->patterndata[modctx->song.patterntable[modctx->tablepos]]; 1277 nptr = nptr + modctx->patternpos; 1278 cptr = modctx->channels; 1279 1280 modctx->patternticks = 0; 1281 modctx->patterntickse = 0; 1282 1283 for(c=0;c<modctx->number_of_channels;c++) 1284 { 1285 worknote((note*)(nptr+c), (channel*)(cptr+c),(char)(c+1),modctx); 1286 } 1287 1288 if( !modctx->jump_loop_effect ) 1289 modctx->patternpos += modctx->number_of_channels; 1290 else 1291 modctx->jump_loop_effect = 0; 1292 1293 if( modctx->patternpos == 64*modctx->number_of_channels ) 1294 { 1295 modctx->tablepos++; 1296 modctx->patternpos = 0; 1297 if(modctx->tablepos >= modctx->song.length) 1298 { 1299 modctx->tablepos = 0; 1300 modctx->loopcount++; // count next loop 1301 } 1302 } 1303 } 1304 else 1305 { 1306 modctx->patterndelay--; 1307 modctx->patternticks = 0; 1308 modctx->patterntickse = 0; 1309 } 1310 1311 } 1312 1313 if( modctx->patterntickse++ > (modctx->patternticksaim/modctx->song.speed) ) 1314 { 1315 nptr = modctx->patterndata[modctx->song.patterntable[modctx->tablepos]]; 1316 nptr = nptr + modctx->patternpos; 1317 cptr = modctx->channels; 1318 1319 for(c=0;c<modctx->number_of_channels;c++) 1320 { 1321 workeffect(nptr+c, cptr+c); 1322 } 1323 1324 modctx->patterntickse = 0; 1325 } 1326 1327 //--------------------------------------- 1328 1329 if( trkbuf && !state_remaining_steps ) 1330 { 1331 if( trkbuf->nb_of_state < trkbuf->nb_max_of_state ) 1332 { 1333 memclear(&trkbuf->track_state_buf[trkbuf->nb_of_state], 0, sizeof(tracker_state)); 1334 } 1335 } 1336 1337 l=0; 1338 r=0; 1339 1340 for(j =0, cptr = modctx->channels; j < modctx->number_of_channels ; j++, cptr++) 1341 { 1342 if( cptr->period != 0 ) 1343 { 1344 finalperiod = cptr->period - cptr->decalperiod - cptr->vibraperiod; 1345 if( finalperiod ) 1346 { 1347 cptr->samppos += ( (modctx->sampleticksconst<<10) / finalperiod ); 1348 } 1349 1350 cptr->ticks++; 1351 1352 if( cptr->replen<=2 ) 1353 { 1354 if( (cptr->samppos>>10) >= (cptr->length) ) 1355 { 1356 cptr->length = 0; 1357 cptr->reppnt = 0; 1358 1359 if( cptr->length ) 1360 cptr->samppos = cptr->samppos % (((unsigned long)cptr->length)<<10); 1361 else 1362 cptr->samppos = 0; 1363 } 1364 } 1365 else 1366 { 1367 if( (cptr->samppos>>10) >= (unsigned long)(cptr->replen+cptr->reppnt) ) 1368 { 1369 cptr->samppos = ((unsigned long)(cptr->reppnt)<<10) + (cptr->samppos % ((unsigned long)(cptr->replen+cptr->reppnt)<<10)); 1370 } 1371 } 1372 1373 k = cptr->samppos >> 10; 1374 1375 if( cptr->sampdata!=0 && ( ((j&3)==1) || ((j&3)==2) ) ) 1376 { 1377 r += ( cptr->sampdata[k] * cptr->volume ); 1378 } 1379 1380 if( cptr->sampdata!=0 && ( ((j&3)==0) || ((j&3)==3) ) ) 1381 { 1382 l += ( cptr->sampdata[k] * cptr->volume ); 1383 } 1384 1385 if( trkbuf && !state_remaining_steps ) 1386 { 1387 if( trkbuf->nb_of_state < trkbuf->nb_max_of_state ) 1388 { 1389 trkbuf->track_state_buf[trkbuf->nb_of_state].number_of_tracks = modctx->number_of_channels; 1390 trkbuf->track_state_buf[trkbuf->nb_of_state].buf_index = i; 1391 trkbuf->track_state_buf[trkbuf->nb_of_state].cur_pattern = modctx->song.patterntable[modctx->tablepos]; 1392 trkbuf->track_state_buf[trkbuf->nb_of_state].cur_pattern_pos = modctx->patternpos / modctx->number_of_channels; 1393 trkbuf->track_state_buf[trkbuf->nb_of_state].cur_pattern_table_pos = modctx->tablepos; 1394 trkbuf->track_state_buf[trkbuf->nb_of_state].bpm = modctx->bpm; 1395 trkbuf->track_state_buf[trkbuf->nb_of_state].speed = modctx->song.speed; 1396 trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].cur_effect = cptr->effect_code; 1397 trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].cur_parameffect = cptr->parameffect; 1398 trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].cur_period = finalperiod; 1399 trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].cur_volume = cptr->volume; 1400 trkbuf->track_state_buf[trkbuf->nb_of_state].tracks[j].instrument_number = (unsigned char)cptr->sampnum; 1401 } 1402 } 1403 } 1404 } 1405 1406 if( trkbuf && !state_remaining_steps ) 1407 { 1408 state_remaining_steps = trkbuf->sample_step; 1409 1410 if(trkbuf->nb_of_state < trkbuf->nb_max_of_state) 1411 trkbuf->nb_of_state++; 1412 } 1413 else 1414 { 1415 state_remaining_steps--; 1416 } 1417 1418 tl = (short)l; 1419 tr = (short)r; 1420 1421 if ( modctx->filter ) 1422 { 1423 // Filter 1424 l = (l+ll)>>1; 1425 r = (r+lr)>>1; 1426 } 1427 1428 if ( modctx->stereo_separation == 1 ) 1429 { 1430 // Left & Right Stereo panning 1431 l = (l+(r>>1)); 1432 r = (r+(l>>1)); 1433 } 1434 1435 // Level limitation 1436 if( l > 32767 ) l = 32767; 1437 if( l < -32768 ) l = -32768; 1438 if( r > 32767 ) r = 32767; 1439 if( r < -32768 ) r = -32768; 1440 1441 // Store the final sample. 1442 outbuffer[(i*2)] = l; 1443 outbuffer[(i*2)+1] = r; 1444 1445 ll = tl; 1446 lr = tr; 1447 1448 } 1449 1450 modctx->last_l_sample = ll; 1451 modctx->last_r_sample = lr; 1452 1453 modctx->samplenb = modctx->samplenb+nbsample; 1454 } 1455 else 1456 { 1457 for (i = 0; i < nbsample; i++) 1458 { 1459 // Mod not loaded. Return blank buffer. 1460 outbuffer[(i*2)] = 0; 1461 outbuffer[(i*2)+1] = 0; 1462 } 1463 1464 if(trkbuf) 1465 { 1466 trkbuf->nb_of_state = 0; 1467 trkbuf->cur_rd_index = 0; 1468 trkbuf->name[0] = 0; 1469 memclear(trkbuf->track_state_buf, 0, sizeof(tracker_state) * trkbuf->nb_max_of_state); 1470 memclear(trkbuf->instruments, 0, sizeof(trkbuf->instruments)); 1471 } 1472 } 1473 } 1474 } 1475 1476 //resets internals for mod context 1477 static bool jar_mod_reset( jar_mod_context_t * modctx) 1478 { 1479 if(modctx) 1480 { 1481 memclear(&modctx->song, 0, sizeof(modctx->song)); 1482 memclear(&modctx->sampledata, 0, sizeof(modctx->sampledata)); 1483 memclear(&modctx->patterndata, 0, sizeof(modctx->patterndata)); 1484 modctx->tablepos = 0; 1485 modctx->patternpos = 0; 1486 modctx->patterndelay = 0; 1487 modctx->jump_loop_effect = 0; 1488 modctx->bpm = 0; 1489 modctx->patternticks = 0; 1490 modctx->patterntickse = 0; 1491 modctx->patternticksaim = 0; 1492 modctx->sampleticksconst = 0; 1493 modctx->samplenb = 0; 1494 memclear(modctx->channels, 0, sizeof(modctx->channels)); 1495 modctx->number_of_channels = 0; 1496 modctx->mod_loaded = 0; 1497 modctx->last_r_sample = 0; 1498 modctx->last_l_sample = 0; 1499 1500 return jar_mod_init(modctx); 1501 } 1502 return 0; 1503 } 1504 1505 void jar_mod_unload( jar_mod_context_t * modctx) 1506 { 1507 if(modctx) 1508 { 1509 if(modctx->modfile) 1510 { 1511 JARMOD_FREE(modctx->modfile); 1512 modctx->modfile = 0; 1513 modctx->modfilesize = 0; 1514 modctx->loopcount = 0; 1515 } 1516 jar_mod_reset(modctx); 1517 } 1518 } 1519 1520 mulong jar_mod_load_file(jar_mod_context_t * modctx, const char* filename) 1521 { 1522 mulong fsize = 0; 1523 if(modctx->modfile) 1524 { 1525 JARMOD_FREE(modctx->modfile); 1526 modctx->modfile = 0; 1527 } 1528 1529 FILE *f = fopen(filename, "rb"); 1530 if(f) 1531 { 1532 fseek(f,0,SEEK_END); 1533 fsize = ftell(f); 1534 fseek(f,0,SEEK_SET); 1535 1536 if(fsize && fsize < 32*1024*1024) 1537 { 1538 modctx->modfile = JARMOD_MALLOC(fsize); 1539 modctx->modfilesize = fsize; 1540 memset(modctx->modfile, 0, fsize); 1541 fread(modctx->modfile, fsize, 1, f); 1542 fclose(f); 1543 1544 if(!jar_mod_load(modctx, (void*)modctx->modfile, fsize)) fsize = 0; 1545 } else fsize = 0; 1546 } 1547 return fsize; 1548 } 1549 1550 mulong jar_mod_current_samples(jar_mod_context_t * modctx) 1551 { 1552 if(modctx) 1553 return modctx->samplenb; 1554 1555 return 0; 1556 } 1557 1558 // Works, however it is very slow, this data should be cached to ensure it is run only once per file 1559 mulong jar_mod_max_samples(jar_mod_context_t * ctx) 1560 { 1561 mint buff[2]; 1562 mulong len; 1563 mulong lastcount = ctx->loopcount; 1564 1565 while(ctx->loopcount <= lastcount) 1566 jar_mod_fillbuffer(ctx, buff, 1, 0); 1567 1568 len = ctx->samplenb; 1569 jar_mod_seek_start(ctx); 1570 1571 return len; 1572 } 1573 1574 // move seek_val to sample index, 0 -> jar_mod_max_samples is the range 1575 void jar_mod_seek_start(jar_mod_context_t * ctx) 1576 { 1577 if(ctx && ctx->modfile) 1578 { 1579 muchar* ftmp = ctx->modfile; 1580 mulong stmp = ctx->modfilesize; 1581 muint lcnt = ctx->loopcount; 1582 1583 if(jar_mod_reset(ctx)){ 1584 jar_mod_load(ctx, ftmp, stmp); 1585 ctx->modfile = ftmp; 1586 ctx->modfilesize = stmp; 1587 ctx->loopcount = lcnt; 1588 } 1589 } 1590 } 1591 1592 #endif // end of JAR_MOD_IMPLEMENTATION 1593 //------------------------------------------------------------------------------- 1594 1595 1596 #endif //end of header file