DIRECT X : AUDIO

/********************************************************/
/* Nom du Fichier : DX_AUDIO.cpp						*/
/* Description    : Implémentation des fonctions		*/
/********************************************************/
/* Auteur : JANISZEWSKI Jérémy alias MasterShadows		*/
/* Date   : 25 05 2005									*/
/********************************************************/
/* (C) Copyright 2005 - SHADOWS Productions				*/
/********************************************************/

#include "DX_AUDIO.h"


/***************************************************************************************************************/
// Chargement d'un Fichier MP3

CDirectX_Audio_MP3::CDirectX_Audio_MP3()
{
}

CDirectX_Audio_MP3::~CDirectX_Audio_MP3()
{}

/************************************/
/*									*/
/*    Efface l'allocation d'objet   */
/*									*/
/************************************/

void CDirectX_Audio_MP3::vEffacer(void)
{
	vArreter_Musique();
}

/************************************/
/*									*/
/*   Initialisation du graphe et    */
/*   charge le fichier MP3			*/
/*									*/
/************************************/

bool CDirectX_Audio_MP3::bJouer_Audio_MP3(unsigned short* Musique_a_Jouer)
{
	HRESULT hresultat;

	// Initialisation du composant COM
	CoInitialize(NULL);

	// Création du graphe
	CoCreateInstance( CLSID_FilterGraph,
					  NULL,
					  CLSCTX_INPROC_SERVER,
					  IID_IGraphBuilder,
					  (void**)&pIGraph_Builder);

	// Interface d'objets
	pIGraph_Builder->QueryInterface(IID_IMediaControl, (void**)&pIMedia_Control);
	pIGraph_Builder->QueryInterface(IID_IMediaEvent, (void**)&pIMedia_Event);
	pIGraph_Builder->QueryInterface(IID_IMediaSeeking, (void**)&pIMedia_Seeking);

	// Charge le fichier musical
	hresultat = pIGraph_Builder->RenderFile(Musique_a_Jouer, NULL);
	if(hresultat != S_OK)
	{
		return (0);
	}

	// Rapidité de la musique ( <1 -> Lent, 1 -> Normal, >1 -> Rapide)
	pIMedia_Seeking->SetRate(1);

	// Joue la musique
	pIMedia_Control->Run();

	// Musique d'arrière plan
	bBackGroundMusiqueActive = 1;

	return 1;
}

/************************************************/
/*												*/
/*    Fonction qui efface la mémoire allouée    */
/*												*/
/************************************************/

void CDirectX_Audio_MP3::vArreter_Musique()
{
	// Stop la musique si elle est en train d'être jouée
	pIMedia_Control->Stop();

	// On efface tout
	pIMedia_Control->Release();
	pIMedia_Event->Release();
	pIGraph_Builder->Release();
}

/****************************************************/
/*													*/
/*  Fonction qui test le status de la musique pour  */
/*    voir si elle est finie et si elle a besoin    */
/*                d'être redemarré.					*/
/*													*/
/****************************************************/

void CDirectX_Audio_MP3::vCheckStatusMusique(unsigned int Rejoue)
{
	long Evenement_Code;

	pIMedia_Event->WaitForCompletion(0, &Evenement_Code);

	// Si la musique est finie, on la redémarre
	if((Evenement_Code == EC_COMPLETE) && (Rejoue == 1))
	{
		// On met la position à 0.
		LONGLONG lPosition_Depart = 0;

		// On arrête la musique
		pIMedia_Control->Stop();

		// Set les positions
		pIMedia_Seeking->SetPositions(&lPosition_Depart, AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);

		// On rejoue la musique
		pIMedia_Control->Run();
	}
}

/************************************************************************************************************/
// Chargement d'une musique MIDI

CDirectX_Audio_MIDI::CDirectX_Audio_MIDI()
{}

CDirectX_Audio_MIDI::~CDirectX_Audio_MIDI()
{}

/************************************/
/*									*/
/*     Efface les objets alloués    */
/*									*/
/************************************/

void CDirectX_Audio_MIDI::vEffacer( void )
{
	if( pIDMSegment ) {
		if( pIDMPerformance ) 
			pIDMSegment->Unload( pIDMPerformance );
	}
	SAFE_RELEASE( pIDMSegment );

	SAFE_RELEASE( pIDMChargeur );
	SAFE_RELEASE( pIDMPerformance );
}

/**********************************************/
/* 											  */
/* Initialisation du système sonore et charge */
/* des sons variés.							  */
/*											  */
/**********************************************/

bool CDirectX_Audio_MIDI::bInitialisation_Sonore( HWND hWnd, WCHAR* midi_a_jouer )
{
	HRESULT					hResultat;
	IDirectMusicAudioPath8	*dmAP;

	// Initialisation du composant COM
	CoInitialize( NULL );
	
	// Création du chargeur
	if( FAILED( hResultat = CoCreateInstance(CLSID_DirectMusicLoader,
											 NULL,
											 CLSCTX_INPROC,
											 IID_IDirectMusicLoader8,
											 (void**) &pIDMChargeur)))
	{
		return( 0 );
	}
	
	// Creation de la performance
	if( FAILED( hResultat = CoCreateInstance(CLSID_DirectMusicPerformance,
											 NULL,
											 CLSCTX_INPROC,
											 IID_IDirectMusicPerformance8,
											 (void**) &pIDMPerformance)))
	{
		return( 0 );
	}
	
	// Initialisation audio
	if( FAILED( hResultat = pIDMPerformance->InitAudio(  NULL,
														NULL,
														hWnd,
														DMUS_APATH_DYNAMIC_STEREO,
														64,
														DMUS_AUDIOF_ALL,
														NULL)))
	{
		return( 0 );
	}
	
	// Chemin par défaut
	if( FAILED( pIDMPerformance->GetDefaultAudioPath(&dmAP))) 
	{
		return(0);
	}
	
	// Volume par défaut
	if( FAILED( dmAP->SetVolume(0,0))) 
	{
		return( 0 );
	}

	// Charge le son d'un fichier
	if ( FAILED(pIDMChargeur->LoadObjectFromFile ( CLSID_DirectMusicSegment,
												IID_IDirectMusicSegment8,
												midi_a_jouer,
												(LPVOID*) &pIDMSegment)))
	{
		return( 0 );
	}
	
	// Télécharge les données
	if ( FAILED ( pIDMSegment->Download( pIDMPerformance )))
	{
		return( 0 );
	}

	// Réussite
	return( 1 );
}

/********************************/
/*								*/
/*    Joue le fichier sonore    */
/*								*/
/********************************/

void CDirectX_Audio_MIDI::vLecture_Son()
{
	// Lit le segment sonore
	pIDMPerformance->PlaySegmentEx( pIDMSegment,
								    NULL,
									NULL,
									0,  // Aucun flag pour avoir une vitesse de lecture normale
									0,
									NULL,
									NULL,
									NULL);
}

/***********************************************************************************************************/
// Chargement d'un son Wave

// Constructeur
CDirectX_Audio_Systeme_Sonore::CDirectX_Audio_Systeme_Sonore()
{
	pIDMChargeur = NULL;
	pIDMPerformance = NULL;
}

// Destructeur
CDirectX_Audio_Systeme_Sonore::~CDirectX_Audio_Systeme_Sonore()
{
	SAFE_RELEASE(pIDMChargeur);
	SAFE_RELEASE(pIDMPerformance);
}

/********************************************/
/*											*/
/*     Initialisation du moteur sonore.     */
/*											*/
/********************************************/

HRESULT CDirectX_Audio_Systeme_Sonore::hrInitialisation_Systeme_Sonore(void)
{
	HRESULT hResultat;
	IDirectMusicAudioPath8* IDMAChemin;

	// Initialisation du composant COM
	CoInitialize(NULL);

	// Création du chargeur
	if(FAILED(hResultat = CoCreateInstance( CLSID_DirectMusicLoader,
											NULL,
											CLSCTX_INPROC,
											IID_IDirectMusicLoader8,
											(void**)&pIDMChargeur)))
	{
		return (DIRECT_X_ERREUR_CHARGEUR_MUSIQUE);
	}

	// Création de la performance
	if(FAILED(hResultat = CoCreateInstance( CLSID_DirectMusicPerformance,
											NULL,
											CLSCTX_INPROC,
											IID_IDirectMusicPerformance8,
											(void**)&pIDMPerformance)))
	{
		return(DIRECT_X_ERREUR_PERFORMANCE_MUSIQUE);
	}

	// Initialise l'audio
	if(FAILED(hResultat = pIDMPerformance->InitAudio( NULL,
													  NULL,
													  hWnd,
													  DMUS_APATH_DYNAMIC_STEREO,
													  64,
													  DMUS_AUDIOF_ALL,
													  NULL)))
	{
		return(DIRECT_X_ERREUR_INIT_AUDIO);
	}

	// Chemin par défaut
	if(FAILED(pIDMPerformance->GetDefaultAudioPath(&IDMAChemin)))
	{
		return(DIRECT_X_ERREUR_CHEMIN);
	}

	// Volume par défaut
	if(FAILED(IDMAChemin->SetVolume(0,0)))
	{
		return(DIRECT_X_ERREUR_VOLUME);
	}

	return S_OK;
}

/********************************************************/
/*														*/
/*	   Charge un son et le sauvegarde dans un objet     */
/*				 CDirectX_Audio_WAVE_Son.               */
/*														*/
/********************************************************/

HRESULT CDirectX_Audio_Systeme_Sonore::hrCharger_Son(char* szNomFichier, CDirectX_Audio_WAVE_Son* pCDAWS)
{
	WCHAR szWideNomFichier[512];

	// Soyons sur que l'audio est initialisé
	if(!pIDMChargeur)
	{
		return (DIRECT_X_ERREUR_CHARGEUR_MUSIQUE);
	}

	if(!pIDMPerformance)
	{
		return(DIRECT_X_ERREUR_PERFORMANCE_MUSIQUE);
	}

	// Effaçons les sons s'ils existent
	if(pCDAWS->pIDMSegment)
	{
		pCDAWS->pIDMSegment->Unload(pIDMPerformance);
		pCDAWS->pIDMSegment->Release();
		pCDAWS->pIDMSegment = NULL;
	}

	// Copie dans le nom de fichier
	DXUtil_ConvertGenericStringToWideCch(szWideNomFichier, szNomFichier, 512);

	// Charge un son à partir d'un fichier
	if(FAILED(pIDMChargeur->LoadObjectFromFile(CLSID_DirectMusicSegment,
											 IID_IDirectMusicSegment8,
											 szWideNomFichier,
											 (LPVOID*)&pCDAWS->pIDMSegment)))
	{
		return (DIRECT_X_ERREUR_CHARGEMENT);
	}

	pCDAWS->pIDMPerformance = pIDMPerformance;

	// Télécharge les données
	if(FAILED(pCDAWS->pIDMSegment->Download(pIDMPerformance)))
	{
		return (DIRECT_X_ERREUR_TELECHARGEMENT);
	}

	return S_OK;
}

/********************************/
/*								*/
/* Lit le son chargé en mémoire */
/*								*/
/********************************/

HRESULT CDirectX_Audio_Systeme_Sonore::hrLecture_Son(CDirectX_Audio_WAVE_Son* cdxaws)
{
	// Soyons sur qu'un objet performance est présent
	if(!pIDMPerformance)
	{
		return (DIRECT_X_ERREUR_PERFORMANCE_MUSIQUE);
	}

	if(!cdxaws->pIDMSegment)
	{
		return (DIRECT_X_ERREUR_PAS_SEGMENT);
	}

	// Jouons le segment sonore
	if(FAILED(pIDMPerformance->PlaySegmentEx(cdxaws->pIDMSegment,
											 NULL,
											 NULL,
											 DMUS_SEGF_DEFAULT | DMUS_SEGF_SECONDARY,
											 0,
											 NULL,
											 NULL,
											 NULL)))
	{
		return (DIRECT_X_ERREUR_ECHEC_LECTURE);
	}

	return S_OK;
};

/****************/
/*				*/
/* Constructeur */
/*				*/
/****************/

CDirectX_Audio_WAVE_Son::CDirectX_Audio_WAVE_Son()
{
	pIDMSegment = NULL;
	pIDMPerformance = NULL;
}

/*****************/
/*	    		 */
/*  Destructeur  */
/*				 */
/*****************/

CDirectX_Audio_WAVE_Son::~CDirectX_Audio_WAVE_Son()
{
	if(pIDMSegment)
	{
		if(pIDMPerformance)
			pIDMSegment->Unload(pIDMPerformance);
	}
	SAFE_RELEASE(pIDMSegment);
}