Application qui plante au démarrage

j'essaye de programmer un fichier qui permette de lire des musiques une par une car mon lecteur audio ne me le permet pas.

Il me reste encore pas mal de boulot, mais voici déjà mon code :

main :

#include <QApplication>
#include "Fenetre.h"
#include "fenetreLecture.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    fenetre salut;
    salut.show();

    return app.exec();
}

Fenetre.h :

#ifndef FENETRE_H
#define FENETRE_H

#include <QApplication>
#include <QPushButton>
#include <QMessageBox>
#include <QWidget>
#include <QInputDialog>
#include <QString>
#include <QObject>
#include <Qfile>
#include <QTextStream>
#include <QFileDialog>
#include <QLabel>
#include "son.h"
#include <windows.h>
#include "fenetreLecture.h"

class fenetre : public QWidget
{
    Q_OBJECT

public :
    fenetre();

public slots:
    void parcourir();
    void sauvegarder(QString fichier);
    void valider();
    void annuler();

signals:
    void boutonRetourne(QString fichier);
    void quitter();

private :
    QPushButton *m_Parcourir;
    QPushButton *m_valider;
    QPushButton *m_annuler;
    QFile m_fichier;
    QTextStream sauvegarde;
    QString m_extentions;
    QLabel *m_fichiersAffiche;
    QString m_playlist;
    fenetreDeLecture m_fenetreDeLecture;
};

#endif // FENETRE_H

Fenetre.cpp :

#include "Fenetre.h"
#include <QTextStream>
#include "son.h"
#include <windows.h>
#include "fenetreLecture.h"

fenetre::fenetre() : QWidget()
{
    int reponse = QMessageBox::question(this, "playlist", "créer une playlist ?", QMessageBox::Yes | QMessageBox::No);
    m_extentions = "audio (*.mp3; *.snd; *.wav; *.au; *.aif; *.aifc; *.aiff; *.wma)";
    if (reponse != QMessageBox::Yes)
    {
        m_extentions = "texte (*.txt)";
    }
    m_playlist="playlist.txt";
    setFixedSize(300,150);
    m_Parcourir = new QPushButton("Parcourir", this);
    m_Parcourir->move(10,120);
    m_Parcourir->setCursor(Qt::PointingHandCursor);
    m_Parcourir->setToolTip("selectionner un fichier");
    m_valider = new QPushButton("valider", this);
    m_valider->move(110,120);
    m_valider->setCursor(Qt::PointingHandCursor);
    m_annuler = new QPushButton("annuler", this);
    m_annuler->move(210,120);
    m_annuler->setCursor(Qt::PointingHandCursor);
    QObject::connect(m_Parcourir, SIGNAL(clicked()), this, SLOT(parcourir()));
    QObject::connect(m_valider, SIGNAL(clicked()), this, SLOT(valider()));
    QObject::connect(m_annuler, SIGNAL(clicked()), this, SLOT(annuler()));
    QObject::connect(this, SIGNAL(boutonRetourne(QString)), this, SLOT(sauvegarder(QString)));
    QObject::connect(this, SIGNAL(quitter()), qApp, SLOT(quit()));
    m_fichier.setFileName("playlist.exe");
    m_fichier.open(QIODevice::WriteOnly);
    sauvegarde.setDevice(&m_fichier);
    m_fichiersAffiche = new QLabel(this);
    m_fichiersAffiche->setText("playlist :<p>");
    m_fichiersAffiche->setGeometry(10,10,290,m_fichiersAffiche->height());
}
void fenetre::parcourir()
{
    QString fichier = QFileDialog::getOpenFileName(this, "Ouvrir un fichier", QString(), m_extentions);
    if (fichier != "")
    {
        emit boutonRetourne(fichier);
    }
}
void fenetre::sauvegarder(QString fichier)
{
    if (m_extentions == "audio (*.mp3; *.snd; *.wav; *.au; *.aif; *.aifc; *.aiff; *.wma)" || (m_extentions == "texte (*.txt)" && m_fichiersAffiche->text() == "playlist :<p>"))
    {
        QString texteAffiche(m_fichiersAffiche->text()+"  "+fichier+"<p>");
        m_fichiersAffiche->setText(texteAffiche);
        m_fichiersAffiche->adjustSize();
        int largeur = 300;
        if (m_fichiersAffiche->width()>300)
        {
            largeur = m_fichiersAffiche->width()+15;
        }
        int hauteur = 150;
        if (m_fichiersAffiche->height()>120)
        {
            hauteur = m_fichiersAffiche->height()+40;
            m_Parcourir->move(10, hauteur-30);
            m_valider->move(110, hauteur-30);
            m_annuler->move(210, hauteur-30);
        }
        setFixedSize(largeur, hauteur);
        QMessageBox::information(this, "fichier ouvert", texteAffiche);
    }
    else
    {
        m_playlist=fichier;
        QString texteAffiche("playlist :<p>  "+fichier);
        QMessageBox::information(this, "fichier ouvert", texteAffiche);
        m_fichiersAffiche->setText(texteAffiche);
        m_fichiersAffiche->adjustSize();
        int largeur = 300;
        if (m_fichiersAffiche->width()>300)
        {
            largeur = m_fichiersAffiche->width()+15;
        }
        int hauteur = 150;
        if (m_fichiersAffiche->height()>120)
        {
            hauteur = m_fichiersAffiche->height()+40;
            m_Parcourir->move(10, hauteur-30);
            m_valider->move(110, hauteur-30);
            m_annuler->move(210, hauteur-30);
        }
        setFixedSize(largeur, hauteur);
    }
}
void fenetre::valider()
{
    QString fichier(m_fichiersAffiche->text());
    if (m_extentions == "audio (*.mp3; *.snd; *.wav; *.au; *.aif; *.aifc; *.aiff; *.wma)")
    {
        sauvegarde.setDevice(&m_fichier);
        sauvegarde << fichier << endl;
    }
    this->hide();
    m_fenetreDeLecture.setPlaylist(m_playlist);
    m_fenetreDeLecture.setVisible(true);
}
void fenetre::annuler()
{
    m_fichier.close();
    this->hide();
    emit quitter();
}

fenetreLecture.h :

#ifndef FENETRELECTURE_H
#define FENETRELECTURE_H

#include <QApplication>
#include <QPushButton>
#include <QMessageBox>
#include <QWidget>
#include <QInputDialog>
#include <QString>
#include <Qfile>
#include <QTextStream>
#include <QFileDialog>
#include <QLabel>
#include <QObject>
#include "son.h"
#include <windows.h>
#include <QProgressBar>
#include <threadLecture.h>

class fenetreDeLecture : public QWidget
{
  Q_OBJECT

public:
    fenetreDeLecture();
    void setPlaylist(QString playlist);
public slots:
    void annuler();
    void relecture();
    void passer();
    void lectureFinie();
signals:

private:
    QPushButton *m_annuler2;
    QPushButton *m_passer2;
    QPushButton *m_relecture2;
    QLabel *m_infos2;
    QFile m_playlist2;
    QTextStream m_lecture2;
    QProgressBar *m_progression2;
    QString m_morceau2;
};

#endif // FENETRELECTURE_H

fenetreLecture.cpp :

#include "fenetreLecture.h"

fenetreDeLecture::fenetreDeLecture()
{
    setFixedSize(300, 150);
    m_infos2->setText("morceau<p>duree<p>etat");
    m_progression2 = new QProgressBar(this);
    m_progression2->setOrientation(Qt::Horizontal);
    m_progression2->setTextVisible(true);
    m_progression2->setRange(0,100);
    m_progression2->setGeometry(10, 90, 280, 20);
    m_playlist2.setFileName("playlist.txt");
    m_playlist2.open(QIODevice::ReadOnly);
    m_lecture2.setDevice(&m_playlist2);
    m_annuler2 = new QPushButton("annuler", this);
    m_annuler2->move(210,120);
    m_annuler2->setCursor(Qt::PointingHandCursor);
    m_passer2 = new QPushButton("passer", this);
    m_passer2->move(10,120);
    m_passer2->setCursor(Qt::PointingHandCursor);
    m_relecture2 = new QPushButton("relire", this);
    m_relecture2->move(110,120);
    m_relecture2->setCursor(Qt::PointingHandCursor);
    creerUnSon musique;
    musique.balanceSon("c:/users/Admin/Music/fichiers de lecture/set_Fire_to_the_Rain.mp3");
    lecture patiente(musique.getChannel(), musique.getSound(), m_progression2);
    QObject::connect(m_annuler2, SIGNAL(clicked()), this, SLOT(annuler()));
    QObject::connect(m_passer2, SIGNAL(clicked()), this, SLOT(passer()));
    QObject::connect(m_relecture2, SIGNAL(clicked()), this, SLOT(relecture()));
}
void fenetreDeLecture::relecture()
{

}
void fenetreDeLecture::passer()
{

}
void fenetreDeLecture::annuler()
{

}
void fenetreDeLecture::setPlaylist(QString playlist)
{
    m_playlist2.setFileName(playlist);
    m_playlist2.open(QIODevice::ReadOnly);
    m_lecture2.setDevice(&m_playlist2);
}
void fenetreDeLecture::lectureFinie()
{

}

son.h :

#ifndef SON_H_INCLUDED
#define SON_H_INCLUDED

#include <string>
#include <FMOD/fmod.h>
#include <time.h>

class creerUnSon
{
public:
    int balanceSon(QString musique);
    void fermerLeSysteme();
    FMOD_CHANNEL* getChannel();
    FMOD_SOUND* getSound();
private:
    FMOD_SYSTEM  *m_chanson;
    FMOD_CHANNEL *m_channel;
    FMOD_SOUND   *m_sound;
};
#endif // SON_H_INCLUDED

son.cpp :

#include <FMOD/fmod.h>
#include <QString>
#include "son.h"

using namespace std;

int creerUnSon::balanceSon(QString musique)
{
    const char *nom2(musique.toStdString().c_str());
    FMOD_System_Create(&m_chanson);
    FMOD_System_Init(m_chanson, 1, FMOD_INIT_NORMAL, NULL);
    FMOD_BOOL lecture(FMOD_OK);
    unsigned int duree;
    lecture = FMOD_System_CreateSound(m_chanson, nom2, FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &m_sound);
    if (lecture == FMOD_OK)
    {
        FMOD_System_PlaySound(m_chanson, FMOD_CHANNEL_FREE, m_sound, 0, &m_channel);
        FMOD_Sound_GetLength(m_sound, &duree, FMOD_TIMEUNIT_MS);
    }
    return ((int)duree);
}

void creerUnSon::fermerLeSysteme()
{
    FMOD_Sound_Release(m_sound);
    FMOD_System_Close(m_chanson);
    FMOD_System_Release(m_chanson);
}
FMOD_CHANNEL* creerUnSon::getChannel()
{
    return m_channel;
}
FMOD_SOUND* creerUnSon::getSound()
{
    return m_sound;
}

threadLecture.h :

#ifndef THREADLECTURE_H
#define THREADLECTURE_H

#include <QThread>
#include <QObject>
#include <FMOD/fmod.h>
#include "fenetreLecture.h"

class lecture : public QThread
{
    Q_OBJECT

public:
    lecture(FMOD_CHANNEL *canal, FMOD_SOUND *sound, QProgressBar* progression);
    void run();
public slots:

signals:
    void fini();
    void envoi(int);
private:
     FMOD_CHANNEL *m_canal;
     FMOD_SOUND *m_sound;
     QProgressBar *m_progression;
};
#endif // THREADLECTURE_H

et enfin, threadLecture.cpp :

#include "threadLecture.h"

lecture::lecture(FMOD_CHANNEL *canal, FMOD_SOUND *sound, QProgressBar *progression) : QThread()
{
    m_canal = canal;
    m_sound = sound;
    m_progression = progression;
    QObject::connect(this, SIGNAL(envoi(int)), m_progression, SLOT(setValue(int)));
    QObject::connect(this, SIGNAL(fini()), parent(), SLOT(passer()));
}
void lecture::run()
{
    unsigned int duree;
    unsigned int position;
    FMOD_Sound_GetLength(m_sound, &duree, FMOD_TIMEUNIT_MS);
    while (duree != position)
    {
        FMOD_Channel_GetPosition(m_canal, &position, FMOD_TIMEUNIT_MS);
        emit envoi(position/duree);
    }
    emit fini();
}

Il y a 2 problèmes dans ce code :
- des messages d'erreur (tous identiques) du type warning apparaissent. En voici un : C:\Qt\5.3\mingw482_32\include\FMOD\fmod.h:305: avertissement : type qualifiers ignored on function return type [-Wignored-qualifiers]
const void (*done)(FMOD_ASYNCREADINFO *info, FMOD_RESULT result); /* FMOD file system wake up function. Use instead of 'result' with FMOD_INIT_ASYNCREAD_FAST to get semaphore based performance improvement. Call this when user file read is finished. Pass result of file read as a parameter. */
^. Je pense que ce problème est lié aux fichiers son.h et son.cpp, mais je n'en suis pas sûr
- l'application plante quand j'essaye de la lancer, que j'utilise debug ou release n'y change absolument rien (je code avec Qt creator)

Quelqu'un sait pourquoi je rencontre ces problèmes (probablement liés) ?

Désolé pour qui voudrait lire mon code, je suis plutôt avare de commentaires, car quand j'en mets, j'utilise au minimum 3 lignes pour le faire