// ConverterInit // // Open the input file // Allocate and read the entire input file into memory // Validate the input file structure // Allocate the input track structures and initialize them // Initialize the output track structures // // Return TRUE on success // Prints its own error message if something goes wrong // BOOL ConverterInit( LPSTR szInFile ) { BOOL fRet = TRUE; DWORD cbRead, dwTag, cbHeader, dwToRead; MIDIFILEHDR Header; PINTRACKSTATE ptsTrack; UINT idx; tkCurrentTime = 0; // Initialize things we'll try to free later if we fail // memset( &ifs, 0, sizeof(INFILESTATE)); ifs.cbFileLength = 0; ifs.pitsTracks = NULL; // Attempt to open the input and output files // MidiData = (byte *)COM_LoadHunkFile2((char *)szInFile, (int *)&ifs.cbFileLength); if (!MidiData) { goto Init_Cleanup; } MidiOffset = 0; MidiSize = ifs.cbFileLength; /* hInFile = CreateFile( szInFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if( hInFile == INVALID_HANDLE_VALUE ) { wsprintf( szTemp, "Could not open \"%s\" for read.\n", szInFile ); MessageBox( GetActiveWindow(), szTemp, "TEST", MB_OK | MB_ICONEXCLAMATION ); goto Init_Cleanup; } */ // Figure out how big the input file is. /* if((( ifs.cbFileLength = GetFileSize( hInFile, NULL )) == (UINT)-1 )) { MessageBox( GetActiveWindow(), "File system error on input file.\n", "TEST", MB_OK | MB_ICONEXCLAMATION ); goto Init_Cleanup; }*/ // Set up to read from the memory buffer. Read and validate // - MThd header // - size of file header chunk // - file header itself // if( GetInFileData( &dwTag, sizeof(DWORD)) || ( dwTag != MThd ) || GetInFileData( &cbHeader, sizeof(DWORD)) || (( cbHeader = DWORDSWAP( cbHeader )) < sizeof(MIDIFILEHDR)) || GetInFileData( &Header, cbHeader ) ) { Con_Printf("MIDI: %s\n",szInitErrInFile); goto Init_Cleanup; } // File header is stored in hi-lo order. Swap this into Intel order and save // parameters in our native int size (32 bits) // ifs.dwFormat = (DWORD)WORDSWAP( Header.wFormat ); ifs.dwTrackCount = (DWORD)WORDSWAP( Header.wTrackCount ); ifs.dwTimeDivision = (DWORD)WORDSWAP( Header.wTimeDivision ); // We know how many tracks there are; allocate the structures for them and parse // them. The parse merely looks at the MTrk signature and track chunk length // in order to skip to the next track header. // ifs.pitsTracks = (PINTRACKSTATE)GlobalAllocPtr( GPTR, ifs.dwTrackCount * sizeof(INTRACKSTATE)); if( ifs.pitsTracks == NULL ) { Con_Printf("MIDI: %s\n",szInitErrMem); goto Init_Cleanup; } for( idx = 0, ptsTrack = ifs.pitsTracks; idx < ifs.dwTrackCount; ++idx, ++ptsTrack ) { if(( ptsTrack->pTrackStart = GlobalAllocPtr( GHND, TRACK_BUFFER_SIZE )) == NULL ) { Con_Printf("MIDI: %s\n", szNoTrackBuffMem); goto Init_Cleanup; } if( GetInFileData( &dwTag, sizeof(dwTag)) || ( dwTag != MTrk ) || GetInFileData( &cbHeader, sizeof(cbHeader))) { Con_Printf("MIDI: %s\n", szInitErrInFile); goto Init_Cleanup; } cbHeader = DWORDSWAP( cbHeader ); ptsTrack->dwTrackLength = cbHeader; // Total track length /////////////////////////////////////////////////////////////////////////////// // Here we need to determine if all track data will fit into a single one of // our track buffers. If not, we need to read in a buffer full and come back // for more later, saving the file offset to continue from and the amount left // to read in the track structure. // Save the file offset of the beginning of this track /* ptsTrack->foTrackStart = SetFilePointer( hInFile, 0, NULL, FILE_CURRENT );*/ ptsTrack->foTrackStart = SetFilePointer2( 0, NULL, FILE_CURRENT ); if( ptsTrack->dwTrackLength > TRACK_BUFFER_SIZE ) dwToRead = TRACK_BUFFER_SIZE; else dwToRead = ptsTrack->dwTrackLength; /* if( !ReadFile( hInFile, ptsTrack->pTrackStart, dwToRead, &cbRead, NULL ) || ( cbRead != dwToRead )) { MessageBox( GetActiveWindow(), szInitErrInFile, "TEST", MB_OK | MB_ICONEXCLAMATION ); goto Init_Cleanup; }*/ if( !ReadFile2( ptsTrack->pTrackStart, dwToRead, &cbRead, NULL ) || ( cbRead != dwToRead )) { Con_Printf("MIDI: %s\n", szInitErrInFile); goto Init_Cleanup; } // Save the number of bytes that didn't make it into the buffer ptsTrack->dwLeftOnDisk = ptsTrack->dwTrackLength - cbRead; ptsTrack->dwLeftInBuffer = cbRead; // Save the current file offset so we can seek to it later /* ptsTrack->foNextReadStart = SetFilePointer( hInFile, 0, NULL, FILE_CURRENT );*/ ptsTrack->foNextReadStart = SetFilePointer2( 0, NULL, FILE_CURRENT ); // Setup pointer to the current position in the track ptsTrack->pTrackCurrent = ptsTrack->pTrackStart; ptsTrack->fdwTrack = 0; ptsTrack->byRunningStatus = 0; ptsTrack->tkNextEventDue = 0; // Handle bozo MIDI files which contain empty track chunks // if( !ptsTrack->dwLeftInBuffer && !ptsTrack->dwLeftOnDisk ) { ptsTrack->fdwTrack |= ITS_F_ENDOFTRK; continue; } // We always preread the time from each track so the mixer code can // determine which track has the next event with a minimum of work // if( GetTrackVDWord( ptsTrack, &ptsTrack->tkNextEventDue )) { Con_Printf("MIDI: %s\n", szInitErrInFile); goto Init_Cleanup; } // Step over any unread data, advancing to the beginning of the next // track's data /* SetFilePointer( hInFile, ptsTrack->foTrackStart + ptsTrack->dwTrackLength, NULL, FILE_BEGIN );*/ SetFilePointer2( ptsTrack->foTrackStart + ptsTrack->dwTrackLength, NULL, FILE_BEGIN ); } // End of track initialization code fRet = FALSE; Init_Cleanup: if( fRet ) ConverterCleanup(); return( fRet ); }
// ---- // Init (stand-alone version) // // Open the input and output files // Allocate and read the entire input file into memory // Validate the input file structure // Allocate the input track structures and initialize them // Initialize the output track structures // // Return TRUE on success // Prints its own error message if something goes wrong // // ---- static BOOL Init(LPSTR szInFile, LPSTR szOutFile) { BOOL fRet = FALSE; LONG cbRead; UINT32 *pChunkID; UINT32 *pChunkSize; LONG iChunkSize; LPMIDIFILEHDR pHeader; LPINTRACKSTATE pInTrack; UINT iTrack; // Initialize things we'll try to free later if we fail // ifs.FileSize = 0; ifs.pFile = NULL; //ifs.pTracks = NULL; // Attempt to open the input and output files // hInFile = CreateFileA(szInFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (INVALID_HANDLE_VALUE == hInFile) { I_OutputMsg("Could not open \"%s\" for read.\n", szInFile); goto Init_Cleanup; } hOutFile = CreateFileA(szOutFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (INVALID_HANDLE_VALUE == hOutFile) { I_OutputMsg("Could not open \"%s\" for write.\n", szOutFile); goto Init_Cleanup; } // Figure out how big the input file is and allocate a chunk of memory big enough // to hold the whole thing. Read the whole file in at once. // if (INVALID_FILE_SIZE == (ifs.FileSize = GetFileSize(hInFile, NULL))) { I_OutputMsg("File system error on input file.\n"); goto Init_Cleanup; } if (NULL == (ifs.pFile = GlobalAllocPtr(GPTR, ifs.FileSize))) { I_OutputMsg("Out of memory.\n"); goto Init_Cleanup; } if ((!ReadFile(hInFile, ifs.pFile, ifs.FileSize, &cbRead, NULL)) || cbRead != ifs.FileSize) { I_OutputMsg("Read error on input file.\n"); goto Init_Cleanup; } // Set up to read from the memory buffer. Read and validate // - MThd header // - size of file header chunk // - file header itself // ifs.iBytesLeft = ifs.FileSize; ifs.pFilePointer = ifs.pFile; // note: midi header size should always be 6 if ((pChunkID = (UINT32*)GetInFileData(sizeof (*pChunkID))) == NULL || *pChunkID != MThd || (pChunkSize = (UINT32*)GetInFileData(sizeof (*pChunkSize))) == NULL || (iChunkSize = LONGSWAP(*pChunkSize)) < sizeof (MIDIFILEHDR) || (pHeader = (LPMIDIFILEHDR)GetInFileData(iChunkSize)) == NULL) { I_OutputMsg("Read error on MIDI header.\n"); goto Init_Cleanup; } // File header is stored in hi-lo order. Swap this into Intel order and save // parameters in our native int size (32 bits) // ifs.dwFormat = (LONG)WORDSWAP(pHeader->wFormat); ifs.nTracks = (LONG)WORDSWAP(pHeader->nTracks); ifs.dwTimeDivision = (LONG)WORDSWAP(pHeader->wTimeDivision); #ifdef DEBUGMIDISTREAM I_OutputMsg("MIDI Header:\n" "------------\n" "format: %d\n" "number of tracks: %d\n" "time division: %d\n", ifs.dwFormat, ifs.nTracks, ifs.dwTimeDivision); #endif // We know how many tracks there are; allocate the structures for them and parse // them. The parse merely looks at the MTrk signature and track chunk length // in order to skip to the next track header. // faB: now static // ifs.pTracks = (INTRACKSTATE *)GlobalAllocPtr(GPTR, ifs.nTracks*sizeof (INTRACKSTATE)); // if (ifs.pTracks == NULL) // { // I_OutputMsg("Out of memory.\n"); // goto Init_Cleanup; // } // faB: made it static, but don't quit if there are more tracks, just skip'em // (this isn't really a limit, since 32 tracks are really the maximum for MIDI files) if (ifs.nTracks > MAX_MIDI_IN_TRACKS) ifs.nTracks = MAX_MIDI_IN_TRACKS; for (iTrack = 0, pInTrack = ifs.pTracks; iTrack < ifs.nTracks; ++iTrack, ++pInTrack) { if ((pChunkID = (UINT32*)GetInFileData(sizeof (*pChunkID))) == NULL || *pChunkID!= MTrk || (pChunkSize = (UINT32*)GetInFileData(sizeof (*pChunkSize))) == NULL) { I_OutputMsg("Read error on track header.\n"); goto Init_Cleanup; } iChunkSize = LONGSWAP(*pChunkSize); pInTrack->iTrackLen = iChunkSize; pInTrack->iBytesLeft = iChunkSize; pInTrack->pTrackData = GetInFileData(iChunkSize); if (pInTrack->pTrackData == NULL) { I_OutputMsg("Read error while reading track data.\n"); goto Init_Cleanup; } #ifdef DEBUGMIDISTREAM I_OutputMsg("Track %d : length %d bytes\n", iTrack, iChunkSize); pInTrack->nTrack = iTrack; #endif pInTrack->pTrackPointer = pInTrack->pTrackData; pInTrack->fdwTrack = 0; pInTrack->bRunningStatus = 0; // Handle bozo MIDI files which contain empty track chunks // if (!pInTrack->iBytesLeft) { pInTrack->fdwTrack |= ITS_F_ENDOFTRK; continue; } // We always preread the time from each track so the mixer code can // determine which track has the next event with a minimum of work // if (!GetTrackVDWord(pInTrack, &pInTrack->tkNextEventDue)) { I_OutputMsg("Read error while reading first delta time of track.\n"); goto Init_Cleanup; } } ots.tkTrack = 0; ots.pFirst = NULL; ots.pLast = NULL; fRet = TRUE; Init_Cleanup: if (!fRet) Cleanup(); return fRet; }
/* ConverterInit * * Open the input file * Allocate and read the entire input file into memory * Validate the input file structure * Allocate the input track structures and initialize them * Initialize the output track structures * * Return zero on success */ int ConverterInit (const char *filename) { int err = 1; DWORD bytes_wanted, bytes_read, magic, bytes; UINT idx; midihdr_t header; track_state_t *ts; currenttime = 0; memset (&mfs, 0, sizeof(midi_filestate_t)); memset (&midi_fh, 0, sizeof(fshandle_t)); if (MID2STREAM_fileopen(filename) != 0) return 1; mfs.length = midi_fh.length; /* Read and validate MThd header, size of file header chunk * and the file header itself. */ if (GetInFileData(&magic, sizeof(DWORD))) goto Init_Cleanup; magic = (DWORD)BigLong(magic); if (magic == MIDI_MAGIC_RIFF) /* RMID ?? */ { if (GetInFileData(&bytes, sizeof(DWORD)) != 0 || /* size */ GetInFileData(&magic, sizeof(DWORD)) != 0 || MIDI_MAGIC_RMID != (DWORD)BigLong(magic) || GetInFileData(&magic, sizeof(DWORD)) != 0 || /* "data" */0x64617461 != (DWORD)BigLong(magic) || GetInFileData(&bytes, sizeof(DWORD)) != 0 || /* size */ /* SMF must begin from here onwards: */ GetInFileData(&magic, sizeof(DWORD)) != 0) { goto Init_Cleanup; } magic = (DWORD)BigLong(magic); } if (magic != MIDI_MAGIC_MTHD) goto Init_Cleanup; if (GetInFileData(&bytes, sizeof(DWORD))) goto Init_Cleanup; if ((bytes = (DWORD)BigLong(bytes)) < sizeof(midihdr_t)) goto Init_Cleanup; if (GetInFileData(&header, bytes)) goto Init_Cleanup; /* File header is stored in big endian (hi-lo) order. */ mfs.format = (DWORD) BigShort(header.format); mfs.numtracks = (DWORD) BigShort(header.numtracks); mfs.timediv = (DWORD) BigShort(header.timediv); if (mfs.format != 0 && mfs.format != 1) /* Type-2 not supported */ goto Init_Cleanup; if (mfs.numtracks == 0) goto Init_Cleanup; if (mfs.format == 0 && mfs.numtracks != 1) goto Init_Cleanup; /* We know how many tracks there are; allocate structures for them * and parse them. The parse merely looks at the MTrk signature and * track chunk length in order to skip to the next track header. */ mfs.tracks = (track_state_t *) Z_Malloc(mfs.numtracks * sizeof(track_state_t), Z_MAINZONE); for (idx = 0, ts = mfs.tracks; idx < mfs.numtracks; ++idx, ++ts) { ts->start_ptr = (BYTE *) Z_Malloc(TRACK_BUFFER_SIZE, Z_MAINZONE); if (GetInFileData(&magic, sizeof(magic))) goto Init_Cleanup; if ((magic = (DWORD)BigLong(magic)) != MIDI_MAGIC_MTRK) goto Init_Cleanup; if (GetInFileData(&bytes, sizeof(bytes))) goto Init_Cleanup; bytes = (DWORD)BigLong(bytes); ts->length = bytes; /* Total track length */ /* Determine whether all track data will fit into a single one of our track * buffers. If not, we need to read in a buffer full and come back for more * later, saving the file offset to continue from and the amount left to read * in the track structure. */ /* Save the file offset of the beginning of this track */ ts->start_ofs = MID2STREAM_seek(0, SEEK_CUR); if (ts->length > TRACK_BUFFER_SIZE) bytes_wanted = TRACK_BUFFER_SIZE; else bytes_wanted = ts->length; MID2STREAM_readfile(ts->start_ptr, bytes_wanted, &bytes_read); if (bytes_read != bytes_wanted) goto Init_Cleanup; /* Save the number of bytes that didn't make it into the buffer */ ts->left_on_disk = ts->length - bytes_read; ts->left_in_buffer = bytes_read; /* Save the current file offset so we can seek to it later */ ts->nextread_ofs = MID2STREAM_seek(0, SEEK_CUR); /* Setup pointer to the current position in the track */ ts->current_ptr = ts->start_ptr; ts->status = 0; ts->running_status = 0; ts->next_event_time = 0; /* Handle bozo MIDI files which contain empty track chunks */ if (!ts->left_in_buffer && !ts->left_on_disk) { ts->status |= ITS_F_ENDOFTRK; continue; } /* always preread the time from each track so the mixer code can * determine which track has the next event with minimum work. */ if (GetTrackVDWord(ts, &ts->next_event_time)) goto Init_Cleanup; /* Step over any unread data, advancing to the beginning of the next * track's data */ MID2STREAM_seek(ts->start_ofs + ts->length, SEEK_SET); } /* End of track initialization code */ err = 0; Init_Cleanup: if (err) { Con_Printf("MIDI: %s\n", err_bad_midi_file); ConverterCleanup(); } return err; }
// ----------------------- // Mid2StreamConverterInit // // Validate the input file structure // Allocate the input track structures and initialize them (faB: now STATIC) // Initialize the output track structures // // Return TRUE on success // ----------------------- BOOL Mid2StreamConverterInit(LPBYTE pMidiData, size_t iMidiSize) { BOOL fRet = TRUE; UINT32 *pChunkID; UINT32 *pChunkSize; UINT32 iChunkSize; LPMIDIFILEHDR pHeader; LPINTRACKSTATE pInTrack; UINT iTrack; tkCurrentTime = 0; // Initialize things we'll try to free later if we fail ZeroMemory(&ifs, sizeof (INFILESTATE)); //ifs.pTracks = NULL; //faB: now static // Set up to read from the memory buffer. Read and validate // - MThd header // - size of file header chunk // - file header itself // ifs.FileSize = iMidiSize; ifs.pFile = pMidiData; ifs.iBytesLeft = ifs.FileSize; ifs.pFilePointer = ifs.pFile; #ifdef DEBUGMIDISTREAM I_OutputMsg("Midi file size: %d\n", iMidiSize); #endif // note: midi header size should always be 6 if ((pChunkID = (UINT32*)GetInFileData(sizeof (*pChunkID))) == NULL || *pChunkID != MThd || (pChunkSize = (UINT32*)GetInFileData(sizeof (*pChunkSize))) == NULL || (iChunkSize = LONGSWAP(*pChunkSize)) < sizeof (MIDIFILEHDR) || (pHeader = (LPMIDIFILEHDR)GetInFileData(iChunkSize)) == NULL) { I_OutputMsg("Read error on MIDI header.\n"); goto Init_Cleanup; } ifs.dwFormat = (LONG)WORDSWAP(pHeader->wFormat); ifs.nTracks = (LONG)WORDSWAP(pHeader->nTracks); ifs.dwTimeDivision = (LONG)WORDSWAP(pHeader->wTimeDivision); #ifdef DEBUGMIDISTREAM I_OutputMsg("MIDI Header:\n" "------------\n" "format: %d\n" "number of tracks: %d\n" "time division: %d\n", ifs.dwFormat, ifs.nTracks, ifs.dwTimeDivision); #endif /* faB: made static ifs.pTracks = (INTRACKSTATE *)GlobalAllocPtr(GPTR, ifs.nTracks*sizeof (INTRACKSTATE)); if (ifs.pTracks == NULL) { I_OutputMsg("Out of memory.\n"); goto Init_Cleanup; } */ // faB: made it static, but don't quit if there are more tracks, just skip'em if (ifs.nTracks > MAX_MIDI_IN_TRACKS) ifs.nTracks = MAX_MIDI_IN_TRACKS; for (iTrack = 0, pInTrack = ifs.pTracks; iTrack < ifs.nTracks; ++iTrack, ++pInTrack) { if ((pChunkID = (UINT32*)GetInFileData(sizeof (*pChunkID))) == NULL || *pChunkID!= MTrk || (pChunkSize = (UINT32*)GetInFileData(sizeof (*pChunkSize))) == NULL) { I_OutputMsg("Read error on track header.\n"); goto Init_Cleanup; } iChunkSize = LONGSWAP(*pChunkSize); pInTrack->iTrackLen = iChunkSize; // Total track length pInTrack->iBytesLeft = iChunkSize; pInTrack->pTrackData = GetInFileData(iChunkSize); if (pInTrack->pTrackData == NULL) { I_OutputMsg("Read error while reading track data.\n"); goto Init_Cleanup; } #ifdef DEBUGMIDISTREAM I_OutputMsg("Track %d : length %d bytes\n", iTrack, iChunkSize); pInTrack->nTrack = iTrack; #endif // Setup pointer to the current position in the track pInTrack->pTrackPointer = pInTrack->pTrackData; pInTrack->fdwTrack = 0; pInTrack->bRunningStatus = BAD_MIDI_FIX; pInTrack->tkNextEventDue = 0; // Handle bozo MIDI files which contain empty track chunks if (!pInTrack->iBytesLeft) { pInTrack->fdwTrack |= ITS_F_ENDOFTRK; continue; } // We always preread the time from each track so the mixer code can // determine which track has the next event with a minimum of work if (!GetTrackVDWord(pInTrack, &pInTrack->tkNextEventDue)) { I_OutputMsg("Read error while reading first delta time of track.\n"); goto Init_Cleanup; } } // End of track initialization code fRet = FALSE; Init_Cleanup: if (fRet) Mid2StreamConverterCleanup(); return fRet; }