1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include "../openttd.h"

     5

#include "../sound.h"

     6

#include "../string.h"

     7

#include "../variables.h"

     8

#include "../debug.h"

     9

#include "libtimidity.h"

    10

#include <fcntl.h>

    11

#include <sys/types.h>

    12

#include <sys/wait.h>

    13

#include <unistd.h>

    14

#include <signal.h>

    15

#include <sys/stat.h>

    16

#include <errno.h>

    17

#include <timidity.h>

    18

#if defined(PSP)

    19

#include <pspaudiolib.h>

    20

#endif /* PSP */

    21

    22

enum MidiState {

    23

	MIDI_STOPPED = 0,

    24

	MIDI_PLAYING = 1,

    25

};

    26

    27

static struct {

    28

	MidIStream *stream;

    29

	MidSongOptions options;

    30

	MidSong *song;

    31

    32

	MidiState status;

    33

	uint32 song_length;

    34

	uint32 song_position;

    35

} _midi;

    36

    37

#if defined(PSP)

    38

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

    39

{

    40

	memset(buf, 0, _reqn * PSP_NUM_AUDIO_CHANNELS);

    41

	if (_midi.status == MIDI_PLAYING) {

    42

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

    43

	}

    44

}

    45

#endif /* PSP */

    46

    47

static FMusicDriver_LibTimidity iFMusicDriver_LibTimidity;

    48

    49

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

    50

{

    51

	_midi.status = MIDI_STOPPED;

    52

    53

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

    54

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

    55

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

    56

		 *  configuration. Who knows that works. */

    57

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

    58

			return "error initializing timidity";

    59

		}

    60

	}

    61

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

    62

    63

	_midi.options.rate = 44100;

    64

	_midi.options.format = MID_AUDIO_S16LSB;

    65

	_midi.options.channels = 2;

    66

#if defined(PSP)

    67

	_midi.options.buffer_size = PSP_NUM_AUDIO_SAMPLES;

    68

#else

    69

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

    70

#endif

    71

    72

#if defined(PSP)

    73

	pspAudioInit();

    74

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

    75

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

    76

#endif /* PSP */

    77

    78

	return NULL;

    79

}

    80

    81

void MusicDriver_LibTimidity::Stop()

    82

{

    83

	if (_midi.status == MIDI_PLAYING) {

    84

		_midi.status = MIDI_STOPPED;

    85

		mid_song_free(_midi.song);

    86

	}

    87

	mid_exit();

    88

}

    89

    90

void MusicDriver_LibTimidity::PlaySong(const char *filename)

    91

{

    92

	_midi.stream = mid_istream_open_file(filename);

    93

	if (_midi.stream == NULL) {

    94

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

    95

		return;

    96

	}

    97

    98

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

    99

	mid_istream_close(_midi.stream);

   100

	_midi.song_length = mid_song_get_total_time(_midi.song);

   101

   102

	if (_midi.song == NULL) {

   103

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

   104

		return;

   105

	}

   106

   107

	mid_song_start(_midi.song);

   108

	_midi.status = MIDI_PLAYING;

   109

}

   110

   111

void MusicDriver_LibTimidity::StopSong()

   112

{

   113

	_midi.status = MIDI_STOPPED;

   114

	mid_song_free(_midi.song);

   115

}

   116

   117

bool MusicDriver_LibTimidity::IsSongPlaying()

   118

{

   119

	if (_midi.status == MIDI_PLAYING) {

   120

		_midi.song_position = mid_song_get_time(_midi.song);

   121

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

   122

			_midi.status = MIDI_STOPPED;

   123

			_midi.song_position = 0;

   124

		}

   125

	}

   126

   127

	return (_midi.status == MIDI_PLAYING);

   128

}

   129

   130

void MusicDriver_LibTimidity::SetVolume(byte vol)

   131

{

   132

	if (_midi.song != NULL)

   133

		mid_song_set_volume(_midi.song, vol);

   134

}