FFT et Fichier WAV

Signaler
Messages postés
51
Date d'inscription
samedi 23 avril 2005
Statut
Membre
Dernière intervention
29 avril 2013
-
Bonjour,
Je suis un peu perdu sur une données que les professeur nous as donnée.

Il nous demandes
Vous devez analyser le fichier WAV à votre nom afin d’en caractériser le contenu (fréquences représentées et leurs amplitudes).
Vous utiliserez une FFT en C#. Vous en trouverez facilement des versions sur Internet.
Vous devrez aussi décoder le contenu de votre fichier WAV. Là aussi, vous trouverez la structure d’un fichier WAV sur Internet.



J'ai donc trouvé sur Wikipedia, la structure d'entête du fichier WAV.
http://fr.wikipedia.org/wiki/WAVEform_audio_format

J'arrive a lire l'entête jusqu'au moment ou j'arrive au DATAS[], voici mon code

Class InformationWav
using System;
using System.IO;
using System.Text;
using System.Windows.Forms;
using System.Resources;
using System.Globalization;


namespace TP4MBB
{
    class InformationWAV
    {
        wavFile wav;
        GestionWAV gestion;
        bool estValide =  false;

        public InformationWAV(string gsChemin)
        {
         try
            {
                gestion = new GestionWAV(gsChemin);
                StreamReader laReader = new StreamReader(gsChemin, Encoding.Default);
                wav = new wavFile();

                char[] EnteteChar = new char[44];
                laReader.Read(EnteteChar, 0, 44);
                String entete = new String(EnteteChar);            

                /*
                 * On lit nos valeur présente dans EnteteChar
                 */
                wav.FileType = entete.Substring(0, 4).ToCharArray();
                entete = entete.Remove(0, 4);

                /* 
                 * Lecture de la taille et conversion en valeur numérique
                 */
                string Size = entete.Substring(0, 4);
                entete = entete.Remove(0, 4);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.FileSize = uint.Parse(Size, System.Globalization.NumberStyles.HexNumber);

                /* Suite lecture */
                wav.FileFormat = entete.Substring(0, 4).ToCharArray();
                entete = entete.Remove(0, 4);
                if (new String(wav.FileFormat).EndsWith("WAVE"))
                {
                    estValide = true;
                }

                wav.FormatBloc = entete.Substring(0, 4).ToCharArray();
                entete = entete.Remove(0, 4);

                /* Conversion du BlocSize */
                Size = entete.Substring(0, 4);
                entete = entete.Remove(0, 4);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.BlocSize = uint.Parse(Size, System.Globalization.NumberStyles.HexNumber);

                /* Conversion du Format */
                Size = entete.Substring(0, 2);
                entete = entete.Remove(0, 2);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.Format = ushort.Parse(Size, System.Globalization.NumberStyles.HexNumber);

                /* Conversion du NbrCanaux */
                Size = entete.Substring(0, 2);
                entete = entete.Remove(0, 2);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.NbrCanaux = ushort.Parse(Size, System.Globalization.NumberStyles.HexNumber);

                /* Conversion de la Frequence */
                Size = entete.Substring(0, 4);
                entete = entete.Remove(0, 4);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.Frequence = uint.Parse(Size, System.Globalization.NumberStyles.HexNumber);

                /* Conversion du Nombre de byte par sec */
                Size = entete.Substring(0, 4);
                entete = entete.Remove(0, 4);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.BitBySec = uint.Parse(Size, System.Globalization.NumberStyles.HexNumber);

                /* Conversion du Nombre de byte par bloc */
                Size = entete.Substring(0, 2);
                entete = entete.Remove(0, 2);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.BitByBloc = ushort.Parse(Size, System.Globalization.NumberStyles.HexNumber);

                /* Conversion du Nombre de byte par Sample (échantillon ??) */
                Size = entete.Substring(0, 2);
                entete = entete.Remove(0, 2);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.BitBySample = uint.Parse(Size, System.Globalization.NumberStyles.HexNumber);


                /*
                 * Chargement des info data
                 */
                wav.DataBlocID = entete.Substring(0, 4).ToCharArray();
                entete = entete.Remove(0, 4);

                /* Conversion du dataSize */
                Size = entete.Substring(0, 4);
                entete = entete.Remove(0, 4);
                Size = ConvertStringToHex(Size);
                Size = gestion.ConvertOffsetToStr(Size);
                wav.DataSize = int.Parse(Size, System.Globalization.NumberStyles.HexNumber);

                /*
                 * Lecture des DATA (donnée du wav)
                 */
                // Lire les data Sample : NbrCanaux * 4

                /* Conversion du data */ 
                // ICI CA BOGUE ET JE SAIS PLUS
                char[] chrValue;
                int SizeData = Convert.ToInt32(wav.BitBySample); // Convert.ToInt32(wav.BitByBloc) * Convert.ToInt32(wav.NbrCanaux);
                EnteteChar = new char[SizeData];
                laReader.Read(EnteteChar, 0, SizeData);
                entete = new String(EnteteChar);

                while (entete.Length > 0)
                {
                    String StrValue = entete.Substring(0, 4);
                    entete = entete.Remove(0, 4);
                    StrValue = ConvertStringToHex(StrValue);
                    StrValue = gestion.ConvertOffsetToStr(StrValue);
                    int intValue = int.Parse(StrValue, System.Globalization.NumberStyles.HexNumber);
                    wav.addData(intValue);
                }


                // Fermture du fichier
                laReader.Close();
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message, "Erreur !", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /*
         * Source : http://snipplr.com/view/36461/
         */
        public string ConvertStringToHex(string asciiString)
        {
            string hex = "";
            foreach (char c in asciiString)
            {
                int tmp = c;
                hex += String.Format("{0:x2}", (uint)System.Convert.ToUInt32(tmp.ToString()));
            }
            return hex;
        }

        /*
         * Source : http://snipplr.com/view/36461/
         */
        public string ConvertHexToString(string HexValue)
        {
            string StrValue = "";
            while (HexValue.Length > 0)
            {
                StrValue += System.Convert.ToChar(System.Convert.ToUInt32(HexValue.Substring(0, 2), 16)).ToString();
                HexValue = HexValue.Substring(2, HexValue.Length - 2);
            }
            return StrValue;
        }

        public wavFile WAV
        {
            get
            {
                return this.wav;
            }
        }
    }
}


Ensuite j'ai aucune idée de comment lire ou/et sauvegardé le data (les données sonores, la track sonore ou je sais trop quoi) dans ma classe, pour ensuite je présume utiliser un algo de FFT pour obtenir un résultat.

Est-ce un tableau d'entier, de float, de double, de bytes ou autres?
Qu'elle quantité (nombre octect) suis-je sensé lire après ? Et à partir d’où?

Disons que je suis loin d'être un amateur de musique, donc quand on me parle de fréquence, de sample, d'amplitude ou je sais j'ai aucune idée de ce que ça signifie.

Et au niveau du FFT, je ne suis pas parvenu a trouvé d'algorithme qui s'occuperait de me donner le résultat désirer à la question de l'énonce, tous ce que je trouve, c'est des explications qui me donne la formule mathématique, mais disons que ça ne dis pas grand choses :D


Class GestionWav
using System;
using System.ComponentModel;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Windows.Forms;

namespace TP4MBB
{
    class GestionWAV
    {
        string gFileName;

        /*
         * Constructeur de la classe
         */
        public GestionWAV(string localFileRoot)
        {
            gFileName  = localFileRoot;
        }

        ~GestionWAV()
        {
            gFileName =  "";
        }
        
        /*
         * Méthode de traitement
         */

        public string readHEX(long offset, int quantiteRead)
        {
            byte[] octets;
            using (FileStream fs = File.OpenRead(gFileName))
            {
                fs.Seek(offset, SeekOrigin.Begin);

                using (BinaryReader reader = new BinaryReader(fs))
                {
                    octets = reader.ReadBytes(quantiteRead);
                }
            }
            return BitConverter.ToString(octets);
        }

        private string EliminerCaractere(string chaine, char caractere)
        {
            for (int i = chaine.Length-1; i > 0; --i)
            {
                if (chaine[i].Equals('-'))
                {
                    chaine = chaine.Remove(i, 1);
                }
            }
            return chaine;
        }

        public long ConvertOffset(string offset)
        {
            string OffsetConvert = "";
            OffsetConvert = offset.Substring(4, 2);
            OffsetConvert += offset.Substring(2, 2);  
            OffsetConvert += offset.Substring(0, 2);  

            return long.Parse(OffsetConvert, System.Globalization.NumberStyles.HexNumber);
        }

        public string ConvertOffsetToStr(string offset)
        {
            string OffsetConvert = "";
            if ((offset.Length > 4) && (!offset.Substring(4, 2).Equals("00")))
            {
                OffsetConvert += offset.Substring(4, 2);
            }
            if (!offset.Substring(2, 2).Equals("00"))
            {
                OffsetConvert += offset.Substring(2, 2);
            }
            if (!offset.Substring(0, 2).Equals("00"))
            {
                OffsetConvert += offset.Substring(0, 2);
            }

            return OffsetConvert;
        }


        public long searchHex(string value, int nbOctets)
        {
            byte[] octets;
            long offset = 0;
            using (FileStream fs = File.OpenRead(gFileName))
            {
                int Pos = 288; 
                bool Etat = false;
                BinaryReader reader = new BinaryReader(fs);
                while ((!Etat) && (Pos < fs.Length))
                {
                    fs.Seek(Pos,SeekOrigin.Begin);
                    octets = reader.ReadBytes(nbOctets);
                    if (!BitConverter.ToString(octets).Equals(value))
                    {
                        Pos++;
                    }
                    else
                    {
                        offset = reader.BaseStream.Position;
                        Etat = true;
                    }
                }
            }
            return offset-nbOctets;
        }
    }
}



Class WavFile
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TP4MBB
{
    class wavFile
    {
        /*
         * Entête format WAVE
         */
        char[] fileType  = new char[4];
        uint fileSize;
        char[] fileFormat = new char[4];

        /*
         * Format de l'audio
         */
        char[] formatBloc = new char[4];
        uint blocSize;
        ushort format;
        ushort nbrCanaux;
        uint frequence;
        uint bitBySec;
        ushort bitByBloc;
        uint bitBySample;

        /*
         * Bloc Data
         */
        char[] dataBlocID = new char[4];
        int dataSize;
        List DataSample = new List();

        public wavFile()
        {
        }

        /*
         * Entête format WAVE
         */

        public char[] FileType
        {
            set {
                this.fileType = value;
            }
            get{
                return this.fileType;
            }
        }

        public uint FileSize
        {
            set
            {
                this.fileSize = value;
            }
            get
            {
                return this.fileSize;
            }
        }

        public char[] FileFormat
        {
            set
            {
                this.fileFormat = value;
            }
            get
            {
                return this.fileFormat;
            }
        }

        /*
         * Format de l'audio
         */
        public char[] FormatBloc
        {
            set
            {
                this.formatBloc = value;
            }
            get
            {
                return this.formatBloc;
            }
        }

        public uint BlocSize
        {
            set
            {
                this.blocSize = value;
            }
            get
            {
                return this.blocSize;
            }
        }

        public ushort Format
        {
            set
            {
                this.format = value;
            }
            get
            {
                return this.format;
            }
        }

        public ushort NbrCanaux
        {
            set
            {
                this.nbrCanaux = value;
            }
            get
            {
                return this.nbrCanaux;
            }
        }

        public uint Frequence
        {
            set
            {
                this.frequence = value;
            }
            get
            {
                return this.frequence;
            }
        }

        public uint BitBySec
        {
            set
            {
                this.bitBySec = value;
            }
            get
            {
                return this.bitBySec;
            }
        }

        public ushort BitByBloc
        {
            set
            {
                this.bitByBloc = value;
            }
            get
            {
                return this.bitByBloc;
            }
        }

        public uint BitBySample
        {
            set
            {
                this.bitBySample = value;
            }
            get
            {
                return this.bitBySample;
            }
        }

        /*
         * Bloc Data
         */
        public char[] DataBlocID
        {
            set
            {
                this.dataBlocID = value;
            }
            get
            {
                return this.dataBlocID;
            }
        }
        public int DataSize
        {
            set
            {
                this.dataSize = value;
            }
            get
            {
                return this.dataSize;
            }
        }
        public List Data
        {
            set
            {
                this.DataSample = value;
            }
            get
            {
                return this.DataSample;
            }
        }

        public void addData(int value)
        {
            DataSample.Add(value);
        }


        public override string ToString()
        {
            return "File Type : " + new String(FileType) + "\n" +
                   "File Size : " + FileSize + "\n" +
                   "File Format : " + new String(FileFormat) + "\n\n" +
                   "Format Bloc: " + new String(FormatBloc) + "\n" +
                   "Bloc Size: " + BlocSize + "\n" +
                   "Format : " + new String(FormatBloc) + "\n" +
                   "Nombre de canaux : " + NbrCanaux + "\n" +
                   "Frequence : " + Frequence + "\n" +
                   "Bit par sec : " + BitBySec + "\n" +
                   "Bit par bloc : " + BitByBloc + "\n" +
                   "Bit par sample : " + BitBySample + "\n\n" +
                   "DataBloc ID : " + new String(DataBlocID) + "\n" +
                   "Data Size : " + DataSize + "\n";
        }

    }

}


Donc, voilà, si quelqu'un à une idée, une explication ou quelques choses pour me débloquer :/ Je fouille la-dedans depuis 4-5 jours, mais je suis toujours bloqué et j'ai rien trouvé :/ Et la remise est pour 23h59 :D

Mat1554