488 lines
9.8 KiB
C++
488 lines
9.8 KiB
C++
#include "pch.h"
|
|
#include "midi.h"
|
|
|
|
|
|
#include "pb.h"
|
|
#include "pinball.h"
|
|
|
|
Mix_Music* midi::currentMidi;
|
|
|
|
MCIERROR midi::play_pb_theme(int flag)
|
|
{
|
|
if (pb::FullTiltMode)
|
|
{
|
|
return play_ft(track1);
|
|
}
|
|
|
|
MCIERROR result = 0;
|
|
music_stop();
|
|
if (currentMidi)
|
|
result = Mix_PlayMusic(currentMidi, -1);
|
|
|
|
return result;
|
|
}
|
|
|
|
MCIERROR midi::music_stop()
|
|
{
|
|
if (pb::FullTiltMode)
|
|
{
|
|
return stop_ft();
|
|
}
|
|
|
|
return Mix_HaltMusic();
|
|
}
|
|
|
|
int midi::music_init(HWND hwnd)
|
|
{
|
|
if (pb::FullTiltMode)
|
|
{
|
|
return music_init_ft(hwnd);
|
|
}
|
|
|
|
currentMidi = Mix_LoadMUS(pinball::get_rc_string(156, 0));
|
|
return currentMidi != nullptr;
|
|
}
|
|
|
|
MCIERROR midi::restart_midi_seq(LPARAM param)
|
|
{
|
|
if (pb::FullTiltMode)
|
|
{
|
|
return play_ft(active_track);
|
|
}
|
|
|
|
MCIERROR result = 0;
|
|
music_stop();
|
|
if (currentMidi)
|
|
result = Mix_PlayMusic(currentMidi, -1);
|
|
|
|
return result;
|
|
}
|
|
|
|
void midi::music_shutdown()
|
|
{
|
|
if (pb::FullTiltMode)
|
|
{
|
|
music_shutdown_ft();
|
|
return;
|
|
}
|
|
|
|
Mix_FreeMusic(currentMidi);
|
|
}
|
|
|
|
|
|
objlist_class<midi_struct>* midi::TrackList;
|
|
midi_struct *midi::track1, *midi::track2, *midi::track3, *midi::active_track, *midi::active_track2;
|
|
int midi::some_flag1;
|
|
|
|
int midi::music_init_ft(HWND hwnd)
|
|
{
|
|
active_track = nullptr;
|
|
TrackList = new objlist_class<midi_struct>(0, 1);
|
|
|
|
track1 = load_track("taba1");
|
|
track2 = load_track("taba2");
|
|
track3 = load_track("taba3");
|
|
if (!track2)
|
|
track2 = track1;
|
|
if (!track3)
|
|
track3 = track1;
|
|
return 1;
|
|
}
|
|
|
|
void midi::music_shutdown_ft()
|
|
{
|
|
if (active_track)
|
|
stream_close(active_track);
|
|
while (TrackList->GetCount())
|
|
{
|
|
midi_struct* midi = TrackList->Get(0);
|
|
unload_track(midi);
|
|
TrackList->Delete(midi);
|
|
}
|
|
active_track = nullptr;
|
|
delete TrackList;
|
|
}
|
|
|
|
midi_struct* midi::load_track(LPCSTR fileName)
|
|
{
|
|
midi_struct* midi;
|
|
char filePath[256];
|
|
char fileName2[256];
|
|
|
|
lstrcpyA(fileName2, "sound\\");
|
|
lstrcatA(fileName2, fileName);
|
|
pinball::make_path_name(filePath, fileName2, 254u);
|
|
lstrcatA(filePath, ".MDS");
|
|
if (load_file(&midi, filePath, 0, 1))
|
|
return nullptr;
|
|
|
|
if (midi)
|
|
TrackList->Add(midi);
|
|
return midi;
|
|
}
|
|
|
|
int midi::load_file(midi_struct** midi_res, void* filePtrOrPath, int fileSizeP, int flags)
|
|
{
|
|
int returnCode;
|
|
unsigned int fileSize;
|
|
HANDLE mapHandle = nullptr;
|
|
midi_struct* midi = nullptr;
|
|
HANDLE fileHandle = INVALID_HANDLE_VALUE;
|
|
int fileFlag = 0;
|
|
|
|
do
|
|
{
|
|
if ((flags & 3) == 0 || (flags & 3) == 3)
|
|
{
|
|
returnCode = 4;
|
|
break;
|
|
}
|
|
|
|
midi = static_cast<midi_struct*>(LocalAlloc(0x40u, sizeof(midi_struct)));
|
|
if (!midi)
|
|
{
|
|
returnCode = 1;
|
|
break;
|
|
}
|
|
midi->Magic = mmioFOURCC('M', 'D', 'S', 'I');
|
|
midi->StreamHandle = nullptr;
|
|
midi->PreparedBlocksCount = 0;
|
|
|
|
if ((flags & 2) != 0)
|
|
{
|
|
fileSize = fileSizeP;
|
|
}
|
|
else
|
|
{
|
|
fileFlag = 1;
|
|
fileHandle = CreateFileA(static_cast<LPCSTR>(filePtrOrPath), GENERIC_READ, 1u, nullptr, OPEN_EXISTING,
|
|
0x80u, nullptr);
|
|
if (fileHandle == INVALID_HANDLE_VALUE)
|
|
{
|
|
returnCode = 2;
|
|
break;
|
|
}
|
|
|
|
fileSize = GetFileSize(fileHandle, nullptr);
|
|
mapHandle = CreateFileMappingA(fileHandle, nullptr, 2u, 0, 0, nullptr);
|
|
if (!mapHandle)
|
|
{
|
|
returnCode = 2;
|
|
break;
|
|
}
|
|
|
|
filePtrOrPath = MapViewOfFile(mapHandle, 4u, 0, 0, 0);
|
|
if (!filePtrOrPath)
|
|
{
|
|
returnCode = 2;
|
|
break;
|
|
}
|
|
}
|
|
returnCode = read_file(midi, static_cast<riff_header*>(filePtrOrPath), fileSize);
|
|
}
|
|
while (false);
|
|
|
|
|
|
if (returnCode)
|
|
{
|
|
if (midi)
|
|
LocalFree(midi);
|
|
}
|
|
else
|
|
{
|
|
*midi_res = midi;
|
|
}
|
|
|
|
if (fileFlag)
|
|
{
|
|
if (filePtrOrPath)
|
|
UnmapViewOfFile(filePtrOrPath);
|
|
if (mapHandle)
|
|
CloseHandle(mapHandle);
|
|
if (fileHandle != INVALID_HANDLE_VALUE)
|
|
CloseHandle(fileHandle);
|
|
}
|
|
return returnCode;
|
|
}
|
|
|
|
int midi::read_file(midi_struct* midi, riff_header* filePtr, unsigned fileSize)
|
|
{
|
|
auto returnCode = 0;
|
|
|
|
do
|
|
{
|
|
midi->DataPtr1 = nullptr;
|
|
if (fileSize < 12)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
if (filePtr->Riff != mmioFOURCC('R', 'I', 'F', 'F'))
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
if (filePtr->Mids != mmioFOURCC('M', 'I', 'D', 'S'))
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
if (filePtr->FileSize > fileSize - 8)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
if (fileSize - 12 < 8)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
if (filePtr->Fmt != mmioFOURCC('f', 'm', 't', ' '))
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
if (filePtr->FmtSize > fileSize - 12)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
if (filePtr->FmtSize < 12)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
|
|
midi->DwTimeFormat = filePtr->dwTimeFormat;
|
|
midi->CbMaxBuffer = filePtr->cbMaxBuffer;
|
|
midi->DwFlagsFormat = filePtr->dwFlags;
|
|
auto blocksSize = fileSize - 20 - filePtr->FmtSize;
|
|
if (blocksSize < 8)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
|
|
auto dataChunk = reinterpret_cast<riff_data*>(reinterpret_cast<char*>(&filePtr->dwTimeFormat) + filePtr->FmtSize
|
|
);
|
|
if (dataChunk->Data != mmioFOURCC('d','a','t','a'))
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
if (dataChunk->DataSize > blocksSize || dataChunk->DataSize < 4)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
|
|
midi->BlockCount = dataChunk->BlocksPerChunk;
|
|
midi->DataPtr1 = reinterpret_cast<midihdr_tag*>(memory::allocate(
|
|
dataChunk->BlocksPerChunk * (midi->CbMaxBuffer + sizeof(midihdr_tag))));
|
|
if (!midi->DataPtr1)
|
|
{
|
|
returnCode = 1;
|
|
break;
|
|
}
|
|
if (!midi->BlockCount)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
|
|
auto blocksSizeIndex = blocksSize - 12;
|
|
auto srcPtr = dataChunk->Blocks;
|
|
auto* dstPtr = midi->DataPtr1;
|
|
for (auto blockIndex = midi->BlockCount; blockIndex; blockIndex--)
|
|
{
|
|
dstPtr->lpData = reinterpret_cast<LPSTR>(&dstPtr[1]);
|
|
dstPtr->dwBufferLength = midi->CbMaxBuffer;
|
|
dstPtr->dwFlags = 0;
|
|
dstPtr->dwUser = reinterpret_cast<DWORD_PTR>(midi);
|
|
dstPtr->lpNext = nullptr;
|
|
if (blocksSizeIndex < 8)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
|
|
auto blockSize = srcPtr->CbBuffer;
|
|
if (blockSize > midi->CbMaxBuffer || blockSize > blocksSizeIndex - 8)
|
|
{
|
|
returnCode = 3;
|
|
break;
|
|
}
|
|
|
|
if ((midi->DwFlagsFormat & 1) != 0)
|
|
{
|
|
/*Not used in FT, some kind of compression*/
|
|
assertm(false, "Unimplemented code reached");
|
|
/*int a1[16];
|
|
a1[0] = (int)blockDataPtr;
|
|
a1[2] = blockSize;
|
|
a1[1] = blockSize;
|
|
if (!sub_4031A0(a1, dataPtr))
|
|
{
|
|
returnCode = 3; break;
|
|
}*/
|
|
}
|
|
else
|
|
{
|
|
dstPtr->dwBytesRecorded = blockSize;
|
|
memcpy(dstPtr->lpData, srcPtr->AData, blockSize);
|
|
}
|
|
blocksSizeIndex -= blockSize + 8;
|
|
srcPtr = reinterpret_cast<riff_block*>(&srcPtr->AData[blockSize]);
|
|
dstPtr = reinterpret_cast<midihdr_tag*>(reinterpret_cast<char*>(&dstPtr[1]) + midi->CbMaxBuffer);
|
|
}
|
|
}
|
|
while (false);
|
|
|
|
if (returnCode && midi->DataPtr1)
|
|
{
|
|
memory::free(midi->DataPtr1);
|
|
}
|
|
return returnCode;
|
|
}
|
|
|
|
int midi::play_ft(midi_struct* midi)
|
|
{
|
|
int result;
|
|
|
|
stop_ft();
|
|
if (!midi)
|
|
return 0;
|
|
if (some_flag1)
|
|
{
|
|
active_track2 = midi;
|
|
return 0;
|
|
}
|
|
if (stream_open(midi, 1))
|
|
{
|
|
active_track = nullptr;
|
|
result = 0;
|
|
}
|
|
else
|
|
{
|
|
active_track = midi;
|
|
result = 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int midi::stop_ft()
|
|
{
|
|
int returnCode = 0;
|
|
if (active_track)
|
|
returnCode = stream_close(active_track);
|
|
active_track = nullptr;
|
|
return returnCode;
|
|
}
|
|
|
|
int midi::unload_track(midi_struct* midi)
|
|
{
|
|
if (midi->Magic != mmioFOURCC('M', 'D', 'S', 'I'))
|
|
return 6;
|
|
if (midi->StreamHandle)
|
|
stream_close(midi);
|
|
if (midi->DataPtr1)
|
|
{
|
|
memory::free(midi->DataPtr1);
|
|
}
|
|
midi->Magic = mmioFOURCC('d','a','t','a');
|
|
LocalFree(midi);
|
|
return 0;
|
|
}
|
|
|
|
int midi::stream_open(midi_struct* midi, char flags)
|
|
{
|
|
auto returnCode = 0;
|
|
if (midi->Magic != mmioFOURCC('M', 'D', 'S', 'I'))
|
|
return 6;
|
|
|
|
/*UINT puDeviceID = -1;
|
|
auto steamOpenedFg = !midi->StreamHandle;
|
|
MIDIPROPTIMEDIV propdata{8, midi->DwTimeFormat};
|
|
if (steamOpenedFg &&
|
|
!midiStreamOpen(&midi->StreamHandle, &puDeviceID, 1u, reinterpret_cast<DWORD_PTR>(midi_callback), 0,
|
|
CALLBACK_FUNCTION) &&
|
|
!midiStreamProperty(midi->StreamHandle, reinterpret_cast<LPBYTE>(&propdata),MIDIPROP_TIMEDIV | MIDIPROP_SET))
|
|
{
|
|
midihdr_tag* blockPtr = midi->DataPtr1;
|
|
for (auto blockIndex = midi->BlockCount; blockIndex; blockIndex--)
|
|
{
|
|
if (midiOutPrepareHeader(reinterpret_cast<HMIDIOUT>(midi->StreamHandle), blockPtr, sizeof(MIDIHDR)) ||
|
|
midiStreamOut(midi->StreamHandle, blockPtr, sizeof(MIDIHDR)))
|
|
{
|
|
returnCode = 5;
|
|
break;
|
|
}
|
|
|
|
++midi->PreparedBlocksCount;
|
|
blockPtr = reinterpret_cast<midihdr_tag*>(reinterpret_cast<char*>(&blockPtr[1]) + blockPtr->dwBufferLength);
|
|
}
|
|
}
|
|
|
|
if (!returnCode)
|
|
{
|
|
if (!steamOpenedFg && (midi->SomeFlag2 & 4) == 0)
|
|
return 7;
|
|
|
|
midi->SomeFlag2 &= ~2;
|
|
if ((flags & 1) != 0)
|
|
midi->SomeFlag2 |= 2;
|
|
midi->SomeFlag2 &= ~4;
|
|
if (midiStreamRestart(midi->StreamHandle))
|
|
returnCode = 5;
|
|
}
|
|
|
|
if (returnCode && steamOpenedFg)
|
|
{
|
|
if (midi->StreamHandle)
|
|
stream_close(midi);
|
|
}*/
|
|
return returnCode;
|
|
}
|
|
|
|
int midi::stream_close(midi_struct* midi)
|
|
{
|
|
int returnCode = 0;
|
|
|
|
/*if (midi->Magic != mmioFOURCC('M', 'D', 'S', 'I'))
|
|
return 6;
|
|
if (!midi->StreamHandle)
|
|
return 7;
|
|
midi->SomeFlag2 |= 1u;
|
|
if (midiOutReset(reinterpret_cast<HMIDIOUT>(midi->StreamHandle)))
|
|
{
|
|
returnCode = 5;
|
|
midi->SomeFlag2 &= ~1;
|
|
}
|
|
else
|
|
{
|
|
midihdr_tag* blockPtr = midi->DataPtr1;
|
|
for (int i = midi->BlockCount; i; --i)
|
|
{
|
|
midiOutUnprepareHeader(reinterpret_cast<HMIDIOUT>(midi->StreamHandle), blockPtr, sizeof(MIDIHDR));
|
|
blockPtr = reinterpret_cast<midihdr_tag*>(reinterpret_cast<char*>(&blockPtr[1]) + blockPtr->dwBufferLength);
|
|
}
|
|
midiStreamClose(midi->StreamHandle);
|
|
returnCode = 0;
|
|
midi->StreamHandle = nullptr;
|
|
midi->SomeFlag2 = 0;
|
|
}*/
|
|
return returnCode;
|
|
}
|
|
|
|
void midi::midi_callback(HMIDIOUT hmo, UINT wMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
|
|
{
|
|
if (wMsg == 969)
|
|
{
|
|
auto mhdr = reinterpret_cast<LPMIDIHDR>(dwParam1);
|
|
auto midi = reinterpret_cast<midi_struct*>(mhdr->dwUser);
|
|
/*if ((midi->SomeFlag2 & 2) == 0 || (midi->SomeFlag2 & 1) != 0 || midiStreamOut(
|
|
midi->StreamHandle, mhdr, sizeof(MIDIHDR)))
|
|
--midi->PreparedBlocksCount;*/
|
|
}
|
|
}
|