Feedback

C# - Wave, MP3, Midi, AVI, MPEG etc. über MCI abspielen

Veröffentlicht von am 18.10.2006
(4 Bewertungen)
Wie spiele ich eine MP3-Datei in einem .NET-Programm ab? Die einfachste, weil auf jedem modernen System automatisch vorhandene Möglichkeit ist, das etwas angestaubte MCI zu verwenden. MCI ist zwar alt, erfordert aber keine weitere Installation (wie z. B. bei DirectX) und funktioniert einfach (wenn man weiß, wie :-). Die Klasse MCI implementiert das Abspielen von Multimediadateien über die Methoden Open und Play. Viel Spass damit :-)
// **********************************************
// Dies ist eines der 322 Rezepte aus dem
// C# 2005 Premium Codebook. 
// Das Snippet wurde vom Autor mit freundlicher 
// Genehmigung von Addison Wesley 
// bei dotnet-snippets.de veröffentlicht.
// **********************************************


using System;
using System.IO;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;

/// <summary>
/// Repräsentiert eine MCI-Ausnahme
/// </summary>
public class MciException : Exception
{
   public MciException(string message)
   {
   }
}

/// <summary>
/// Klasse für das Abspielen von Mediadateien über MCI 
/// </summary>
public class Mci : IDisposable
{
   /* Deklaration der MCI-Funktionen, -Konstanten und -Strukturen */
   [DllImport("winmm.dll", CharSet = CharSet.Auto)]
   private static extern int mciSendString(string lpstrCommand,
      StringBuilder lpstrReturnString, int uReturnLength, IntPtr
      hwndCallback);

   [DllImport("winmm.dll", CharSet = CharSet.Auto)]
   private static extern int mciGetErrorString(int dwError, StringBuilder
      lpstrBuffer, int uLength);

   [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
   private static extern int GetShortPathName(string lpszLongPath,
      StringBuilder lpszShortPath, int cchBuffer);

   /* Eigenschaft für den MCI-Alias */
   private string alias;

   private bool isOpen = false;
   /// <summary>
   /// Gibt an, ob gerade ein MCI-Gerät geöffnet ist
   /// </summary>
   public bool IsOpen
   {
      get
      {
         return this.isOpen;
      }
   }

   /// <summary>
   /// Liefert eine Fehlermeldung zu einem gegebenen 
   /// Fehlercode
   /// </summary>
   /// <param name="errorCode">Der Fehlercode</param>
   /// <returns>Gibt die Fehlermeldung zurück</returns>
   private string GetMciError(int errorCode)
   {
      StringBuilder errorMessage = new StringBuilder(255);
      if (mciGetErrorString(errorCode, errorMessage,
         errorMessage.Capacity) == 0)
      {
         return "MCI-Fehler " + errorCode;
      }
      else
      {
         return errorMessage.ToString();
      }
   }

   /// <summary>
   /// Öffnet eine Multimediadatei
   /// </summary>
   /// <param name="filename">Der Dateiname</param>
   public void Open(string filename)
   {
      Open(filename, null);
   }

   /// <summary>
   /// Öffnet eine Multimediadatei
   /// </summary>
   /// <param name="filename">Der Dateiname</param>
   /// <param name="owner">Der Besitzer der erzeugten MCI-Instanz</param>
   public void Open(string filename, Control owner)
   {
      // Schließen einer eventuell zuvor noch geöffneten
      // Datei
      if (this.IsOpen)
      {
         this.Close();
      }

      // Alias für das MCI-Gerät erzeugen
      this.alias = Guid.NewGuid().ToString("N");

      // Überprüfen, ob die Datei existiert
      if (File.Exists(filename) == false)
      {
         throw new FileNotFoundException("Die Datei '" + filename +
            "' existiert nicht", filename);
      }

      // Den kurzen Dateinamen ermitteln
      StringBuilder shortPath = new StringBuilder(261);
      if (GetShortPathName(filename, shortPath, shortPath.Capacity) == 0)
      {
         throw new MciException("Fehler beim Auslesen des kurzen " +
            "Dateinamens für '" + filename + "': Windows-Fehler " +
            Marshal.GetLastWin32Error());
      }

      // MCI-Befehlsstring zum Öffnen zusammensetzen
      string mciString = "open " + shortPath.ToString() +
         " type mpegvideo alias " + this.alias;

      if (owner != null)
      {
         mciString += " parent " + (int)owner.Handle + " style child";
      }

      // MCI-Gerät öffnen
      int result = mciSendString(mciString, null, 0, IntPtr.Zero);
      if (result != 0)
      {
         throw new MciException("Fehler beim Öffnen des MCI-Geräts: " +
            GetMciError(result));
      }

      this.isOpen = true;

      // Das Zeitformat für Längen- und Positionsangaben explizit
      // auf Millisekunden setzen
      mciString = "set " + this.alias + " time format ms";
      result = mciSendString(mciString, null, 0, IntPtr.Zero);
      if (result != 0)
      {
         throw new MciException("Fehler beim Setzen des Zeitformats: " +
            GetMciError(result));
      }
   }

   /// <summary>
   /// Gibt die Abspiellänge der aktuellen Multimediadatei zurück
   /// </summary>
   public int Length
   {
      get
      {
         StringBuilder buffer = new StringBuilder(261);
         int result = mciSendString("status " + this.alias + " length",
            buffer, buffer.Capacity, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Lesen von 'Length': " +
               GetMciError(result));
         }

         return int.Parse(buffer.ToString());
      }
   }

   /// <summary>
   /// Spielt eine geladene Multimediadatei ab
   /// </summary>
   /// <param name="repeat">Gibt an, ob das Abspielen nach dem Ende wieder von vorne beginnen soll</param>
   public void Play(bool repeat)
   {
      Play(0, this.Length, repeat);
   }

   /// <summary>
   /// Spielt eine geladene Multimediadatei ab einer bestimmten Position ab
   /// </summary>
   /// <param name="from">Die Startposition</param>
   /// <param name="repeat">Gibt an, ob das Abspielen nach dem Ende wieder von vorne beginnen soll</param>
   public void Play(int from, bool repeat)
   {
      Play(from, this.Length - from, repeat);
   }

   /// <summary>
   /// Spielt eine geladene Multimediadatei ab einer bestimmten Position 
   /// und bis zu einer bestimmten anderen Position ab
   /// </summary>
   /// <param name="from">Die Startposition</param>
   /// <param name="to">Die Endposition</param>
   /// <param name="repeat">Gibt an, ob das Abspielen nach dem Ende wieder von vorne beginnen soll</param>
   public void Play(int from, int to, bool repeat)
   {
      string mciString = "play " + this.alias +
         " from " + from + " to " + to;
      if (repeat)
      {
         mciString += " repeat";
      }
      int result = mciSendString(mciString, null, 0, IntPtr.Zero);
      if (result != 0)
      {
         throw new MciException("Fehler beim Aufruf von 'Play': " +
            GetMciError(result));
      }
   }

   /// <summary>
   /// Verwaltet die Lautstärke
   /// </summary>
   public int Volume
   {
      get
      {
         StringBuilder buffer = new StringBuilder(261);
         int result = mciSendString("status " + this.alias + " volume",
            buffer, buffer.Capacity, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Lesen von 'Volume': " +
               GetMciError(result));
         }
         return int.Parse(buffer.ToString());
      }

      set
      {
         int result = mciSendString("setaudio " + this.alias +
            " volume to " + value, null, 0, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Aufruf von 'SetAudio': " +
               GetMciError(result));
         }
      }
   }

   /// <summary>
   /// Verwaltet die aktuelle Position in den Multimedia-Daten
   /// </summary>
   public int Position
   {
      get
      {
         StringBuilder buffer = new StringBuilder(261);
         int result = mciSendString("status " + this.alias + " position",
            buffer, buffer.Capacity, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Lesen von 'Position': " +
               GetMciError(result));
         }
         return int.Parse(buffer.ToString());
      }

      set
      {
         int result = mciSendString("seek " + this.alias +
            " to " + value, null, 0, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Setzen von 'Position'" +
               GetMciError(result));
         }
         result = mciSendString("play " + this.alias, null, 0, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Aufruf von 'Play': " +
               GetMciError(result));
         }
      }
   }

   /// <summary>
   /// Verwaltet die aktuelle Abspiel-Geschwindigkeit
   /// </summary>
   public int PlaybackSpeed
   {
      get
      {
         StringBuilder buffer = new StringBuilder(261);
         int result = mciSendString("status " + this.alias + " speed",
            buffer, buffer.Capacity, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Lesen von 'Speed'" +
               GetMciError(result));
         }
         return int.Parse(buffer.ToString());
      }

      set
      {
         string mciString = "set " + this.alias + " speed " + value;
         int result = mciSendString(mciString, null, 0, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Setzen von 'Speed': " +
               GetMciError(result));
         }
      }
   }

   /// <summary>
   /// Methode zur Definition der Abspielposition und -größe für Videos, die auf einem Formular, einer PictureBox o. ä. dargestellt werden
   /// </summary>
   /// <param name="x">Die X-Position</param>
   /// <param name="y">Die Y-Position</param>
   /// <param name="width">Die Breite</param>
   /// <param name="height">Die Höhe</param>
   public void SetRectangle(int x, int y, int width, int height)
   {
      string mciString = "put " + this.alias + " window at " + x +
         " " + y + " " + width + " " + height;
      int result = mciSendString(mciString, null, 0, IntPtr.Zero);
      if (result != 0)
      {
         throw new MciException("Fehler beim Aufruf von 'Put Window at': " +
            GetMciError(result));
      }
   }

   /// <summary>
   /// Stoppt den aktuellen Abspielvorgang
   /// </summary>
   public void Stop()
   {
      string mciString = "stop " + this.alias;
      int result = mciSendString(mciString, null, 0, IntPtr.Zero);
      if (result != 0)
      {
         throw new MciException("Fehler beim Aufruf von 'Stop': " +
            GetMciError(result));
      }
   }

   /// <summary>
   /// Schließt ein aktuell geöffnetes MCI-Gerät
   /// </summary>
   public void Close()
   {
      if (this.isOpen)
      {
         string mciString = "close " + this.alias;
         int result = mciSendString(mciString, null, 0, IntPtr.Zero);
         if (result != 0)
         {
            throw new MciException("Fehler beim Aufruf von 'Close': " +
               GetMciError(result));
         }

         this.isOpen = false;
      }
   }

   /// <summary>
   /// Schließt ein aktuell geöffnetes MCI-Gerät
   /// </summary>
   public void Dispose()
   {
      this.Close();
   }

   /// <summary>
   /// Finalisierer
   /// </summary>
   ~Mci()
   {
      this.Close();
   }
}
Abgelegt unter MCI, MP3, AVI, Multimedia, MPEG, Midi, Wave, Sound.

2 Kommentare zum Snippet

Darius Riegel schrieb am 21.04.2010:
Hi!

kann ich damit auch faden? Habe es schon versucht, hatte aber ein Knacken beim abspielen. Da die Lautstärke für ein gerade spielendes Stück nicht aktualisiert wird, musste ich stoppen Lautstärke verändern und wieder starten. Da der Aufsetzpunkt wohl nicht ganz richtig ist, gabs dieses Knacken!

Gibt es da einen Rat?
Koopakiller schrieb am 28.06.2016:
Hallo,
echt super Snippet!
Was kann denn die MCI eigentlich alles abspielen? mp3 und wav habe ich getestet, die funktionieren.
 

Logge dich ein, um hier zu kommentieren!