Logo Search packages:      
Sourcecode: scummvm version File versions

midiparser_xmidi.cpp

/* ScummVM - Scumm Interpreter
 * Copyright (C) 2001-2004 The ScummVM project
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Header: /cvsroot/scummvm/scummvm/sound/midiparser_xmidi.cpp,v 1.17 2004/04/29 11:51:11 eriktorbjorn Exp $
 *
 */

#include "stdafx.h"
#include "midiparser.h"
#include "mididrv.h"
#include "common/util.h"


/**
 * The XMIDI version of MidiParser.
 * 
 * Much of this code is adapted from the XMIDI implementation from the exult
 * project.
 */
00034 class MidiParser_XMIDI : public MidiParser {
protected:
      NoteTimer _notes_cache[32];
      uint32 _inserted_delta; // Track simulated deltas for note-off events

protected:
      uint32 readVLQ2(byte * &data);
      void resetTracking();
      void parseNextEvent(EventInfo &info);

public:
      MidiParser_XMIDI() : _inserted_delta(0) {}
      ~MidiParser_XMIDI() { }

      bool loadMusic(byte *data, uint32 size);
};


// This is a special XMIDI variable length quantity
uint32 MidiParser_XMIDI::readVLQ2(byte * &pos) {
      uint32 value = 0;
      int i;
      
      for (i = 0; i < 4; ++i) {
            if (pos[0] & 0x80)
                  break;
            value += *pos++;
      }
      return value;
}

void MidiParser_XMIDI::parseNextEvent(EventInfo &info) {
      info.start = _position._play_pos;
      info.delta = readVLQ2(_position._play_pos) - _inserted_delta;

      // Process the next event.
      _inserted_delta = 0;
      info.event = *(_position._play_pos++);
      switch (info.event >> 4) {
      case 0x9: // Note On
            info.basic.param1 = *(_position._play_pos++);
            info.basic.param2 = *(_position._play_pos++);
            info.length = readVLQ(_position._play_pos);
            if (info.basic.param2 == 0) {
                  info.event = info.channel() | 0x80;
                  info.length = 0;
            }
            break;

      case 0xC: case 0xD:
            info.basic.param1 = *(_position._play_pos++);
            info.basic.param2 = 0;
            break;

      case 0x8: case 0xA: case 0xB: case 0xE:
            info.basic.param1 = *(_position._play_pos++);
            info.basic.param2 = *(_position._play_pos++);
            break;

      case 0xF: // Meta or SysEx event
            switch (info.event & 0x0F) {
            case 0x2: // Song Position Pointer
                  info.basic.param1 = *(_position._play_pos++);
                  info.basic.param2 = *(_position._play_pos++);
                  break;

            case 0x3: // Song Select
                  info.basic.param1 = *(_position._play_pos++);
                  info.basic.param2 = 0;
                  break;

            case 0x6: case 0x8: case 0xA: case 0xB: case 0xC: case 0xE:
                  info.basic.param1 = info.basic.param2 = 0;
                  break;

            case 0x0: // SysEx
                  info.length = readVLQ(_position._play_pos);
                  info.ext.data = _position._play_pos;
                  _position._play_pos += info.length;
                  break;

            case 0xF: // META event
                  info.ext.type = *(_position._play_pos++);
                  info.length = readVLQ(_position._play_pos);
                  info.ext.data = _position._play_pos;
                  _position._play_pos += info.length;
                  if (info.ext.type == 0x51 && info.length == 3) {
                        // Tempo event. We want to make these constant 500,000.
                        info.ext.data[0] = 0x07;
                        info.ext.data[1] = 0xA1;
                        info.ext.data[2] = 0x20;
                  }
                  break;
            }
      }
}

bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
      uint32 i = 0;
      byte *start;
      uint32 len;
      uint32 chunk_len;
      char buf[32];

      unloadMusic();
      byte *pos = data;

      if (!memcmp(pos, "FORM", 4)) {
            pos += 4;

            // Read length of 
            len = read4high(pos);
            start = pos;

            // XDIRless XMIDI, we can handle them here.
            if (!memcmp(pos, "XMID", 4)) {      
                  warning("XMIDI doesn't have XDIR");
                  pos += 4;
                  _num_tracks = 1;
            } else if (memcmp(pos, "XDIR", 4)) {
                  // Not an XMIDI that we recognise
                  warning("Expected 'XDIR' but found '%c%c%c%c'", pos[0], pos[1], pos[2], pos[3]);
                  return false;
            } else {
                  // Seems Valid
                  pos += 4;
                  _num_tracks = 0;

                  for (i = 4; i < len; i++) {
                        // Read 4 bytes of type
                        memcpy(buf, pos, 4);
                        pos += 4;

                        // Read length of chunk
                        chunk_len = read4high(pos);

                        // Add eight bytes
                        i += 8;

                        if (memcmp(buf, "INFO", 4)) {
                              // Must align
                              pos += (chunk_len + 1) & ~1;
                              i += (chunk_len + 1) & ~1;
                              continue;
                        }

                        // Must be at least 2 bytes long
                        if (chunk_len < 2) {
                              warning("Invalid chunk length %d for 'INFO' block!", (int) chunk_len);
                              return false;
                        }

                        _num_tracks = (byte) read2low(pos);

                        if (chunk_len > 2) {
                              warning("Chunk length %d is greater than 2", (int) chunk_len);
                              pos += chunk_len - 2;
                        }
                        break;
                  }

                  // Didn't get to fill the header
                  if (_num_tracks == 0) {
                        warning("Didn't find a valid track count");
                        return false;
                  }

                  // Ok now to start part 2
                  // Goto the right place
                  pos = start + ((len + 1) & ~1);

                  if (memcmp(pos, "CAT ", 4)) {
                        // Not an XMID
                        warning("Expected 'CAT ' but found '%c%c%c%c'", pos[0], pos[1], pos[2], pos[3]);
                        return false;
                  }
                  pos += 4;

                  // Now read length of this track
                  len = read4high(pos);

                  if (memcmp(pos, "XMID", 4)) {
                        // Not an XMID
                        warning("Expected 'XMID' but found '%c%c%c%c'", pos[0], pos[1], pos[2], pos[3]);
                        return false;
                  }
                  pos += 4;

            }

            // Ok it's an XMIDI.
            // We're going to identify and store the location for each track.
            if (_num_tracks > ARRAYSIZE(_tracks)) {
                  warning("Can only handle %d tracks but was handed %d", (int) ARRAYSIZE(_tracks), (int) _num_tracks);
                  return false;
            }

            int tracks_read = 0;
            while (tracks_read < _num_tracks) {
                  if (!memcmp(pos, "FORM", 4)) {
                        // Skip this plus the 4 bytes after it.
                        pos += 8;
                  } else if (!memcmp(pos, "XMID", 4)) {
                        // Skip this.
                        pos += 4;
                  } else if (!memcmp(pos, "TIMB", 4)) {
                        // Custom timbres?
                        // We don't support them.
                        // Read the length, skip it, and hope there was nothing there.
                        pos += 4;
                        len = read4high(pos);
                        pos += (len + 1) & ~1;
                  } else if (!memcmp(pos, "EVNT", 4)) {
                        // Ahh! What we're looking for at last.
                        _tracks[tracks_read] = pos + 8; // Skip the EVNT and length bytes
                        pos += 4;
                        len = read4high(pos);
                        pos += (len + 1) & ~1;
                        ++tracks_read;
                  } else {
                        warning("Hit invalid block '%c%c%c%c' while scanning for track locations", pos[0], pos[1], pos[2], pos[3]);
                        return false;
                  }
            }

            // If we got this far, we successfully established
            // the locations for each of our tracks.
            // Note that we assume the original data passed in
            // will persist beyond this call, i.e. we do NOT
            // copy the data to our own buffer. Take warning....
            _ppqn = 60;
            resetTracking();
            setTempo(500000);
            _inserted_delta = 0;
            setTrack(0);
            return true;
      }

      return false;
}

void MidiParser_XMIDI::resetTracking() {
      MidiParser::resetTracking();
      _inserted_delta = 0;
}

MidiParser *MidiParser::createParser_XMIDI() { return new MidiParser_XMIDI; }

Generated by  Doxygen 1.6.0   Back to index