home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / musik / MIDIFP21 / SOURCES / MY_LIB / NOTIMTAB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-24  |  7.7 KB  |  251 lines
  1. /**************************************************************
  2. *
  3. *                NOTIMTAB.C
  4. *
  5. **************************************************************/
  6.  
  7. #include <acs.h>        /* because of NULL, Ax_malloc(), ... */
  8. #include <string.h>     /* because of memcmp(), ... */
  9.  
  10. #include <servimem.pif>
  11. #include <notimtab.pif>
  12.  
  13.  
  14. /********************************************************************
  15. */
  16.     int delta(
  17.         NOTE_TIME_TABLE_ELEMENT *border,     /* search till border is reached */
  18.         NOTE_TIME_TABLE_ELEMENT *position    /* search from position onwards */
  19.     )    
  20. /* Assumes "border" and "position" to be pointers
  21. * into a note_time_table. "delta" searches - starting from "position" 
  22. * in direction to "border" - for the first note in the table which ma- 
  23. * tches to the one "position" is pointing to. Two notes match - in 
  24. * the sense used here - if note number, channel and source chunk are 
  25. * equal and if the reference of the found note is still initialized.
  26. *
  27. * RETURN:  d: = 0 , if no match was found or if position == border.
  28. *             = matching position - position , else.
  29. * 
  30. ********************************************************************/
  31. {
  32. int d = 0;
  33. register NOTE_TIME_TABLE_ELEMENT *current ;
  34.  
  35.     current = position ;
  36.     if (border > position)
  37.     {
  38.         while ( (current < border) && !d )
  39.         {
  40.             current += 1 ;
  41.             if (!current->reference &&
  42.                  (current->note == position->note) &&
  43.                  (current->channel == position->channel) )
  44.                 d = current - position ;    
  45.         }
  46.     }
  47.     else if (border < position)
  48.     {
  49.         while ( (current > border) && !d )
  50.         {
  51.             current -= 1 ;
  52.             if (!current->reference &&
  53.                  (current->note == position->note) &&
  54.                  (current->channel == position->channel) )
  55.                 d = current - position ;    
  56.         }
  57.     }
  58.     return(d) ;
  59. }
  60.  
  61.  
  62.  
  63. /******************************************************************/
  64. /***********  PUBLISHED INTERFACE (PIF)  **************************/
  65. /******************************************************************/
  66.  
  67. unsigned int fill_note_time_table
  68. (
  69.     unsigned char *track_address,
  70.     long track_length,
  71.     NOTE_TIME_TABLE_ELEMENT *first_element,
  72.     long *elements_generated,
  73.     unsigned int *channels,
  74.     NOTE *min_note, NOTE *max_note,
  75.     char *trackname,
  76.     int max_text_length
  77. )
  78. {
  79. event *next_data = track_address, status = 0 ;
  80. NOTE_TIME_TABLE_ELEMENT *current_element = first_element;
  81. unsigned long length = 0 ; /* length of sysex or meta events */
  82. TIME time = 0, delta_time = 0 ;
  83. unsigned char read_bytes = 0 ;
  84. int d = 0,   /* reference(note on) = - reference(note off) = d */
  85.     EOT_reached = FALSE ;
  86.  
  87.     *channels = 0 ; /* up to now, all are empty */
  88.     *min_note = 0x7f ; *max_note = 0x00 ; 
  89.  
  90.     /*** while not end of track reached ***/
  91.     while (!EOT_reached)
  92.     {
  93.         /*** get next time value ***/
  94.         if ( read_var_len(next_data, &delta_time, &read_bytes) )
  95.             return no_var_length_number ;
  96.         next_data += read_bytes ; 
  97.         time += delta_time ;
  98.  
  99.         /*** get next event out of this chunk ***/
  100.         if ( (*next_data & MSN) == SYS_EX )
  101.         { 
  102.             /*** sysex or meta event or error ***/
  103.             status = 0 ;
  104.             switch (*next_data)
  105.             {
  106.             case SYS_EX: /*** sysex event transmit "f0": ignore ***/
  107.                 if ( read_var_len(next_data + 1, &length, &read_bytes) 
  108.                     == no_var_length_number ) return no_var_length_number ;
  109.                 next_data += (1 + read_bytes + length) ; break ;
  110.             case SYS_EX_NT: /*** sysex event not transmit "f0": ignore ***/
  111.                 if ( read_var_len(next_data + 1, &length, &read_bytes) 
  112.                     == no_var_length_number ) return no_var_length_number ;
  113.                 next_data += (1 + read_bytes + length) ; break ;
  114.             case META_EVENT: /*** meta event ***/
  115.                 next_data += 1 ; /* point to type of meta event */
  116.                 if ( read_var_len(next_data + 1, &length, &read_bytes) 
  117.                     == no_var_length_number ) return no_var_length_number ;
  118.                 switch (*next_data)
  119.                 {
  120.                 case END_OF_TRACK: EOT_reached = TRUE ; break ;
  121.                 case SQ_TRCK_NAME: 
  122.                     if (length >= max_text_length) {
  123.                         memcpy(trackname, next_data + 1 + read_bytes, max_text_length - 1) ;
  124.                         trackname[max_text_length - 1] = 0 ;
  125.                     }
  126.                     else {
  127.                         memcpy(trackname, next_data + 1 + read_bytes, length) ;
  128.                         trackname[length] = 0 ;
  129.                     }
  130.                 }
  131.                 next_data += (1 + read_bytes + length) ;
  132.                 break ;
  133.             default: 
  134.                 return wrong_event_found ;
  135.             }
  136.         }
  137.         else 
  138.         {
  139.             /*** midi data or channel message status byte ***/
  140.             if ( !(*next_data & STATUS) ) 
  141.             { 
  142.                 /*** data, running status must be given ***/
  143.                 if (!status) return data_without_status_given ;
  144.             }
  145.             else    
  146.             { 
  147.                 /*** channel message status byte ***/
  148.                 status = *next_data ;
  149.                 next_data += 1 ;
  150.             }
  151.             switch (status & MSN)
  152.             {
  153.             case NOTE_OFF: /* for delta: | _ON_ */ 
  154.                 current_element->note = *next_data | _ON_ ; 
  155.                 current_element->channel = status & LSN ;
  156.                 next_data += 1 ;
  157.                 current_element->dynamic = *next_data ;
  158.                 next_data += 1 ;
  159.                 current_element->time = time ;
  160.  
  161.                 /*** link note on and note off ***/
  162.                 d = delta(first_element, current_element) ; 
  163.  
  164.                 /*** reset: note off ***/
  165.                 current_element->note &= ~_ON_ ; 
  166.                 current_element->reference = d ;   
  167.                 (current_element + d)->reference = - d ;
  168.                 current_element += 1 ; 
  169.                 break ;
  170.             case NOTE_ON: 
  171.                 if (*next_data > *max_note) *max_note = *next_data ;
  172.                 if (*next_data < *min_note) *min_note = *next_data ;
  173.                 current_element->note = *next_data | _ON_ ; 
  174.                 current_element->channel = status & LSN ;
  175.                 *channels |= 0x1<<(current_element->channel) ; 
  176.                 next_data += 1 ;
  177.                 current_element->dynamic = *next_data ;
  178.                 next_data += 1 ;
  179.                 current_element->time = time ;
  180.  
  181.                 /*** note on with dynamic == 0 is note off ***/
  182.                 if (!current_element->dynamic)
  183.                 { 
  184.                     /*** link note on and note off ***/
  185.                     d = delta(first_element, current_element) ;
  186.  
  187.                     /*** switch note to off ! ***/
  188.                     current_element->note &= ~_ON_ ; 
  189.                     current_element->reference = d ;   
  190.                     (current_element + d)->reference = - d ;
  191.                     current_element += 1 ; 
  192.                 } 
  193.                 else  
  194.                 { 
  195.                     /*** normal note on:                   ***/
  196.                     /*** initialize reference and continue ***/
  197.                     current_element->reference = 0 ; 
  198.                     current_element += 1 ;
  199.                 }
  200.                 break ;
  201.             case POLY_KEY_PRESS: 
  202.             case CONTROL_CHANGE: 
  203.             case PITCH_BEND: 
  204.                 next_data += 2 ; break ; 
  205.             case PROGRAM_CHANGE: 
  206.             case CHANNEL_PRESS: 
  207.                 next_data += 1 ; break ; 
  208.             }
  209.         }
  210.         if (next_data - track_address > track_length)
  211.             return next_data_overflow ;
  212.     } 
  213. /*** <-- end while (!EOT_reached) ***/
  214.     *elements_generated = ( (long)current_element  - (long)first_element ) / 
  215.                               sizeof *first_element ;
  216. /*** return success message ***/
  217.     return note_time_table_filled ;
  218. }
  219.  
  220.  
  221.  
  222. NOTE_TIME_TABLE_ELEMENT *get_element(NOTE_TIME_TABLE_ELEMENT *first_element, 
  223.                                      unsigned long number ,
  224.                                      TIME time)
  225. {
  226. NOTE_TIME_TABLE_ELEMENT *current_element, *previous_element ;
  227. unsigned long low = 0, mid, high = number ;
  228. int found = FALSE ;
  229.  
  230.     /*** Has already the first element a higher time ? ***/
  231.     if (first_element->time >= time) return first_element ;    
  232.  
  233.     /*** Has the last element a lower time ? ***/
  234.     current_element = first_element + number - 1 ;
  235.     if (current_element->time < time) return NULL ; /* failed */
  236.  
  237.     /*** Now, number shurely is greater or equal 2 ! ***/
  238.     while (!found)
  239.         {
  240.         mid = (low + high) / 2 ;
  241.         current_element = first_element + mid ;
  242.         previous_element = current_element - 1 ;
  243.         if ((current_element->time >= time) && (previous_element->time >= time)) 
  244.              high = mid ;
  245.         else if (current_element->time < time) low = mid ;
  246.              else found = TRUE ;
  247.         if (!high) { current_element = first_element ; found = TRUE ; } ;
  248.         }
  249.     return current_element ;
  250. }
  251.