1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include "../openttd.h"

     5

#include "../sound_type.h"

     6

#include "../variables.h"

     7

#include "../debug.h"

     8

#include "libtimidity.h"

     9

#include <fcntl.h>

    10

#include <sys/types.h>

    11

#include <sys/wait.h>

    12

#include <unistd.h>

    13

#include <signal.h>

    14

#include <sys/stat.h>

    15

#include <errno.h>

    16

#include <timidity.h>

    17

#if defined(PSP)

    18

#include <pspaudiolib.h>

    19

#endif /* PSP */

    20

    21

enum MidiState {

    22

	MIDI_STOPPED = 0,

    23

	MIDI_PLAYING = 1,

    24

};

    25

    26

static struct {

    27

	MidIStream *stream;

    28

	MidSongOptions options;

    29

	MidSong *song;

    30

    31

	MidiState status;

    32

	uint32 song_length;

    33

	uint32 song_position;

    34

} _midi;

    35

    36

#if defined(PSP)

    37

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

    38

{

    39

	memset(buf, 0, _reqn * PSP_NUM_AUDIO_CHANNELS);

    40

	if (_midi.status == MIDI_PLAYING) {

    41

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

    42

	}

    43

}

    44

#endif /* PSP */

    45

    46

static FMusicDriver_LibTimidity iFMusicDriver_LibTimidity;

    47

    48

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

    49

{

    50

	_midi.status = MIDI_STOPPED;

    51

    52

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

    53

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

    54

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

    55

		 *  configuration. Who knows that works. */

    56

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

    57

			return "error initializing timidity";

    58

		}

    59

	}

    60

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

    61

    62

	_midi.options.rate = 44100;

    63

	_midi.options.format = MID_AUDIO_S16LSB;

    64

	_midi.options.channels = 2;

    65

#if defined(PSP)

    66

	_midi.options.buffer_size = PSP_NUM_AUDIO_SAMPLES;

    67

#else

    68

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

    69

#endif

    70

    71

#if defined(PSP)

    72

	pspAudioInit();

    73

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

    74

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

    75

#endif /* PSP */

    76

    77

	return NULL;

    78

}

    79

    80

void MusicDriver_LibTimidity::Stop()

    81

{

    82

	if (_midi.status == MIDI_PLAYING) {

    83

		_midi.status = MIDI_STOPPED;

    84

		mid_song_free(_midi.song);

    85

	}

    86

	mid_exit();

    87

}

    88

    89

void MusicDriver_LibTimidity::PlaySong(const char *filename)

    90

{

    91

	_midi.stream = mid_istream_open_file(filename);

    92

	if (_midi.stream == NULL) {

    93

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

    94

		return;

    95

	}

    96

    97

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

    98

	mid_istream_close(_midi.stream);

    99

	_midi.song_length = mid_song_get_total_time(_midi.song);

   100

   101

	if (_midi.song == NULL) {

   102

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

   103

		return;

   104

	}

   105

   106

	mid_song_start(_midi.song);

   107

	_midi.status = MIDI_PLAYING;

   108

}

   109

   110

void MusicDriver_LibTimidity::StopSong()

   111

{

   112

	_midi.status = MIDI_STOPPED;

   113

	mid_song_free(_midi.song);

   114

}

   115

   116

bool MusicDriver_LibTimidity::IsSongPlaying()

   117

{

   118

	if (_midi.status == MIDI_PLAYING) {

   119

		_midi.song_position = mid_song_get_time(_midi.song);

   120

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

   121

			_midi.status = MIDI_STOPPED;

   122

			_midi.song_position = 0;

   123

		}

   124

	}

   125

   126

	return (_midi.status == MIDI_PLAYING);

   127

}

   128

   129

void MusicDriver_LibTimidity::SetVolume(byte vol)

   130

{

   131

	if (_midi.song != NULL)

   132

		mid_song_set_volume(_midi.song, vol);

   133

}