Exemplo n.º 1
0
BOOL CDecompressTrack::ReadUMX(const BYTE* lpStream, DWORD dwMemLength)
	//---------------------------------------------------------------
{
	if ((!lpStream) || (dwMemLength < 0x800))
		return FALSE;
	// Rip Mods from UMX
	if ((bswapLE32(*((DWORD *) (lpStream + 0x20))) < dwMemLength) &&
		(bswapLE32(*((DWORD *) (lpStream + 0x18))) <= dwMemLength - 0x10) &&
		(bswapLE32(*((DWORD *) (lpStream + 0x18))) >= dwMemLength - 0x200)) {
		for (UINT uscan = 0x40; uscan < 0x500; uscan++) {
			DWORD dwScan = bswapLE32(*((DWORD*) (lpStream + uscan)));
			// IT
			if (dwScan == 0x4D504D49) {
				DWORD dwRipOfs = uscan;
				return ReadIT(lpStream + dwRipOfs, dwMemLength - dwRipOfs);
			}
			// S3M
			if (dwScan == 0x4D524353) {
				DWORD dwRipOfs = uscan - 44;
				return ReadS3M(lpStream + dwRipOfs, dwMemLength - dwRipOfs);
			}
			// XM
			if (!_strnicmp((LPCSTR) (lpStream + uscan), "Extended Module", 15)) {
				DWORD dwRipOfs = uscan;
				return ReadXM(lpStream + dwRipOfs, dwMemLength - dwRipOfs);
			}
			// MOD
			if ((uscan > MODMAGIC_OFFSET) && (dwScan == 0x2e4b2e4d)) {
				DWORD dwRipOfs = uscan - MODMAGIC_OFFSET;
				return ReadMod(lpStream + dwRipOfs, dwMemLength - dwRipOfs);
			}
		}
	}
	return FALSE;
}
Exemplo n.º 2
0
BOOL CSoundFile::Create(LPCBYTE lpStream, DWORD dwMemLength)
//----------------------------------------------------------
{
	int i;

	m_nType = MOD_TYPE_NONE;
	m_dwSongFlags = 0;
	m_nChannels = 0;
	m_nMixChannels = 0;
	m_nSamples = 0;
	m_nInstruments = 0;
	m_nFreqFactor = m_nTempoFactor = 128;
	m_nMasterVolume = 128;
	m_nDefaultGlobalVolume = 256;
	m_nGlobalVolume = 256;
	m_nOldGlbVolSlide = 0;
	m_nDefaultSpeed = 6;
	m_nDefaultTempo = 125;
	m_nPatternDelay = 0;
	m_nFrameDelay = 0;
	m_nNextRow = 0;
	m_nRow = 0;
	m_nPattern = 0;
	m_nCurrentPattern = 0;
	m_nNextPattern = 0;
	m_nRestartPos = 0;
	m_nMinPeriod = 16;
	m_nMaxPeriod = 32767;
	m_nSongPreAmp = 0x30;
	m_nPatternNames = 0;
	m_nMaxOrderPosition = 0;
	m_lpszPatternNames = NULL;
	m_lpszSongComments = NULL;
	memset(Ins, 0, sizeof(Ins));
	memset(ChnMix, 0, sizeof(ChnMix));
	memset(Chn, 0, sizeof(Chn));
	memset(Headers, 0, sizeof(Headers));
	memset(Order, 0xFF, sizeof(Order));
	memset(Patterns, 0, sizeof(Patterns));
	memset(m_szNames, 0, sizeof(m_szNames));
	memset(m_MixPlugins, 0, sizeof(m_MixPlugins));
	ResetMidiCfg();
	for (UINT npt=0; npt<MAX_PATTERNS; npt++) PatternSize[npt] = 64;
	for (UINT nch=0; nch<MAX_BASECHANNELS; nch++)
	{
		ChnSettings[nch].nPan = 128;
		ChnSettings[nch].nVolume = 64;
		ChnSettings[nch].dwFlags = 0;
		ChnSettings[nch].szName[0] = 0;
	}
	if (lpStream)
	{
#ifdef MMCMP_SUPPORT
		BOOL bMMCmp = MMCMP_Unpack(&lpStream, &dwMemLength);
#endif
		if ((!ReadXM(lpStream, dwMemLength))
		 && (!ReadS3M(lpStream, dwMemLength))
		 && (!ReadIT(lpStream, dwMemLength))
		 && (!ReadWav(lpStream, dwMemLength))
#ifndef MODPLUG_BASIC_SUPPORT
/* Sequencer File Format Support */
		 && (!ReadABC(lpStream, dwMemLength))
		 && (!ReadMID(lpStream, dwMemLength))
		 && (!ReadPAT(lpStream, dwMemLength))
		 && (!ReadSTM(lpStream, dwMemLength))
		 && (!ReadMed(lpStream, dwMemLength))
		 && (!ReadMTM(lpStream, dwMemLength))
		 && (!ReadMDL(lpStream, dwMemLength))
		 && (!ReadDBM(lpStream, dwMemLength))
		 && (!Read669(lpStream, dwMemLength))
		 && (!ReadFAR(lpStream, dwMemLength))
		 && (!ReadAMS(lpStream, dwMemLength))
		 && (!ReadOKT(lpStream, dwMemLength))
		 && (!ReadPTM(lpStream, dwMemLength))
		 && (!ReadUlt(lpStream, dwMemLength))
		 && (!ReadDMF(lpStream, dwMemLength))
		 && (!ReadDSM(lpStream, dwMemLength))
		 && (!ReadUMX(lpStream, dwMemLength))
		 && (!ReadAMF(lpStream, dwMemLength))
		 && (!ReadPSM(lpStream, dwMemLength))
		 && (!ReadMT2(lpStream, dwMemLength))
#endif // MODPLUG_BASIC_SUPPORT
		 && (!ReadMod(lpStream, dwMemLength))) m_nType = MOD_TYPE_NONE;
#ifdef MMCMP_SUPPORT
		if (bMMCmp)
		{
			GlobalFreePtr(lpStream);
			lpStream = NULL;
		}
#endif
	}
	// Adjust song names
	for (i=0; i<MAX_SAMPLES; i++)
	{
		LPSTR p = m_szNames[i];
		int j = 31;
		p[j] = 0;
		while ((j>=0) && (p[j]<=' ')) p[j--] = 0;
		while (j>=0)
		{
			if (((BYTE)p[j]) < ' ') p[j] = ' ';
			j--;
		}
	}
	// Adjust channels
	for (i=0; i<MAX_BASECHANNELS; i++)
	{
		if (ChnSettings[i].nVolume > 64) ChnSettings[i].nVolume = 64;
		if (ChnSettings[i].nPan > 256) ChnSettings[i].nPan = 128;
		Chn[i].nPan = ChnSettings[i].nPan;
		Chn[i].nGlobalVol = ChnSettings[i].nVolume;
		Chn[i].dwFlags = ChnSettings[i].dwFlags;
		Chn[i].nVolume = 256;
		Chn[i].nCutOff = 0x7F;
	}
	// Checking instruments
	MODINSTRUMENT *pins = Ins;

	for (i=0; i<MAX_INSTRUMENTS; i++, pins++)
	{
		if (pins->pSample)
		{
			if (pins->nLoopEnd > pins->nLength) pins->nLoopEnd = pins->nLength;
			if (pins->nLoopStart + 3 >= pins->nLoopEnd)
			{
				pins->nLoopStart = 0;
				pins->nLoopEnd = 0;
			}
			if (pins->nSustainEnd > pins->nLength) pins->nSustainEnd = pins->nLength;
			if (pins->nSustainStart + 3 >= pins->nSustainEnd)
			{
				pins->nSustainStart = 0;
				pins->nSustainEnd = 0;
			}
		} else
		{
			pins->nLength = 0;
			pins->nLoopStart = 0;
			pins->nLoopEnd = 0;
			pins->nSustainStart = 0;
			pins->nSustainEnd = 0;
		}
		if (!pins->nLoopEnd) pins->uFlags &= ~CHN_LOOP;
		if (!pins->nSustainEnd) pins->uFlags &= ~CHN_SUSTAINLOOP;
		if (pins->nGlobalVol > 64) pins->nGlobalVol = 64;
	}
	// Check invalid instruments
	while ((m_nInstruments > 0) && (!Headers[m_nInstruments])) 
		m_nInstruments--;
	// Set default values
	if (m_nSongPreAmp < 0x20) m_nSongPreAmp = 0x20;
	if (m_nDefaultTempo < 32) m_nDefaultTempo = 125;
	if (!m_nDefaultSpeed) m_nDefaultSpeed = 6;
	m_nMusicSpeed = m_nDefaultSpeed;
	m_nMusicTempo = m_nDefaultTempo;
	m_nGlobalVolume = m_nDefaultGlobalVolume;
	m_nNextPattern = 0;
	m_nCurrentPattern = 0;
	m_nPattern = 0;
	m_nBufferCount = 0;
	m_nTickCount = m_nMusicSpeed;
	m_nNextRow = 0;
	m_nRow = 0;
	if ((m_nRestartPos >= MAX_ORDERS) || (Order[m_nRestartPos] >= MAX_PATTERNS)) m_nRestartPos = 0;
	// Load plugins
	if (gpMixPluginCreateProc)
	{
		for (UINT iPlug=0; iPlug<MAX_MIXPLUGINS; iPlug++)
		{
			if ((m_MixPlugins[iPlug].Info.dwPluginId1)
			 || (m_MixPlugins[iPlug].Info.dwPluginId2))
			{
				gpMixPluginCreateProc(&m_MixPlugins[iPlug]);
				if (m_MixPlugins[iPlug].pMixPlugin)
				{
					m_MixPlugins[iPlug].pMixPlugin->RestoreAllParameters();
				}
			}
		}
	}
	if (m_nType)
	{
		UINT maxpreamp = 0x10+(m_nChannels*8);
		if (maxpreamp > 100) maxpreamp = 100;
		if (m_nSongPreAmp > maxpreamp) m_nSongPreAmp = maxpreamp;
		return TRUE;
	}
	return FALSE;
}
Exemplo n.º 3
0
int main(int argc,char *argv[]){
	STA *stahead,*stap;
	CS *cshead,*csp;
	EV *evp, *evhead=NULL,*evq=NULL;
	int i;
	int skipn,skipnbefore;
	int csnum=0;
	int stationnum;
	int eventn;
	char stemp[100];
	double r,max,min;
	double grade[3];
	FILE *evfp, *opfp;

	if (argc == 1)
	{
		printf("Usage: gsdfmain event_path_list \n");
		return(0);
	}

	evfp=fopen(argv[1],"r");

	if (evfp==NULL)
	{
		printf("Can't open the event path list file!\n");
		return 1;
	}

	/* Read in the model files */
	ReadMod();
	
/* Begin the loop of events	*/
	eventn=0;
	fgets(stemp,100,evfp);
while(!feof(evfp)){

	/* build event chain */
	eventn++;
	evp=(EV *)malloc(EVLEN);	

	sscanf(stemp,"%s %f %f %f %f\n",evp->path,&evp->grv0,&evp->t0, &evp->grv1, &evp->t1);

	if (eventn==1)
	{
		evhead=evp;
		evq=evp;
		evp->n=NULL;
	}
	else
	{
		evq->n=evp;
		evp->n=NULL;
		evq=evp;
	}

	/* Build station chain for this event and fill the event information */
	stahead=CreateStationChain(evp);
	evp->stachain=stahead;

	// Count the number of the staitons for this event
	stap=stahead;
	stationnum=0;
	while (stap!=NULL)
	{
		//printf("%s %f %f %s\n",stap->filename, stap->la, stap->lo, stap->staname);
		stap=stap->n;
		stationnum++;
	}
	printf("Station Number is %d \n", stationnum);
	evp->stationnum=stationnum;

	// Build the cross-correlation meas[0]urement chain 
	cshead=CreateMainCSChain(stahead);
	evp->cschain=cshead;
	csp=cshead;
	skipnbefore=0;
	while (csp!=NULL)
	{
		csp=csp->n;
	}

	// Average the both way measurement
	//AverageBothWay(cshead);


	// Grading the path using common friends and calculate the total grade
	printf("Grading path.....\n");
	pathgrading(cshead);

	ErrLevel(cshead);

	/*
	printf("Grading model.....\n");
	RefModGrading(cshead);
	*/

	/*
	printf("Grading station.....\n");
	StationGrading(evp);
	*/

	printf("Writing output.....\n");
	PrintOutputEV(evp);

	fgets(stemp,100,evfp);
	}  /* End of loop event */

	
/*
	printf("gathering station information.....\n");
	StaInformGather(evhead);
*/

	// Print output
}
Exemplo n.º 4
0
bool module_renderer::ReadMO3(const uint8_t * lpStream, const uint32_t dwMemLength)
//-----------------------------------------------------------
{
    // no valid MO3 file (magic bytes: "MO3")
    if(dwMemLength < 4 || lpStream[0] != 'M' || lpStream[1] != 'O' || lpStream[2] != '3')
            return false;

#ifdef NO_MO3_SUPPORT
    /* As of August 2010, the format revision is 5; Versions > 31 are unlikely to exist in the next few years,
    so we will just ignore those if there's no UNMO3 library to tell us if the file is valid or not
    (avoid log entry with .MOD files that have a song name starting with "MO3" */
    if(lpStream[3] > 31) return false;

#ifdef MODPLUG_TRACKER
    if(m_pModDoc != nullptr) m_pModDoc->AddToLog(GetStrI18N(_TEXT("The file appears to be a MO3 file, but this OpenMPT build does not support loading MO3 files.")));
#endif // MODPLUG_TRACKER
    return false;

#else
    bool bResult = false; // result of trying to load the module, false == fail.

    int iLen = static_cast<int>(dwMemLength);
    void **mo3Stream = (void **)&lpStream;

    // try to load unmo3.dll dynamically.
#ifdef MODPLUG_TRACKER
    CHAR szPath[MAX_PATH];
    strcpy(szPath, theApp.GetAppDirPath());
    _tcsncat(szPath, _TEXT("unmo3.dll"), MAX_PATH - (_tcslen(szPath) + 1));
    HMODULE unmo3 = LoadLibrary(szPath);
#else
    HMODULE unmo3 = LoadLibrary(_TEXT("unmo3.dll"));
#endif // MODPLUG_TRACKER
    if(unmo3 == NULL) // Didn't succeed.
    {
#ifdef MODPLUG_TRACKER
            if(m_pModDoc != nullptr) m_pModDoc->AddToLog(GetStrI18N(_TEXT("Loading MO3 file failed because unmo3.dll could not be loaded.")));
#endif // MODPLUG_TRACKER
    }
    else //case: dll loaded succesfully.
    {
            UNMO3_DECODE UNMO3_Decode = (UNMO3_DECODE)GetProcAddress(unmo3, "UNMO3_Decode");
            UNMO3_FREE UNMO3_Free = (UNMO3_FREE)GetProcAddress(unmo3, "UNMO3_Free");

            if(UNMO3_Decode != NULL && UNMO3_Free != NULL)
            {
                    if(UNMO3_Decode(mo3Stream, &iLen) == 0)
                    {
                            /* if decoding was successful, mo3Stream and iLen will keep the new
                               pointers now. */

                            if(iLen > 0)
                            {
                                    bResult = true;
                                    if ((!ReadXM((const uint8_t *)*mo3Stream, (uint32_t)iLen))
                                    && (!ReadIT((const uint8_t *)*mo3Stream, (uint32_t)iLen))
                                    && (!ReadS3M((const uint8_t *)*mo3Stream, (uint32_t)iLen))
                                    #ifndef FASTSOUNDLIB
                                    && (!ReadMTM((const uint8_t *)*mo3Stream, (uint32_t)iLen))
                                    #endif // FASTSOUNDLIB
                                    && (!ReadMod((const uint8_t *)*mo3Stream, (uint32_t)iLen))) bResult = false;
                            }

                            UNMO3_Free(*mo3Stream);
                    }
            }
            FreeLibrary(unmo3);
    }
    return bResult;
#endif // NO_MO3_SUPPORT
}
Exemplo n.º 5
0
OPENMPT_NAMESPACE_BEGIN


bool CSoundFile::ReadMO3(FileReader &file, ModLoadingFlags loadFlags)
//-------------------------------------------------------------------
{
	file.Rewind();

	// No valid MO3 file (magic bytes: "MO3")
	if(!file.CanRead(8) || !file.ReadMagic("MO3"))
	{
		return false;
	} else if(loadFlags == onlyVerifyHeader)
	{
		return true;
	}

#ifdef NO_MO3
	// As of November 2013, the format revision is 5; Versions > 31 are unlikely to exist in the next few years,
	// so we will just ignore those if there's no UNMO3 library to tell us if the file is valid or not
	// (avoid log entry with .MOD files that have a song name starting with "MO3".
	if(file.ReadUint8() > 31)
	{
		return false;
	}

	AddToLog(GetStrI18N("The file appears to be a MO3 file, but this OpenMPT build does not support loading MO3 files."));
	return false;

#else

	bool result = false;	// Result of trying to load the module, false == fail.

	// Try to load unmo3 dynamically.
	mpt::Library unmo3 = mpt::Library(mpt::LibraryPath::App(MPT_PATHSTRING("unmo3")));

	if(!unmo3.IsValid())
	{
		// Didn't succeed.
		AddToLog(GetStrI18N("Loading MO3 file failed because unmo3.dll could not be loaded."));
	} else
	{
		// Library loaded successfully.
		#if MPT_OS_WINDOWS
			#define UNMO3_API __stdcall
		#else
			#define UNMO3_API 
		#endif
		typedef uint32 (UNMO3_API * UNMO3_GETVERSION)();
		// Decode a MO3 file (returns the same "exit codes" as UNMO3.EXE, eg. 0=success)
		// IN: data/len = MO3 data/len
		// OUT: data/len = decoded data/len (if successful)
		// flags & 1: Don't load samples
		typedef int32 (UNMO3_API * UNMO3_DECODE_OLD)(const void **data, uint32 *len);
		typedef int32 (UNMO3_API * UNMO3_DECODE)(const void **data, uint32 *len, uint32 flags);
		// Free the data returned by UNMO3_Decode
		typedef void (UNMO3_API * UNMO3_FREE)(const void *data);
		#undef UNMO3_API

		UNMO3_GETVERSION UNMO3_GetVersion = nullptr;
		UNMO3_DECODE_OLD UNMO3_Decode_Old = nullptr;
		UNMO3_DECODE UNMO3_Decode = nullptr;
		UNMO3_FREE UNMO3_Free = nullptr;
		unmo3.Bind(UNMO3_GetVersion, "UNMO3_GetVersion");
		if(UNMO3_GetVersion == nullptr)
		{
			// Old API version: No "flags" parameter.
			unmo3.Bind(UNMO3_Decode_Old, "UNMO3_Decode");
		} else
		{
			unmo3.Bind(UNMO3_Decode, "UNMO3_Decode");
		}
		unmo3.Bind(UNMO3_Free, "UNMO3_Free");
		if((UNMO3_Decode != nullptr || UNMO3_Decode_Old != nullptr) && UNMO3_Free != nullptr)
		{
			file.Rewind();
			const void *stream = file.GetRawData();
			uint32 length = mpt::saturate_cast<uint32>(file.GetLength());

			int32 unmo3result;
			if(UNMO3_Decode != nullptr)
			{
				unmo3result = UNMO3_Decode(&stream, &length, (loadFlags & loadSampleData) ? 0 : 1);
			} else
			{
				// Old API version: No "flags" parameter.
				unmo3result = UNMO3_Decode_Old(&stream, &length);
			}

			if(unmo3result == 0)
			{
				// If decoding was successful, stream and length will keep the new pointers now.
				FileReader unpackedFile(stream, length);

				result = ReadXM(unpackedFile, loadFlags)
					|| ReadIT(unpackedFile, loadFlags)
					|| ReadS3M(unpackedFile, loadFlags)
					|| ReadMTM(unpackedFile, loadFlags)
					|| ReadMod(unpackedFile, loadFlags)
					|| ReadM15(unpackedFile, loadFlags);
				if(result)
				{
					m_ContainerType = MOD_CONTAINERTYPE_MO3;
				}

				UNMO3_Free(stream);
			}
		}
	}
	return result;
#endif // NO_MO3
}