Vb.net mp3 abspielen (als eingebundene Resource)

nim da einfach AxWindowsMediaPlayer versteck ihn und nim dann die befehle

AxWindowsMediaPlay.1 Stop pause etc.

wird diir dann angezeigt ;) bei Hilfe add mich icq 550103469

Ja aber den wmp hat noch längst nicht jeder^^

wenn anstelle von mp3 du ne wav nimmst gehts ganz einfach

My.Computer.Audio.Play(My.Resources.*NameDerDatei* , AudioPlayMode.WaitToComplete)

Zitat:

---

Zitat von Planxty

wenn anstelle von mp3 du ne wav nimmst gehts ganz einfach

My.Computer.Audio.Play(My.Resources.*NameDerDatei* , AudioPlayMode.WaitToComplete)

---

Habe ich ja derzeit nur das schlägt auf die mbs

haste die mp3 den in ne res datei reingehaun zum compilen?
Und haste den pfad überhaupt richtig angegeben?
Kann sein das du das abspielen vielleicht gar nicht geproggt hast. XD

Code:

---

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

namespace FlowerRadio.Audio
{
    /// <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();
        }
    }
}

---

Hatte vor kurzem erst selber das Problem mit dem abspielen von MP3's und diese Klasse sollte genau das verwirklichen was du suchst.
Ist zwar C# aber ich glaube das in VB.net umzuschreiben sollte nich das Problem sein.
Mfg Impi

So für alle die Mp3 aus den resourcen ohne controls etc abspielen möchten.
Klick