JOUER DE LA MUSIQUE EN ASYNHRONE (WAV ET MP3)

using System;
using QuartzTypeLib;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;


public class Musique 
{

   // Cette classe propose des méthode pour jouer des morceaux WAV ou MP3.
   // Il y a également une méthode de conversion de WAV vers MP3.
		
   private string Music_File;
   private bool   MP3;
   private bool   Boucle;
   private System.Timers.Timer  Relance = new System.Timers.Timer();

   private static QuartzTypeLib.IMediaControl   MP3_control;
   private static QuartzTypeLib.FilgraphManager graphManager;

   [DllImport("winmm.dll", EntryPoint="PlaySoundA")]   public static extern int PlaySound(string Snd_File, int hModule , int Mode);
		

   public Musique(string File_Name) 
   {
      Music_File=File_Name;
      MP3 = File_Name.ToUpper().IndexOf(".MP3") >=0 ? true : false;
      Relance.Elapsed += new System.Timers.ElapsedEventHandler(MP3_PlayLoop);
   }

   public Musique(string File_Name , bool mp3)    
   {
      Music_File=File_Name;
      MP3 = mp3;
      Relance.Elapsed += new System.Timers.ElapsedEventHandler(MP3_PlayLoop);
   }

   ~Musique()
   {
      Stop();
   }


   public string FileName 
   { 
      get 
      { 
         return Music_File; 
      } 
      set 
      { 
         if (Music_File != value)
         {
            Stop();
            Music_File = value; 
            MP3 = Music_File.ToUpper().IndexOf(".MP3") >=0 ? true : false;
         }
      } 
   } 

 
   public void Play()            
   {
      Boucle = false;
      if (MP3)    MP3_Play();
      else        WAV_Play();
   }

   public void PlayLoop()        
   {
      Boucle = true;
      if (MP3)    MP3_Play();
      else        WAV_PlayLoop();
   }

   public void Stop()            
   {
      if (MP3)    MP3_Stop();
      else        WAV_Stop();
   }


   // Méthodes pour les fichiers MP3 :
   private void   MP3_Play()        
   {
      MP3_Stop();
      graphManager = new QuartzTypeLib.FilgraphManager(); 
      MP3_control  = (QuartzTypeLib.IMediaControl)graphManager; 
      MP3_control.RenderFile(Music_File); 
      MP3_control.Run();
      if (Boucle)
      {  // Timer de boucle avec une seconde de marge.
         Relance.Interval = 1000 * (int) (1 + graphManager.Duration);
         Relance.Start();
      }
   }

   private void   MP3_PlayLoop(object source, System.Timers.ElapsedEventArgs e)    
   {
      MP3_Play();
   }

   private void   MP3_Stop()        
   {
      if (MP3_control != null)
      {
         MP3_control.Stop();
         Relance.Stop();
      }
   }


   // Méthodes pour les fichiers WAV :
   private void   WAV_Play()        
   {
      PlaySound(Music_File , 0 , 1);
   }

   private void   WAV_PlayLoop()    
   {
      PlaySound(Music_File , 0 , 9);
   }

   private void   WAV_Stop()        
   {
      PlaySound(null , 0 , 64);
   }


   // Conversion WAV vers MP3 :
   public  void   Convert_Wav_TO_MP3(string Rep_LAME , string WAV_File , string MP3_File , bool Stréréo, int BitRate, bool waitFlag)
   {
      string Mode    = Stréréo      ? " -m s" : "-m m";
      string bitrate = BitRate == 0 ? " -b 128" : " -b " + BitRate.ToString();

      Rep_LAME = (Rep_LAME.Substring(Rep_LAME.Length-1) == @"\\" ? Rep_LAME : Rep_LAME+@"\\");
      string outfile       = bitrate + Mode + " \\"" + WAV_File + "\\" \\"" + MP3_File + "\\"";
      ProcessStartInfo psi = new ProcessStartInfo();
      psi.FileName         = "\\"" + Rep_LAME + "lame.exe" + "\\"";
      psi.Arguments        = outfile;
      psi.WindowStyle      = System.Diagnostics.ProcessWindowStyle.Minimized;
      Process          p   = System.Diagnostics.Process.Start(psi);
      if (waitFlag) 
         p.WaitForExit();        // wait for exit of called application			
   }
}


*********************************************
*********************************************
**      EVOLUTION  NOVEMBRE 2004           **
*********************************************
*********************************************

using System;
using QuartzTypeLib;
using Rnd_Wallpaper;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Threading;


/// <summary> Cette classe permet de jouer des morceaux WAV ou MP3, en asynchrone.
/// Elle contient également une méthode de conversion de WAV vers MP3.</summary>
public class Musique 
{		
   private ArrayList mMusicFiles;         // Tableaux des fichiers 
   private string    mCurrent_File = "";  // Fichier en cours  de lecture
   private string    mPaddFile = "";      // Padding des fichiers 
   private bool      mBoucle   = false;   // Indique si la lecture est en boucle ou non
   private bool      mRndPlay  = false;   // Indique si l'ordre de lecture est aléatoire ou pas
   private int       mCurrent  = 0;       // Indice du fichier en cours de lecture;
   private double    mDelay    = -1;      // Durée de lecture des morceaux (-1 => durée du morceau).

   private System.Timers.Timer  TimerRelance = new System.Timers.Timer();
   public  event    EventHandler MusicChanged;
   public  event    EventHandler MusicEnded;

   // private static QuartzTypeLib.IBasicAudio     AudioCtrl = null;
   // private static QuartzTypeLib.IMediaPosition  PositionCtrl = null;
   // private static QuartzTypeLib.IMediaControl   MusicCtrl;
   private static QuartzTypeLib.FilgraphManager graphManager;


      /// <summary> Constructeur d'un objet "Musique". </summary>
      /// <param name="File_Name"> Indique le fichier ou le padding des fichiers qui seront joués. </param>
   public Musique(string File_Name)                   
   {
      InitData(File_Name);
      TimerRelance.Elapsed += new System.Timers.ElapsedEventHandler(Play);
   }

   ~Musique()                                         
   {
      Stop();
   }


      /// <summary> Contient le fichier à lire ou un padding définissant une liste de fichier (Lecture/Ecriture). </summary>
   public string FileName                             
   { 
      get 
      { 
         return mPaddFile;
      } 
      set 
      { 
         InitData(value);
      } 
   } 

      /// <summary> Renvoie le nom du fichier actuellement joué (Lecture seule). </summary>
   public string CurrentFile                          
   { 
      get 
      { 
         return mCurrent_File;
      } 
   }
 
      /// <summary> Renvoie la durée du fichier actuellement joué. La modification de cette propriété n'a d'effet que lorsqu'un 
      /// morceau est en cours de lecture : elle permet de déterminer le délai pour passer au morceau suivant. </summary>
   public double Duration                             
   { 
      get 
      { 
         try   {  return (mDelay<=0 ? graphManager.Duration : mDelay); }
         catch {  return 0;}
      } 
      set 
      { 
         mDelay = value;
      } 
   }
 

      /// <summary> Permet de jouer un fichier MP3 ou WAV dans la liste définie par la propriété "FileName".</summary>
      /// <returns>Renvoie 'true' si le fichier a pu être joué, 'false' sinon. </returns> 
      /// <param name="Loop"> Indique si le morceau de musique est jouer en boucle ou pas. </param>
      /// <param name="RndPlay"> Si une liste de fichiers a été paramétrée, indique si la lecture est aléatoire ou séquentielle. </param>
   public bool Play        (bool Loop, bool RndPlay)  
   {
      mRndPlay = RndPlay;
      bool Result;
      do
         Result = Play(Loop, FindFile());
      while (!Result && mMusicFiles.Count > 0);
      return Result;
   }

      /// <summary> Permet de jouer le fichier MP3 ou WAV spécifié. </summary>
      /// <returns> Renvoie 'true' si le fichier a pu être jouer, 'false' sinon. </returns>
      /// <param name="Loop"> Indique si le morceau de musique est jouer en boucle ou pas. </param>
      /// <param name="File"> Nom du Fichier à jouer. </param>
   public bool Play        (bool Loop, string File)   
   {
      Stop();
      mCurrent_File = (System.IO.File.Exists(File) ? File : "");
      if (mCurrent_File != "")
      {
         mCurrent = mMusicFiles.IndexOf(File);
         try
         {
            // Variables de gestion des fichiers AUDIO MP3 & WAV :
            graphManager = new QuartzTypeLib.FilgraphManager(); 
            graphManager.RenderFile(mCurrent_File);
            graphManager.Run();
            OnMusicChanged(EventArgs.Empty);
            if (mBoucle = Loop)
            {
               TimerRelance.Interval = (mDelay<=0 ? (int) (500 + 1000 * graphManager.Duration) : 1000 * mDelay);
               TimerRelance.Start();
            }
            return true;
         }
         catch
         {
            if (mCurrent > -1)    
               mMusicFiles.RemoveAt(mCurrent);
            mCurrent_File = "";
         }
      }
      return false;
   }

      /// <summary> Arrète le morceau de musique en cours de lecture. </summary>
   public void Stop        ()                         
   {
      if (graphManager != null)
      {
         graphManager.Stop();
         graphManager = null;

         TimerRelance.Stop();
         mCurrent_File = "";
         mCurrent = -1;
      }
   }


      /// <summary> Initialise les données de l'objet lorsqu'un nouveau 'FileName' est indiqué. </summary>
      /// <param name="File_Name"> Nouvelle valeur de la propriété 'FileName'. </param>
   private void   InitData (string File_Name)         
   {
      // Chargement des données :
      Stop();
      mPaddFile = File_Name;
      mRndPlay  = ! System.IO.File.Exists(File_Name);
      mBoucle   = false;

      int Pos = File_Name.LastIndexOf("\\");
      if (Pos < 1)
         mMusicFiles = null;
      else
      {
         string    PadFile  = File_Name.Substring(Pos+1);
         string[]  RepList  = new string[] {File_Name.Substring(0,Pos)};
         string[,] List_fmt = new string[,] {{"True", PadFile}};
         mMusicFiles = new ArrayList(FctCom.Find_File_List(RepList, List_fmt, false));    // Utilisation détournée de la fonction => CtrlImg = false
      }

      //PositionCtrl = (QuartzTypeLib.IMediaPosition)MusicCtrl;
   }

      /// <summary> Renvoie le nom d'un fichier dans la liste définie par le propriété 'FileName'. </summary>
   private string FindFile ()                         
   {
      if (mMusicFiles != null)
         if (mMusicFiles.Count > 0)
         {
            if (mRndPlay)
               do
                  mCurrent = DATA.Rnd.Next(mMusicFiles.Count);
               while ( (string)mMusicFiles[mCurrent] == mCurrent_File && mMusicFiles.Count > 1);
            else
               ++mCurrent;
            if (mCurrent >= mMusicFiles.Count)
               mCurrent = 0;
            return (string) mMusicFiles[mCurrent];
         }
      return "";
   }

      /// <summary> Cette fonction est appelée à chaque fois que le timer est atteint (à la fin d'un morceau de musique donc). </summary>
   private void   Play     (object source, System.Timers.ElapsedEventArgs e)
   {
      OnMusicEnded(EventArgs.Empty);
      Play(mBoucle, mRndPlay);
   }


      /// <summary> Permet de convertir un fichier WAV en MP3. </summary>
      /// <param name="Rep_LAME"> Contient le répertoire dans lequel se trouve le programme "lame.exe". </param>
      /// <param name="WAV_File"> Nom du Fichier WAV à convertir (complet). </param>
      /// <param name="MP3_File"> Nom du Fichier MP3 issu de la conversion (complet). </param>
      /// <param name="Stréréo">  Indique si la conversion est stéréo ou pas. </param>
      /// <param name="BitRate">  Contient le BitRate de conversion. </param>
      /// <param name="waitFlag"> Indique si la conversion est synchrone ou pas. </param>
   public  void   Convert_Wav_TO_MP3(string Rep_LAME , string WAV_File , string MP3_File , bool Stréréo, int BitRate, bool waitFlag)
   {
      string Mode    = Stréréo      ? " -m s" : "-m m";
      string bitrate = BitRate == 0 ? " -b 128" : " -b " + BitRate.ToString();

      Rep_LAME = (Rep_LAME.Substring(Rep_LAME.Length-1) == @"\" ? Rep_LAME : Rep_LAME+@"\");
      string outfile       = bitrate + Mode + " \"" + WAV_File + "\" \"" + MP3_File + "\"";
      ProcessStartInfo psi = new ProcessStartInfo();
      psi.FileName         = "\"" + Rep_LAME + "lame.exe" + "\"";
      psi.Arguments        = outfile;
      psi.WindowStyle      = System.Diagnostics.ProcessWindowStyle.Minimized;
      Process          p   = System.Diagnostics.Process.Start(psi);
      if (waitFlag) 
         p.WaitForExit();        // wait for exit of called application			
   }

   
      /// <summary> Cet évènement se produit à chaque fois qu'un nouveau morceau démarre. </summary>
   protected virtual void OnMusicChanged  (EventArgs e)              
   {
      if (MusicChanged != null)
         MusicChanged(this, e);
   }

      /// <summary> Cet évènement se produit à chaque fois qu'un morceau se termine. </summary>
   protected virtual void OnMusicEnded    (EventArgs e)              
   {
      if (MusicEnded != null)
         MusicEnded(this, e);
   }

}