home *** CD-ROM | disk | FTP | other *** search
/ Zodiac Super OZ / MEDIADEPOT.ISO / FILES / 15 / GMS100.ZIP / gms100 / source / song.cpp < prev    next >
C/C++ Source or Header  |  1996-05-15  |  8KB  |  240 lines
  1. #define COMPILING_SONG
  2.  
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include "globals.h"
  7. #ifdef TARGET_MSDOS
  8. #include <dos.h>
  9. #endif
  10. #include <assert.h>
  11. #include "block.h"
  12. #include "inst.h"
  13. #include "song.h"
  14. #include "musdrv.h"
  15. #ifdef EDITOR_HOOKS
  16. #include "intrface.h"
  17. #include "gengad.h"
  18. #include "statbar.h"
  19. #endif
  20.  
  21. song::song() {
  22.   name = new char [51];
  23.   *name = 0;
  24.   info_page = (char *) malloc(14);
  25.   memset(info_page, 0, 14);
  26.   pattern_list[0] = 0;
  27.   highest_pattern = 0;
  28.   highest_stereo_left = 3;
  29.   highest_track = 8;
  30.   soundsystem = adlib;
  31.   overall_am_vib.byte = 0; 
  32.   tempo = 130;
  33.   secondary_tempo = 6;
  34.   block_pointer[0] = new block;
  35.   highest_block = 0;
  36.   instrument_pointer[0] = new instrument;
  37.   instrument_pointer[0]->a_d1.byte = 0xFF;
  38.   instrument_pointer[0]->a_d2.byte = 0xFF;
  39.   instrument_pointer[0]->s_r1.byte = 0xFF;
  40.   instrument_pointer[0]->s_r2.byte = 0xFF;
  41.   instrument_pointer[1] = new instrument;
  42.   highest_instrument = 1;
  43.   position_jump(0);
  44. }
  45.  
  46. song::~song() {
  47.   delete [] name;
  48.   wipe_old_song();
  49.   delete instrument_pointer[0];
  50.   free(info_page);
  51. }
  52.  
  53. void song::position_jump(unsigned int new_pattern, unsigned int new_line) {
  54.   music.forbid_playing();
  55.   if (new_pattern > highest_pattern)
  56.     new_pattern = highest_pattern; 
  57.   block_jump(pattern_list[new_pattern], new_line);
  58.   current_pattern = new_pattern;
  59.   music.permit_playing();
  60. }
  61.  
  62. void song::block_jump(unsigned int new_block, unsigned int new_line) {
  63.   unsigned int stepper, stepper2;
  64.  
  65.   music.forbid_playing();
  66.   if (new_block > highest_block)
  67.     new_block = highest_block;
  68.   for(stepper = 0;stepper <= highest_track;stepper++)
  69.     current_note[stepper] =
  70.       block_pointer[new_block]->track_pointer[stepper];
  71.   if (new_line) {
  72.     if (new_line > block_pointer[new_block]->highest_line)
  73.       new_line = block_pointer[new_block]->highest_line;
  74.     for(stepper = 0;stepper <= highest_track;stepper++)
  75.       for(stepper2 = 0;stepper2 < new_line;stepper2++)
  76.         skip_note(current_note[stepper]);
  77.   }
  78.   current_block = new_block;
  79.   current_line = new_line;
  80.   music.reset_accumulated_ticks();
  81.   music.permit_playing();
  82. }
  83.  
  84. void song::advance_line() {
  85. // Advance to the next line, and possibly to the next pattern.
  86.   unsigned int stepper;
  87.  
  88.   if (++current_line > block_pointer[current_block]->highest_line) {
  89. #ifdef EDITOR_HOOKS
  90.     if (music.play_block_mode)
  91.       block_jump(current_block);
  92.     else {
  93. #endif
  94.       if(++current_pattern > highest_pattern)
  95.         current_pattern = 0;
  96.       position_jump(current_pattern);
  97. #ifdef EDITOR_HOOKS
  98.     }
  99. #endif
  100.   }
  101.   else
  102.     for (stepper = 0;stepper <= highest_track;stepper++)
  103.       skip_note(current_note[stepper]); 
  104. }
  105.  
  106. void song::wipe_old_song() {
  107.   unsigned int stepper;
  108.  
  109.   for (stepper = 0;stepper <= highest_block;stepper++)
  110.     delete block_pointer[stepper];
  111.   for (stepper = 1;stepper <= highest_instrument;stepper++)
  112.     delete instrument_pointer[stepper];
  113. }
  114.  
  115. unsigned int song::load_gms(FILE *module) {
  116.   char tracker_id_reader[20];
  117.   unsigned int inbyte;
  118.   unsigned int counter, stepper;
  119.   char *char_read;
  120.   int track_memory[MAX_BLOCKS][MAX_TRACKS];
  121.   unsigned int track_counter, track_max;
  122.   unsigned int track_lines;
  123.   unsigned int track_start, track_end;
  124.   unsigned char *mem_holder;
  125.  
  126.   fread(tracker_id_reader, 1, tracker_id_length[GMS_MOD_OFFSET], module);
  127.   if (memcmp(tracker_id_reader, tracker_id_string[GMS_MOD_OFFSET],
  128.     tracker_id_length[GMS_MOD_OFFSET])) {
  129. #ifdef EDITOR_HOOKS
  130.     status_bar_obj.message_output("This is not a GMS module.");
  131. #endif
  132.     return NO;
  133.   }
  134.   else {
  135.     inbyte = fgetc(module);
  136.     if (inbyte == 0) {
  137. #ifdef EDITOR_HOOKS
  138.       status_bar_obj.message_output("This is a GMS 1.0 module.");
  139. #endif
  140.       wipe_old_song();
  141. // Load song info.
  142.       stepper = 0;
  143.       while ((*(name + stepper++) = fgetc(module)));
  144.       free(info_page);
  145.       info_page = (char *) malloc(784);
  146.       char_read = info_page;
  147.       for (counter = 0;counter < 14;counter++)
  148.         while ((*(char_read++) = fgetc(module)));
  149.       info_page = (char *) realloc(info_page, char_read - info_page);
  150.       overall_am_vib.byte = fgetc(module);
  151.       highest_track = fgetc(module);
  152.       tempo = fgetc(module);
  153.       secondary_tempo = fgetc(module);
  154.       soundsystem = (sound_cards) fgetc(module);
  155.       highest_stereo_left = fgetc(module);
  156. // Load instruments.
  157.       highest_instrument = fgetc(module);
  158.       for (counter = 1;counter <= highest_instrument;counter++) {
  159.         instrument_pointer[counter] = new instrument;
  160.         stepper = 0;
  161.         while ((*(instrument_pointer[counter]->name + stepper++)
  162.           = fgetc(module)));
  163.         instrument_pointer[counter]->am_vib1.byte = fgetc(module);
  164.         instrument_pointer[counter]->scaling_volume1.byte = fgetc(module);
  165.         instrument_pointer[counter]->a_d1.byte = fgetc(module);
  166.         instrument_pointer[counter]->s_r1.byte = fgetc(module);
  167.         instrument_pointer[counter]->wave1.byte = fgetc(module);
  168.         instrument_pointer[counter]->am_vib2.byte = fgetc(module);
  169.         instrument_pointer[counter]->scaling_volume2.byte = fgetc(module);
  170.         instrument_pointer[counter]->a_d2.byte = fgetc(module);
  171.         instrument_pointer[counter]->s_r2.byte = fgetc(module);
  172.         instrument_pointer[counter]->wave2.byte = fgetc(module);
  173.         instrument_pointer[counter]->op1mod_feedback.byte = fgetc(module);
  174.       }
  175. // Load pattern-list data.
  176.       highest_pattern = fgetc(module);
  177.       for (counter = 0;counter <= highest_pattern;counter++)
  178.         pattern_list[counter] = fgetc(module);
  179. // Load blocks.
  180.       highest_block = fgetc(module);
  181.       track_max = 0;
  182.       for (counter = 0;counter <= highest_block;counter++) {
  183.         block_pointer[counter] = new block;
  184.         block_pointer[counter]->highest_line = fgetc(module);
  185.         for (stepper = 0;stepper <= highest_track;stepper++) {
  186.           inbyte = fgetc(module);
  187.           track_memory[counter][stepper] = (inbyte << 8) + fgetc(module);
  188.           if (!track_memory[counter][stepper]) {
  189.             free(block_pointer[counter]->track_pointer[stepper]);
  190.             block_pointer[counter]->track_pointer[stepper] = 0;
  191.             block_pointer[counter]->track_bytes[stepper] = 0;
  192.           }
  193.           if (track_memory[counter][stepper] > (int) track_max)
  194.             track_max = track_memory[counter][stepper];
  195.         }
  196.       }
  197.       for (track_counter = 1;track_counter <= track_max;track_counter++) {
  198.         track_lines = 9999;
  199.         for (counter = 0;counter <= highest_block;counter++)
  200.           for (stepper = 0;stepper <= highest_track;stepper++)
  201.             if (track_memory[counter][stepper] == (int) track_counter)
  202.               track_lines = block_pointer[counter]->highest_line;
  203.         assert(track_lines != 9999);
  204.         track_start = ftell(module);
  205.         for (counter = 0;counter <= track_lines;counter++) {
  206.           if (fgetc(module) & 128)
  207.             if (fgetc(module) & 128)
  208.               do {
  209.                 inbyte = fgetc(module);
  210.                 fgetc(module);
  211.               } while (inbyte & 128);
  212.         }
  213.         track_end = ftell(module);
  214.         fseek(module, track_start, SEEK_SET);
  215.         mem_holder = (unsigned char *) malloc(track_end - track_start);
  216.         fread(mem_holder, 1, track_end - track_start, module);
  217.         for (counter = 0;counter <= highest_block;counter++)
  218.           for (stepper = 0;stepper <= highest_track;stepper++)
  219.             if (track_memory[counter][stepper] == (int) track_counter) {
  220.               free(block_pointer[counter]->track_pointer[stepper]);
  221.               block_pointer[counter]->track_pointer[stepper] = mem_holder;
  222.               block_pointer[counter]->track_bytes[stepper] = track_end
  223.                 - track_start;
  224.             }
  225.       }
  226. #ifdef EDITOR_HOOKS
  227.       editor_reformat();
  228. #endif
  229.       position_jump(0);
  230.       return YES;
  231.     }
  232.     else {
  233. #ifdef EDITOR_HOOKS
  234.       status_bar_obj.message_output("Unknown GMS format. You need a newer version of GMS.");
  235. #endif
  236.       return NO;
  237.     }
  238.   }
  239. }
  240.