Logo Search packages:      
Sourcecode: scummvm version File versions  Download package

sound.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/tags/release-0-11-1/engines/agi/sound.h $
 * $Id: sound.h 30944 2008-02-23 22:50:18Z sev $
 *
 */

#ifndef AGI_SOUND_H
#define AGI_SOUND_H

#include "agi/agi.h"
#include "sound/audiostream.h"
#include "sound/mixer.h"
#include "common/frac.h"

namespace Agi {

#define BUFFER_SIZE     410
#define IIGS_BUFFER_SIZE 200

#define SOUND_EMU_NONE  0
#define SOUND_EMU_PC    1
#define SOUND_EMU_TANDY 2
#define SOUND_EMU_MAC   3
#define SOUND_EMU_AMIGA 4
#define SOUND_EMU_APPLE2GS 5

#define WAVEFORM_SIZE   64
#define ENV_ATTACK      10000       /**< envelope attack rate */
#define ENV_DECAY       1000        /**< envelope decay rate */
#define ENV_SUSTAIN     100         /**< envelope sustain level */
#define ENV_RELEASE     7500        /**< envelope release rate */
#define NUM_CHANNELS    7           /**< number of sound channels */

// MIDI command values (Shifted right by 4 so they're in the lower nibble)
#define MIDI_CMD_NOTE_OFF        0x08
#define MIDI_CMD_NOTE_ON         0x09
#define MIDI_CMD_CONTROLLER      0x0B
#define MIDI_CMD_PROGRAM_CHANGE  0x0C
#define MIDI_CMD_PITCH_WHEEL     0x0E
// Whole MIDI byte values (Command and channel info together)
#define MIDI_BYTE_STOP_SEQUENCE  0xFC
#define MIDI_BYTE_TIMER_SYNC     0xF8

struct IIgsEnvelopeSegment {
      uint8 bp;
      uint16 inc; ///< 8b.8b fixed point, very probably little endian
};

#define ENVELOPE_SEGMENT_COUNT 8
struct IIgsEnvelope {
      IIgsEnvelopeSegment seg[ENVELOPE_SEGMENT_COUNT];

      /** Reads an Apple IIGS envelope from then given stream. */
      bool read(Common::SeekableReadStream &stream);
};

// 2**(1/12) i.e. the 12th root of 2
#define SEMITONE 1.059463094359295

// C6's frequency is A4's (440 Hz) frequency but one full octave and three semitones higher
// i.e. C6_FREQ = 440 * pow(2.0, 15/12.0)
#define C6_FREQ 1046.502261202395

// Size of the SIERRASTANDARD file (i.e. the wave file i.e. the sample data used by the instruments).
#define SIERRASTANDARD_SIZE 65536

// Maximum number of instruments in an Apple IIGS instrument set.
// Chosen empirically based on Apple IIGS AGI game data, increase if needed.
#define MAX_INSTRUMENTS 28

struct IIgsWaveInfo {
      uint8 top;
      uint addr;
      uint size;
// Oscillator channel
#define OSC_CHANNEL_RIGHT 0
#define OSC_CHANNEL_LEFT  1
      uint channel;
// Oscillator mode
#define OSC_MODE_LOOP     0
#define OSC_MODE_ONESHOT  1
#define OSC_MODE_SYNC_AM  2
#define OSC_MODE_SWAP     3
      uint mode;
      bool halt;
      int16 relPitch; ///< Relative pitch in semitones (Signed 8b.8b fixed point)

      /** Reads an Apple IIGS wave information structure from the given stream. */
      bool read(Common::SeekableReadStream &stream, bool ignoreAddr = false);
      bool finalize(Common::SeekableReadStream &uint8Wave);
};

// Number of waves per Apple IIGS sound oscillator
#define WAVES_PER_OSCILLATOR 2

/** An Apple IIGS sound oscillator. Consists always of two waves. */
00116 struct IIgsOscillator {
      IIgsWaveInfo waves[WAVES_PER_OSCILLATOR];

      bool finalize(Common::SeekableReadStream &uint8Wave);
};

// Maximum number of oscillators in an Apple IIGS instrument.
// Chosen empirically based on Apple IIGS AGI game data, increase if needed.
#define MAX_OSCILLATORS 4

/** An Apple IIGS sound oscillator list. */
00127 struct IIgsOscillatorList {
00128       uint count; ///< Oscillator count
00129       IIgsOscillator osc[MAX_OSCILLATORS]; ///< The oscillators

      /** Indexing operators for easier access to the oscillators. */
00132       const IIgsOscillator &operator()(uint index) const { return osc[index]; }     
      IIgsOscillator &operator()(uint index) { return osc[index]; }
      
      /** Reads an Apple IIGS oscillator list from the given stream. */
      bool read(Common::SeekableReadStream &stream, uint oscillatorCount, bool ignoreAddr = false);
      bool finalize(Common::SeekableReadStream &uint8Wave);
};

struct IIgsInstrumentHeader {
      IIgsEnvelope env;
      uint8 relseg;
      uint8 bendrange;
      uint8 vibdepth;
      uint8 vibspeed;
      IIgsOscillatorList oscList;

      /**
       * Read an Apple IIGS instrument header from the given stream.
       * @param stream The source stream from which to read the data.
       * @param ignoreAddr Should we ignore wave infos' wave address variable's value?
       * @return True if successful, false otherwise.
       */
      bool read(Common::SeekableReadStream &stream, bool ignoreAddr = false);
      bool finalize(Common::SeekableReadStream &uint8Wave);
};

struct IIgsSampleHeader {
      uint16 type;
      uint8  pitch; ///< Logarithmic, base is 2**(1/12), unknown multiplier (Possibly in range 1040-1080)
      uint8  unknownByte_Ofs3; // 0x7F in Gold Rush's sound resource 60, 0 in all others.
      uint8  volume; ///< Current guess: Logarithmic in 6 dB steps
      uint8  unknownByte_Ofs5; ///< 0 in all tested samples.
      uint16 instrumentSize; ///< Little endian. 44 in all tested samples. A guess.
      uint16 sampleSize; ///< Little endian. Accurate in all tested samples excluding Manhunter I's sound resource 16.
      IIgsInstrumentHeader instrument;

      /**
       * Read an Apple IIGS AGI sample header from the given stream.
       * @param stream The source stream from which to read the data.
       * @return True if successful, false otherwise.
       */
      bool read(Common::SeekableReadStream &stream);
      bool finalize(Common::SeekableReadStream &uint8Wave);
};

/**
 * AGI sound note structure.
 */
00180 struct AgiNote {
00181       uint16 duration;    ///< Note duration
00182       uint16 freqDiv;     ///< Note frequency divisor (10-bit)
00183       uint8  attenuation; ///< Note volume attenuation (4-bit)

      /** Reads an AgiNote through the given pointer. */
00186       void read(const uint8 *ptr) {
            duration = READ_LE_UINT16(ptr);
            uint16 freqByte0 = *(ptr + 2); // Bits 4-9 of the frequency divisor
            uint16 freqByte1 = *(ptr + 3); // Bits 0-3 of the frequency divisor
            // Merge the frequency divisor's bits together into a single variable
            freqDiv = ((freqByte0 & 0x3F) << 4) | (freqByte1 & 0x0F);
            attenuation = *(ptr + 4) & 0x0F;
      }
};

struct IIgsChannelInfo {
      IIgsInstrumentHeader ins; ///< Instrument info
      const int16 *sample; ///< Source sample data (16-bit signed format)
      frac_t pos;     ///< Current sample position
      frac_t posAdd;  ///< Current sample position adder (Calculated using note, vibrato etc)
      frac_t note;    ///< Note
      frac_t vol;     ///< Current volume (Takes both channel volume and enveloping into account)
      frac_t chanVol; ///< Channel volume
      frac_t startEnvVol; ///< Starting envelope volume
      frac_t envVol;  ///< Current envelope volume
      uint   envSeg;  ///< Current envelope segment
      uint   size;    ///< Sample size
      bool   loop;    ///< Should we loop the sample?
      bool   end;     ///< Has the playing ended?
};

      /**
       * AGI sound resource types.
       * It's probably coincidence that all the values here are powers of two
       * as they're simply the different used values in AGI sound resources'
       * starts (The first 16-bit little endian word, to be precise).
       */
      enum AgiSoundType {
            AGI_SOUND_SAMPLE  = 0x0001,
            AGI_SOUND_MIDI          = 0x0002,
            AGI_SOUND_4CHN          = 0x0008
      };
      enum AgiSoundFlags {
            AGI_SOUND_LOOP          = 0x0001,
            AGI_SOUND_ENVELOPE      = 0x0002
      };
      enum AgiSoundEnv {
            AGI_SOUND_ENV_ATTACK    = 3,
            AGI_SOUND_ENV_DECAY           = 2,
            AGI_SOUND_ENV_SUSTAIN   = 1,
            AGI_SOUND_ENV_RELEASE   = 0
      };
/**
 * AGI engine sound channel structure.
 */
00236 struct ChannelInfo {
      AgiSoundType type;
      const uint8 *ptr; // Pointer to the AgiNote data
      const int16 *ins;
      int32 size;
      uint32 phase;
      uint32 flags;     // ORs values from AgiSoundFlags
      AgiSoundEnv adsr;
      int32 timer;
      uint32 end;
      uint32 freq;
      uint32 vol;
      uint32 env;
};

class SoundMgr;

/**
 * AGI sound resource structure.
 */
00256 class AgiSound {
public:
      AgiSound(SoundMgr &manager) : _manager(manager), _isPlaying(false), _isValid(false) {}
      virtual ~AgiSound() {}
      virtual void play()      { _isPlaying = true; }
      virtual void stop()      { _isPlaying = false; }
      virtual bool isPlaying() { return _isPlaying; }
      virtual uint16 type() = 0;

      /**
       * A named constructor for creating different types of AgiSound objects
       * from a raw sound resource.
       *
       * NOTE: This function should take responsibility for freeing the raw resource
       * from memory using free() or delegate the responsibility onwards to some other
       * function!
       */
      static AgiSound *createFromRawResource(uint8 *data, uint32 len, int resnum, SoundMgr &manager);

protected:
00276       SoundMgr &_manager; ///< AGI sound manager object
00277       bool _isPlaying;    ///< Is the sound playing?
00278       bool _isValid;      ///< Is this a valid sound object?
};

class PCjrSound : public AgiSound {
public:
      PCjrSound(uint8 *data, uint32 len, int resnum, SoundMgr &manager);
      ~PCjrSound() { if (_data != NULL) free(_data); }
      virtual uint16 type() { return _type; }
      const uint8 *getVoicePointer(uint voiceNum);
protected:
      uint8 *_data; ///< Raw sound resource data
      uint32 _len;  ///< Length of the raw sound resource
      uint16 _type; ///< Sound resource type
};

class IIgsMidi : public AgiSound {
public:
      IIgsMidi(uint8 *data, uint32 len, int resnum, SoundMgr &manager);
      ~IIgsMidi() { if (_data != NULL) free(_data); }
      virtual uint16 type() { return _type; }
      virtual const uint8 *getPtr() { return _ptr; }
      virtual void setPtr(const uint8 *ptr) { _ptr = ptr; }
      virtual void rewind() { _ptr = _data + 2; }
protected:
      uint8 *_data; ///< Raw sound resource data
      const uint8 *_ptr; ///< Pointer to the current position in the MIDI data
      uint32 _len; ///< Length of the raw sound resource
      uint16 _type; ///< Sound resource type
};

class IIgsSample : public AgiSound {
public:
      IIgsSample(uint8 *data, uint32 len, int resnum, SoundMgr &manager);
      ~IIgsSample() { delete[] _sample; }
      virtual uint16 type() { return _header.type; }
      const IIgsSampleHeader &getHeader() const { return _header; }
      const int16 *getSample() const { return _sample; }
protected:
      IIgsSampleHeader _header; ///< Apple IIGS AGI sample header
      int16 *_sample;           ///< Sample data (16-bit signed format)
};

/** Apple IIGS AGI instrument set information. */
00321 struct instrumentSetInfo {
00322       uint byteCount;          ///< Length of the whole instrument set in bytes
00323       uint instCount;          ///< Amount of instrument in the set
00324       const char *md5;         ///< MD5 hex digest of the whole instrument set
00325       const char *waveFileMd5; ///< MD5 hex digest of the wave file (i.e. the sample data used by the instruments)
};

/** Apple IIGS AGI executable file information. */
00329 struct IIgsExeInfo {
00330       enum AgiGameID gameid;            ///< Game ID
00331       const char *exePrefix;            ///< Prefix of the Apple IIGS AGI executable (e.g. "SQ", "PQ", "KQ4" etc)
00332       uint agiVer;                      ///< Apple IIGS AGI version number, not strictly needed
00333       uint exeSize;                     ///< Size of the Apple IIGS AGI executable file in bytes
00334       uint instSetStart;                ///< Starting offset of the instrument set inside the executable file
00335       const instrumentSetInfo &instSet; ///< Information about the used instrument set
};

class AgiEngine;
class AgiBase;

class SoundMgr : public Audio::AudioStream {
      AgiBase *_vm;

public:
      SoundMgr(AgiBase *agi, Audio::Mixer *pMixer);
      ~SoundMgr();
      virtual void setVolume(uint8 volume);

      // AudioStream API
      int readBuffer(int16 *buffer, const int numSamples) {
            premixerCall(buffer, numSamples / 2);
            return numSamples;
      }

      bool isStereo() const {
            return false;
      }

      bool endOfData() const {
            return false;
      }

      int getRate() const {
            // FIXME: Ideally, we should use _sampleRate.
            return 22050;
      }

private:
      Audio::Mixer *_mixer;
      Audio::SoundHandle _soundHandle;
      uint32 _sampleRate;

      bool _playing;
      ChannelInfo _chn[NUM_CHANNELS];
      IIgsChannelInfo _IIgsChannel;
      int _endflag;
      int _playingSound;
      uint8 _env;

      int16 *_sndBuffer;
      const int16 *_waveform;

      void premixerCall(int16 *buf, uint len);

public:
      void unloadSound(int);
      void playSound();
      int initSound();
      void deinitSound();
      void startSound(int, int);
      void stopSound();
      void stopNote(int i);
      void playNote(int i, int freq, int vol);
      void playAgiSound();
      uint32 mixSound();
      bool loadInstruments();
      void playMidiSound();
      void playSampleSound();
      bool finalizeInstruments(Common::SeekableReadStream &uint8Wave);
      Audio::AudioStream *makeIIgsSampleStream(Common::SeekableReadStream &stream, int resnum = -1);
      const IIgsExeInfo *getIIgsExeInfo(enum AgiGameID gameid) const;
      bool loadInstrumentHeaders(const Common::String &exePath, const IIgsExeInfo &exeInfo);
      bool convertWave(Common::SeekableReadStream &source, int16 *dest, uint length);
      Common::MemoryReadStream *loadWaveFile(const Common::String &wavePath, const IIgsExeInfo &exeInfo);
};

} // End of namespace Agi

#endif /* AGI_SOUND_H */

Generated by  Doxygen 1.6.0   Back to index