1

/* $Id$ */

     2

     3

/** @file libtimidity.cpp Playing music via the timidity library. */

     4

     5

#include "../stdafx.h"

     6

#include "../openttd.h"

     7

#include "../sound_type.h"

     8

#include "../variables.h"

     9

#include "../debug.h"

    10

#include "libtimidity.h"

    11

#include <fcntl.h>

    12

#include <sys/types.h>

    13

#include <sys/wait.h>

    14

#include <unistd.h>

    15

#include <signal.h>

    16

#include <sys/stat.h>

    17

#include <errno.h>

    18

#include <timidity.h>

    19

#if defined(PSP)

    20

#include <pspaudiolib.h>

    21

#endif /* PSP */

    22

    23

enum MidiState {

    24

	MIDI_STOPPED = 0,

    25

	MIDI_PLAYING = 1,

    26

};

    27

    28

static struct {

    29

	MidIStream *stream;

    30

	MidSongOptions options;

    31

	MidSong *song;

    32

    33

	MidiState status;

    34

	uint32 song_length;

    35

	uint32 song_position;

    36

} _midi;

    37

    38

#if defined(PSP)

    39

static void AudioOutCallback(void *buf, unsigned int _reqn, void *userdata)

    40

{

    41

	memset(buf, 0, _reqn * PSP_NUM_AUDIO_CHANNELS);

    42

	if (_midi.status == MIDI_PLAYING) {

    43

		mid_song_read_wave(_midi.song, buf, _reqn * PSP_NUM_AUDIO_CHANNELS);

    44

	}

    45

}

    46

#endif /* PSP */

    47

    48

static FMusicDriver_LibTimidity iFMusicDriver_LibTimidity;

    49

    50

const char *MusicDriver_LibTimidity::Start(const char *const *param)

    51

{

    52

	_midi.status = MIDI_STOPPED;

    53

    54

	if (mid_init(param == NULL ? NULL : (char *)param[0]) < 0) {

    55

		/* If init fails, it can be because no configuration was found.

    56

		 *  If it was not forced via param, try to load it without a

    57

		 *  configuration. Who knows that works. */

    58

		if (param != NULL || mid_init_no_config() < 0) {

    59

			return "error initializing timidity";

    60

		}

    61

	}

    62

	DEBUG(driver, 1, "successfully initialised timidity");

    63

    64

	_midi.options.rate = 44100;

    65

	_midi.options.format = MID_AUDIO_S16LSB;

    66

	_midi.options.channels = 2;

    67

#if defined(PSP)

    68

	_midi.options.buffer_size = PSP_NUM_AUDIO_SAMPLES;

    69

#else

    70

	_midi.options.buffer_size = _midi.options.rate;

    71

#endif

    72

    73

#if defined(PSP)

    74

	pspAudioInit();

    75

	pspAudioSetChannelCallback(_midi.options.channels, &AudioOutCallback, NULL);

    76

	pspAudioSetVolume(_midi.options.channels, PSP_VOLUME_MAX, PSP_VOLUME_MAX);

    77

#endif /* PSP */

    78

    79

	return NULL;

    80

}

    81

    82

void MusicDriver_LibTimidity::Stop()

    83

{

    84

	if (_midi.status == MIDI_PLAYING) {

    85

		_midi.status = MIDI_STOPPED;

    86

		mid_song_free(_midi.song);

    87

	}

    88

	mid_exit();

    89

}

    90

    91

void MusicDriver_LibTimidity::PlaySong(const char *filename)

    92

{

    93

	_midi.stream = mid_istream_open_file(filename);

    94

	if (_midi.stream == NULL) {

    95

		DEBUG(driver, 0, "Could not open music file");

    96

		return;

    97

	}

    98

    99

	_midi.song = mid_song_load(_midi.stream, &_midi.options);

   100

	mid_istream_close(_midi.stream);

   101

	_midi.song_length = mid_song_get_total_time(_midi.song);

   102

   103

	if (_midi.song == NULL) {

   104

		DEBUG(driver, 1, "Invalid MIDI file");

   105

		return;

   106

	}

   107

   108

	mid_song_start(_midi.song);

   109

	_midi.status = MIDI_PLAYING;

   110

}

   111

   112

void MusicDriver_LibTimidity::StopSong()

   113

{

   114

	_midi.status = MIDI_STOPPED;

   115

	mid_song_free(_midi.song);

   116

}

   117

   118

bool MusicDriver_LibTimidity::IsSongPlaying()

   119

{

   120

	if (_midi.status == MIDI_PLAYING) {

   121

		_midi.song_position = mid_song_get_time(_midi.song);

   122

		if (_midi.song_position >= _midi.song_length) {

   123

			_midi.status = MIDI_STOPPED;

   124

			_midi.song_position = 0;

   125

		}

   126

	}

   127

   128

	return (_midi.status == MIDI_PLAYING);

   129

}

   130

   131

void MusicDriver_LibTimidity::SetVolume(byte vol)

   132

{

   133

	if (_midi.song != NULL)

   134

		mid_song_set_volume(_midi.song, vol);

   135

}