Groovy Bytes: Behind the Moon/groovybytes.iso/GROOVY/DEMOS/MISC_DEM/SUNKNOWN.ZIP/MIDIHACK.C

C/C++ Source or Header | 1994-04-07 | 4.8 KB | 210 lines

/*
** Copyright (c) 1992 Forte.  All rights reserved.
** Written late one night 6/27/93.
**
** Note from Five, And Then Some:
**   This file was originally included in the ultramid-package (or the
**   Software Development Kit for the Gravis Ultrasound).
**
** Additional programming by Ronny H.
**
*/


//#define DEBUG
#define TRUE 1
#define FALSE 0

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <conio.h>
#include <dir.h>
#include <dos.h>

/* midi files */
#include "global.h"
#include "midi.h"
#include "totsr.h"
#include "midihack.h"


void midi_do_something(struct MIDILIB *ml, unsigned long now_time);
unsigned long midi_getvarinum(struct track *track);


struct header_type header;    /* format of midifile, # of tracks, and time */
int midi_libs=0;
int control_break = FALSE;
FILE *fpIn=NULL;    /* file pointer */
struct MIDILIB *ml;
int i, j, ret;
char *cp;
int not_done_playing=1;

/* callback routine to read a character from the midi file */
mygetc() { return(getc(fpIn)); }

/* callback routine for the midi library to print error messages */
void myerror(s)
char *s;
{
    midi_error("Error: %s\n", s);
}

/* callback routine for the midi library to record header information */
void myheader(format,ntrks,division)
int format,ntrks,division;
{
    header.format = format;
    header.ntrks = ntrks;
    header.division.quarter_note = division;
}

void mytrack(struct MIDILIB *ml, struct track *track)
{
    struct track *tp;

    if (ml->Mp_tracks) {
        for (tp=ml->Mp_tracks; tp->next_track; tp = tp->next_track) ;
        tp->next_track = track;
    } else {
        ml->Mp_tracks = track;
    }
}

/*
** This routine initalizes the midifile and midiplay libraries and
** sets up all of the callback functions
*/
void init_funcs(struct MIDILIB *ml)
{
    int i;
    int bm;

    ml->Mf_getc = mygetc;
    ml->Mf_header = myheader;
    ml->Mp_set_tempo = um_set_tempo;
    ml->Mp_reset_tick_counter = um_reset_tick_counter;
    ml->Mp_wait_for = um_wait_for;
    ml->Mp_init_timers = um_init_timers;
    ml->Mp_cleanup_timers = um_cleanup_timers;
    ml->Mp_reset_midi = reset_um;
    ml->Mp_note_on = um_note_on;
    ml->Mp_note_off = um_note_off;
    ml->Mp_pressure = um_pressure;
    ml->Mp_parameter = um_parameter;
    ml->Mp_pitch_bend = um_pitch_bend;
    ml->Mp_program = um_program;
    ml->Mp_chanpressure = um_chanpressure;
    ml->Mp_init_hardware = um_init_hardware;
    ml->Mp_cleanup = um_cleanup;
}

void midi_error(char *fmt, ...)
{
    char buffer[512];
    register int i;
    va_list argptr;
    int cnt;

    va_start(argptr, fmt);
    cnt = vsprintf(buffer, fmt, argptr);
    if (cnt != EOF) {
        puts(buffer);
    }
    va_end(argptr);
}

void midi_message(char *fmt, ...)
{
    char buffer[512];
    register int i;
    va_list argptr;
    int cnt;

    va_start(argptr, fmt);
    cnt = vsprintf(buffer, fmt, argptr);
    if (cnt != EOF) {
        puts(buffer);
    }
    va_end(argptr);
}

void smidistart(void)
{
    struct track *track;
    unsigned long next_event_time;
    int i, iret, c;

  /* try and open the midifile */
  fpIn = fopen(MIDIFILE, "rb");
  if (fpIn == NULL) {
#ifdef DEBUG
      fprintf(stderr,"%s: unable to open file %s for reading.\n","smidistart()", MIDIFILE);
#endif
      exit(1);
  }
  ml = mfinit(myerror);
  (void) init_funcs(ml); /* intialize midi libraries */
  mfread(ml);         /* read midi file */
  fclose(fpIn);

    not_done_playing = 1;
    /* initialize track playback info */
    next_event_time = -1L;
    for (track=ml->Mp_tracks; track; track = track->next_track) {
        track->playp = track->data;
        track->position = 0L;
        track->status = 0;
        track->play_state = MPS_PLAYING;
            track->play_time = midi_getvarinum(track);
        if (track->play_time < next_event_time) {
        next_event_time = track->play_time;
        }
    }
    ml->Mp_next_event_time = next_event_time;
    if (ml->Mp_set_tempo && header.division.quarter_note < 0) {
        (*ml->Mp_set_tempo)(0, header.division.quarter_note);
    }
    if (ml->Mp_wait_for == 0L) return;
    if (ml->Mp_reset_tick_counter) (*ml->Mp_reset_tick_counter)();
    if (ml->Mp_reset_midi) (*ml->Mp_reset_midi)();
    if (ml->Mp_init_hardware) {
        iret = (*ml->Mp_init_hardware)(ml);
        if (iret != 0) {
        if (ml->Mp_cleanup) (*ml->Mp_cleanup)();
        return;
        }
    }
#ifdef DEBUG
        midi_message("Now playing");
#endif
        if (ml->Mp_init_timers) {
        (*ml->Mp_init_timers)();
    }
    not_done_playing = 1;

}

void smidireset(void)
{
  if (ml->Mp_cleanup_timers)
    (*ml->Mp_cleanup_timers)();

    if (ml->Mp_cleanup)
    (*ml->Mp_cleanup)();

  mfcleanup(ml);       // close the midifile library

  mfclose(&ml);           // close the midi libraries
}

void smidigo(void)
{
  if (!((*ml->Mp_wait_for)(ml->Mp_next_event_time)))
    midi_do_something(ml, ml->Mp_next_event_time);
}