Direct x : audio

Soyez le premier à donner votre avis sur cette source.

Vue 9 778 fois - Téléchargée 560 fois

Description

Désolé d'avoir mis si longtemps à poster une source mais en BAC STI on a un projet BAC (cette année, c'était un I-Cybie, le robot chien) et comme ce projet coute un coeff 7 à l'écriture et 9 à l'oral (snif je passe lundi) j'avais pas envie de prendre de risque.

Bon passons au vif du sujet, ce programme sert à jouer des fichiers musicaux tel que le MP3, MIDI ou WAVE (pour l'instant ceux-là).

Je ne mets pas de WAV ni de MP3 volontairement (trop gros) alors vous n'avez que le midi.
Il vous suffit de remplacer les lignes nécessaires.

Voici le code du fichier DX_Audio.cpp

Source / Exemple :


/********************************************************/
/* 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);
}

Conclusion :


Bugs connus : le WAVE ne se lit pas à tous les coups (du moins lorsque l'on compile).
lorsque vous cliquez sur un bouton autre que wav et que ce fichier est lu, il devrait s'arrêter pour lire un autre fichier mais il le fait pas

Améliorations possible : lecture d'autres fichiers et un mode de répétition. (Pas vu dans la doc de directX comment on fait, si vous avez des exemples).

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.