Application qui plante au démarrage

leberra Messages postés 27 Date d'inscription Statut Membre Dernière intervention -
leberra Messages postés 27 Date d'inscription Statut Membre Dernière intervention - 13 juin 2014 à 21:21

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

Afficher la suite

A voir également:

3 réponses

Réponse 1 / 3

leberra Messages postés 27 Date d'inscription Statut Membre Dernière intervention 1

j'ai réalisé un débogage et il semble que ce soit l'extention d'application Qt5Widgets.dll qui pose problème

Des solutions ?

Réponse 2 / 3

leberra Messages postés 27 Date d'inscription Statut Membre Dernière intervention 1

voici le message d'erreur généré par le débogueur :
l'inférieur a stoppé car il a reçu le signal du systeme d'exploitation
nom du signal : SIGSEGV
signification du signal : segmentation fault

ElementW Messages postés 4814 Date d'inscription Statut Contributeur Dernière intervention 1 223

Bonne idée d'utiliser un débogueur, mais il faut l'utiliser a bon escient: c'est un crash, on, sait, ça. Il nous faut la trace de l'erreur, la backtrace, pour savoir d'où vient l'erreur. Je vois que tu utilises mingw, donc ton débogueur c'est

gdb

, et la commande (si tu t'en sers en console), c'est

bt

. Sinon, selon ton environnement, la démarche varie...

leberra Messages postés 27 Date d'inscription Statut Membre Dernière intervention 1

où entrer bt stp ?

dsl c'est la première fois que je suis confronté à un problème de ce type, donc je découvre le débogueur par la même occasion

ElementW Messages postés 4814 Date d'inscription Statut Contributeur Dernière intervention 1 223

J'ai dit que

bt

c'est si tu utilises GDB en ligne de commande. Sinon, ça dépend de l'environnement de développement que tu utilises.

leberra Messages postés 27 Date d'inscription Statut Membre Dernière intervention 1

je suis sous Qt creator et j'utilise minGW 32 bits

Rinaldo

Bonjour,

Je ne connais pas le debugger gdb, mais il doit y avoir le moyen de placer un breakpoint sur une ligne de ton code source, et à partir de là d'exécuter le programme ligne par ligne, sous contrôle du debugger, examiner le contenu des variables, les valeurs des paramètres de fonctions, jusqu'à atteindre la ligne de code source qui provoque l'erreur.

Il faut se méfier d'inclure des fonctions trop "complexes" dans le constructeur d'une classe,
(MessageBox, operateur new ...), il est préférable de les mettre dans une autre méthode (objet::initialiser ? ...) qui puisse retourner true ou false selon que l'initialisation de l'objet se soit bien déroulée ou non.

Pour la classe creerUnSon je n'ai pas trouvé de constructeur, je ne sais pas si c'est normal ?

Réponse 3 / 3

leberra Messages postés 27 Date d'inscription Statut Membre Dernière intervention 1

le problème vient de la ligne 305 de la lib liée à fmod.h, et ce, indépendamment de mon code car il se déclenche dès que je rajoute la ligne : #include<FMOD/fmodex.h>

D'où ma question : comment utiliser FMODex avec Qtcreator ?

Votre réponse