Documentation Qtfr - version_Qt3

Un conteneur pour MPlayer (utilisation de QProcess)

IrmatDen — Mon, 02 Apr 2007 09:01:00 +0200

Comment visualiser une vidéo dans Qt ?
Comment intégrer MPlayer et Qt ?

Qt, dans son souci de framework généraliste, n'implémente pas toujours tout ce dont on peut avoir besoin, surtout lorsque cela n'est pas d'usage courant. Les vidéos font partie de ce qui n'était pas couvert par Qt (maintenant supporté depuis la 4.4 par le biais de Phonon). Cependant, un grand nombre de librairies et autres backends existent. Nous allons voir comment utiliser l'un d'entre eux: MPlayer.

Version concernée : Toutes versions (exemple fait avec C++/Qt4 et une version pyQt disponible)
Auteur : Denys Bulant (IrmatDen), alteo_gange et egaudrain pour les versions pyQt
Résumé : utiliser MPlayer conjointement à Qt pour afficher une vidéo
Fil de discussion : Forum

Généralité sur MPlayer en tant que backend...

La particularité de MPlayer est de ne pas s'intégrer par le biais d'une api, mais par un process externe. Les applications désirant l'utiliser en tant que tel, doivent communiquer avec lui par le biais de son flux d'entrée. Les flux de sorties (standard/erreur) peuvent bien sûr être analysés pour récupérer diverses infos sur la vidéo ainsi que les réponses à des requêtes pouvant être formulées par votre application.

Voici ce dont vous aurez besoin :

MPlayer installé, et fonctionnel,
La page des options de MPlayer,
Et la liste des options en slave mode pour mplayer (c'est toutes les manip qui vous sont permises, donc considérez ce fichier comme votre référence ;)).

Pour utiliser MPlayer comme backend, il y a 2 arguments à lui passer impérativement:

l'id du widget à utiliser pour le rendu par le biais de "-wid"
"-slave" qui permet de le mettre en mode esclave, d'où le nom ;-)

Exemple de code lançant MPlayer comme backend:

QStringList args;
// On demande à utiliser mplayer comme backend
args << "-slave";
#ifdef Q_WS_WIN
// reinterpret_cast<unsigned int> obligatoire, HWND ne se laissant pas convertir gentiment ;)
args << "-wid" << QString::number(reinterpret_cast<unsigned int>(renderTarget->winId()));
#else
// Sur linux, pas de manip pour Wid :)
args << "-wid" << QString::number(renderTarget->winId());
#endif

A savoir aussi que sur Windows, je n'ai trouvé que directx comme driver de sortie :/ Cela ne concerne pas les autres OS; lors de mon test sur Linux, je n'ai eu aucun driver à spécifier et cela marche nickel.

Et apparemment les seuls drivers compatibles pour un embarquement de MPlayer sous Linux sont xv, x11 et gl. Et sous Linux, il faut faire attention à avoir un widget de taille raisonnable pour contenir la vidéo. En effet, contrairement à Windows, un resize à la volée n'est pas possible :/

Ensuite, le mode esclave permet donc de commander MPlayer pour:

obtenir des infos (ex: get_video_resolution/get_time_length/...)
lui donner un ordre (ex: play/pause/quit/...)

Tout ce qui lui est transmis, doit être terminé par un retour chariot. Si vous demandiez une information, elle sera renvoyée sur la sortie standard, avec un début de ligne propre à chaque commande (ex: get_video_resolution renverra ANS_VIDEO_RESOLUTION='resX x resY')

Exemple complet

Voici un programme proposant les fonctionnalités suivantes:

lecture d'une vidéo
arrêt
avancer/reculer en déplaçant le slider
affiche le log de toutes ce qui sort sur les flux stdout et stderr de mplayer

Vous le trouverez en annexe de ce tuto ; seuls les points essentiels sont repris ici par souci de clarté. Pour vos tests, pensez à changer les valeurs de mPlayerPath et movieFile, en haut du fichier.

Ce n'est pas un frontend complet, mais cela vous permettra de voir fonctionner Qt 4 avec MPlayer en utilisant QProcess :)

Comme dit dans l'introduction, une version pyQt a été réalisée par alteo_gange. Elle est disponible sur le forum. A noter qu'une version multi-plateforme a été postée par egaudrain; le code est dispo à ce post.

class PlayerWidget: public QWidget
{
    Q_OBJECT
 
public:
    PlayerWidget(QWidget *parent =0)
        :QWidget(parent), isPlaying(false)
    {
        [...]
        renderTarget = new QWidget;
        renderTarget->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
        renderTarget->setAttribute(Qt::WA_PaintOnScreen);
        renderTarget->setMinimumSize(320, 240);
        [...]
 
        mplayerProcess = new QProcess(this);
 
        [...]
        connect(mplayerProcess, SIGNAL(readyReadStandardOutput()),
            this, SLOT(catchOutput()));
        connect(mplayerProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
            this, SLOT(mplayerEnded(int, QProcess::ExitStatus)));
        [...]
    }
 
protected:
    virtual void closeEvent(QCloseEvent *e)
    {
        [...]
    }
 
    private:
    bool startMPlayer()
    {
        [...]
        QStringList args;
        // On demande à utiliser mplayer comme backend
        args << "-slave";
        // Et on veut ne pas avoir trop de chose à parser  :) 
        args << "-quiet";
 
#ifdef Q_WS_WIN
        // reinterpret_cast<qlonglong> obligatoire, winId() ne se laissant pas convertir gentiment ;)
        args << "-wid" << QString::number(reinterpret_cast<qlonglong>(renderTarget->winId()));
        args << "-vo" << "directx:noaccel";
#else
        // Sur linux, aucun driver n'a été nécessaire et pas de manip pour Wid :)
        args << "-wid" << QString::number(renderTarget->winId());
        log->append("Video output driver may not be necessary for your platform. \
                    Check: http://www.mplayerhq.hu/DOCS/man/en/mplayer.1.html \
                    at the VIDEO OUTPUT DRIVERS section.");
#endif
 
        args << movieFile;
        qDebug(args.join(" ").toUtf8());
 
        // On parse la stdout et stderr au même endroit, donc on demande à "fusionnner" les 2 flux
        mplayerProcess->setProcessChannelMode(QProcess::MergedChannels);
        mplayerProcess->start(mplayerPath, args);
        if(!mplayerProcess->waitForStarted(3000))
        {
            qDebug("allez, cherche le bug :o");
            return false;
        }
 
        // On récupère les infos de base
        mplayerProcess->write("get_video_resolution\n");
        mplayerProcess->write("get_time_length\n");
        [...]
    }
 
    bool stopMPlayer()
    {
        [...]
        mplayerProcess->write("quit\n");
        if(!mplayerProcess->waitForFinished(3000))
        {
            qDebug("ZOMG, ça plante :(");
            return false;
        }
 
        return true;
    }
 
private slots:
    void catchOutput()
    {
        while(mplayerProcess->canReadLine())
        {
            QByteArray buffer(mplayerProcess->readLine());
            log->append(QString(buffer));
 
            // On vérifie si on a eu des réponses
            // réponse à get_video_resolution : ANS_VIDEO_RESOLUTION='176 x 144'
            if(buffer.startsWith("ANS_VIDEO_RESOLUTION"))
            {
                buffer.remove(0, 21);
                buffer.replace(QByteArray("'"), QByteArray(""));
                buffer.replace(QByteArray(" "), QByteArray(""));
                buffer.replace(QByteArray("\n"), QByteArray(""));
                buffer.replace(QByteArray("\r"), QByteArray(""));
                int sepIndex = buffer.indexOf('x');
                int resX = buffer.left(sepIndex).toInt();
                int resY = buffer.mid(sepIndex+1).toInt();
                renderTarget->setMinimumSize(resX, resY);
            }
            // réponse à get_time_length : ANS_LENGTH=45.28
            if(buffer.startsWith("ANS_LENGTH"))
            {
                buffer.remove(0, 11);
                buffer.replace(QByteArray("'"), QByteArray(""));
                buffer.replace(QByteArray(" "), QByteArray(""));
                buffer.replace(QByteArray("\n"), QByteArray(""));
                buffer.replace(QByteArray("\r"), QByteArray(""));
                float maxTime = buffer.toFloat();
                timeLine->setMaximum(static_cast<int>(maxTime+1));
            }
            // réponse à get_time_pos : ANS_TIME_POSITION=2.4
            if(buffer.startsWith("ANS_TIME_POSITION"))
            {
                buffer.remove(0, 18);
                buffer.replace(QByteArray("'"), QByteArray(""));
                buffer.replace(QByteArray(" "), QByteArray(""));
                buffer.replace(QByteArray("\n"), QByteArray(""));
                buffer.replace(QByteArray("\r"), QByteArray(""));
                float currTime = buffer.toFloat();
                timeLine->setValue(static_cast<int>(currTime+1));
            }
        }
    }
 
    void pollCurrentTime()
    {
        mplayerProcess->write("get_time_pos\n");
    }
 
    // Dirige la timeline
    void timeLineChanged(int pos)
    {
        mplayerProcess->write(QString("seek " + QString::number(pos) + " 2\n").toUtf8());
    }
 
    // Play/stop
    void switchPlayState()
    {
        [...]
    }
 
    void mplayerEnded(int exitCode, QProcess::ExitStatus exitStatus)
    {
        [...]
    }
 
private:
    [...]
    QWidget *renderTarget;
    QProcess *mplayerProcess;
    [...]
};

Si vous avez des remarques...

Si vous avez besoin d'un éclaircissement, vous pouvez le faire ici.

Intégration de VLC

lud42fr — Wed, 21 Feb 2007 22:55:00 +0100

Comment intégrer VLC dans une application Qt ?
Comment visualiser une vidéo dans une applicaiton Qt ?

Ce tutoriel va explorer l'intégration de la bibliothèque VLC dans Qt, pour la lecture de fichier.

Version : Qt3, Qt4
Auteur : Ludo (lud42fr)
Status : basé sur la version SVN 0.9.0 de l’API VLC (devrait egalement fonctionner avec une version >= 0.8.6)

Introduction

Qt, dans son souci de framework généraliste, n’implémente pas toujours tout ce dont on peut avoir besoin, surtout lorsque cela n’est pas d’usage courant. Les vidéos font partie de ce qui n’est pas couvert par Qt. Cependant, un grand nombre de librairies et autres backends existent. Nous allons voir comment utiliser l’une d’entre elle: VLC.

Pré-requis

Voici ce dont vous aurez besoin :

Les librairies VLC >= 0.8.6 (Page de téléchargement)
La documentation des fonctions internes de VLC
Il semblerait que VLC soit difficilement compilable sous Visual C++. Comme ce tutoriel suppose de pouvoir lier votre application avec les libraires VLC, les personnes désireuses de développer sous Windows devront utiliser Mingw pour générer leur application.

Pour compiler VLC 0.9.0 (la version actuellement en cours de développement, récupérable depuis le SVN), vous aurez besoin de :

bibliothèque MAD (MPEG Audio Decoder) : http://www.underbit.com/products/ma... ou mettre une option lors du configure pour la désactiver,
FFMpeg : http://ffmpeg.mplayerhq.hu/,
liba52 : http://liba52.sf.net,
libmpeg2 : http://libmpeg2.sf.net.

Lecteur vidéo

Ce tutoriel détaille la manière d'utiliser l'API VLC au travers d'une application Qt.

L’avantage de cette méthode est que le contrôle de VLC est plus simple et précis et ne nécessite pas d’exécuter/piloter un processus externe (contrairement à l'utilisation de MPlayer).

Nous allons créer un petit exemple simple de lecteur vidéo, ce dernier permettant :

d’initialiser VLC,
de charger un flux vidéo,
de naviguer dans la vidéo (avance/retour),
de modifier le volume.

Une image valant mieux qu'un long discours, voici une capture d'écran du résultat final :

Le code de ce tutorial (source + .pro)

Compilation

La compilation de l’exemple nécessite bien entendu les includes et les libraires de VLC. Celles ci doivent êtres dans dans les chemins de recherche

Linux/Unix

Voici le fichier pro typique :

TEMPLATE = app
DEPENDPATH += .
INCLUDEPATH += . 
SOURCES += tuto_vlc.cpp
LIBS+=-lvlc

Explications

Si l'on résume les étapes nécessaires à la lecture d'un vidéo dans une application Qt :

initialiser un contexte VLC,
ajouter un flux à la playlist,
rediriger la fenêtre vidéo de sortie vlc sur un widget Qt de l'application,
démarrer la lecture du flux.

Certaines fonctions de l'API de VLC seront détaillées. Toutes ces fonctions et bien plus encore sont disponibles dans la documentation de VLC.

Initialisation d'un contexte VLC

Normalement seule l'inclusion de l'entête vlc/libvlc.h est nécessaire pour utiliser toutes les fonctions VLC.

#include <vlc/libvlc.h>

VLC reporte toutes ses erreurs dans une structure particulière libvlc_exception_t. Avant tout appel à une fonction VLC, il nous faudra donc une telle structure :

libvlc_exception_t _vlcexcep; //déclaration de la structure
libvlc_exception_init (&_vlcexcep); //initialisation de la structure

Quelques fonctions pratiques à utiliser avec libvlc_exception_t :

if(libvlc_exception_raised(&_vlcexcep)!=0) {....} //teste si une erreur a eu lieu.
libvlc_exception_get_message(&_vlcexcep); //retourne le message d'erreur
libvlc_exception_clear(&_vlcexcep); //efface la/les erreurs précédentes

Il est maintenant temps de créer un contexte VLC, de type libvlc_instance_t, nécessaire à la plupart des fonctions :

libvlc_instance_t *_vlcinstance;
_vlcinstance=libvlc_new(argc,argv,&_vlcexcep);

Il n'est possible de lire qu'un seul flux vidéo à la fois par contexte. Pour lire plusieurs flux en parallèle, il faut donc initialiser plusieurs contextes. Lorsqu'un contexte, n'est plus utile, ne pas oublier de le libérer :

libvlc_destroy (_vlcinstance, &_vlcexcep);

Ajout d'un flux

Le chargement d'un flux vidéo se fait dans un contexte initialisé et dans l'élément playlist de VLC (se réfèrer à la doc quant à la gestion des playlist, ce tutoriel n'en faisant pas d'autres mentions).

libvlc_playlist_clear(_vlcinstance,&_vlcexcep); //on vide la playlist
libvlc_playlist_add (_vlcinstance,URL,NULL,&_vlcexcep);//on ajoute le nouveau flux

Note : à ce niveau, le fichier est dans la playlist, il n'est pas en cours de lecture ou n'a pas interrompu la lecture en cours.

Avec URL une chaine de caractère de la forme (principalement) :

Type	Forme
Fichier local	file://chemin
Url http	http://ip:port/file
Fichier ftp	ftp://ip:port/file
DVD	dvd://[device]
Flux UDP	udp:[]@[][:]%%

Redirection du flux sur un widget Qt

La redirection de la sortie vidéo sur un widget de l'application est une des étapes les plus importantes pour l'intégration (ce n'est pas la plus compliquée ;-) ).

A noter que VLC, se chargera d'adapter la taille de la vidéo à la taille du widget tout en conservant l'aspect de la video (VLC se chargera aussi de resizer la video si la taille du widget venait a changer en cours de lecture).

N'importe quel widget peut servir pour afficher une video, mais dans la mesure ou il sera complètement recouvert, un simple QWidget suffit.

//Notez l'usage de Widget->winId() pour indiquer on dessiner la video
libvlc_video_set_parent(_vlcinstance ,Widget->winId(),&_vlcexcep);

Functions vidéos/audios

Certaines fonctions requièrent un pointeur sur libvlc_input_t .Pour obtenir ce pointeur, un flux doit etre en cours de lecture/pause :

libvlc_input_t *input=libvlc_playlist_get_input (_vlcinstance,&_vlcexcep); //obtenir un pointeur input
libvlc_input_free (input); //il est en general de bon ton de libérer input après usage

Contrôle de la vidéo

Démarrer la lecture :

libvlc_playlist_play (_vlcinstance , -1, 0, NULL, &_vlcexcep);
// avec :
//          -1 pour indiquer de lire l'element suivant de la playlist
//          0 le nombre d'option a passer au flux a lire
//          NULL : les options

Stopper la lecture :

libvlc_playlist_stop (_vlcinstance, &_vlcexcep);

Mettre en pause la lecture :

libvlc_playlist_pause (_vlcinstance, &_vlcexcep);

Connaître l'état :

int etat=libvlc_playlist_isplaying(_vlcinstance, &_vlcexcep);
//etat=0 si stop ou pause
//etat=1 si lecture en cours

Lire en boucle :

int loop=1; //mettre a 0 pour stopper la lecture en boucle
libvlc_playlist_loop (_vlcinstance, loop,&_vlcexcep);

Connaître la durée totale du flux (nécessite un pointeur input) :

long long duree=libvlc_input_get_length (input, &_vlcexcep);

Connaître la position actuelle en ms (nécessite un pointeur input) :

long long position=libvlc_input_get_time (input, &_vlcexcep);

Se positionner dans le flux (position en ms - nécessite un pointeur input) :

libvlc_input_set_time (input, 42000,&_vlcexcep); //se positionne a 42 sec

Connaître la position actuelle en pourcentage (nécessite un pointeur input) :

float posEnPourcent=libvlc_input_get_position (input, &_vlcexcep)*100.0;

Se positionner dans le flux (position en pourcentage du temps total - nécessite un pointeur input) :

libvlc_input_set_position(input, 0.42f,&_vlcexcep); // se positionne a 42% du flux ???

Contrôle du volume

Obtenir la valeur du volume comprise entre 0 et 100 - 0 étant le minimum :

int volume=libvlc_audio_get_volume (_vlcinstance, &_vlcexcep);

Positionner le volume (valeur en 0 et 100) :

libvlc_audio_set_volume (_vlcinstance, 42,&_vlcexcep); //volume a 42%

Intégration de SDL

IrmatDen — Wed, 21 Feb 2007 13:11:00 +0100

Comment intégrer SDL dans un widget Qt ?

Ce tutoriel va explorer l'intégration de la bibliothèque SDL dans Qt, le rendu étant effectué dans un widget Qt.

Version : Qt4 (Qt3 possible avec quelques ajustements)
Auteur : Denys Bulant (IrmatDen)

Pré requis:

La librairie SDL : le site contient une section documentation pour débuter

Un widget Qt comme cible de rendu pour SDL

Les moteurs graphiques des différents Qt ne sont souvent pas adaptés au travail graphique intense (sauf à passer par OpenGL, mais on détourne le problème - c'est d'ailleurs ce que l'on va faire ici).

Signifier à SDL la fenêtre à utiliser

Se servir d'un widget comme zone de rendu cible pour SDL est très simple: il suffit d'une variable d'environnement. Cette variable est SDL_WINDOWID et peut être de 2 formats:

un entier, tel quel
une valeur hexadécimale, préfixé par '0x'

Une variable valide est un handle de fenêtre (dont le format peut varier en fonction de l'environnement utilisé). Ce handle s'obtient par la méthode QWidget::winId(), qui est une méthode publique.

Une fois la zone de rendu définie par cette variable, on peut initialiser le moteur graphique de SDL. Voici par exemple le code permettant de réaliser cette intégration :

char windowid[64];
#ifdef Q_WS_WIN
	sprintf(windowid, "SDL_WINDOWID=0x%lx", reinterpret_cast<qlonglong>(winId()));
#elif defined Q_WS_X11
	sprintf(windowid, "SDL_WINDOWID=0x%lx", winId());
#else
	qFatal("Fatal: cast du winId() inconnu pour votre plate-forme; toute information est la bienvenue!");
#endif
SDL_putenv(windowid);
// Initialisation du système vidéo de SDL
SDL_Init(SDL_INIT_VIDEO);
screen = SDL_SetVideoMode(width(), height(), 32, SDL_SWSURFACE);

Attention : ne le faîtes pas l'initialisation du système vidéo de SDL avant que la création réelle de votre widget (le moment le plus sûr est lors du premier showEvent), sinon une seconde fenêtre sera créée par et pour SDL.

Configuration du widget de rendu

Le dessin direct par SDL sur un widget Qt implique une petite configuration des attributs de dessin du dit widget:

setAttribute(Qt::WA_PaintOnScreen);
setAttribute(Qt::WA_NoSystemBackground);

A faire lors de l'utilisation de SDL, sinon, vous aurez une bouillie de pixels "inspirée" par le fond de l'écran à cet emplacement ;)

Conflit de main

Il y a par contre un conflit entre SDL et Qt au niveau de la fonction main. Lorsque main n'est pas le point d'entrée d'un programme (ce qui est le cas sur win32 par exemple), Qt appelle main à partir de son implémentation de WinMain. SDL quant à lui fait un define (code extrait de SDL_main.h) :

#define main SDL_main
/* The prototype for the application's main() function */
extern C_LINKAGE int SDL_main(int argc, char *argv[]);

Pour supprimer ce problème, ils vous faut annuler la définition de SDL, juste après l'inclusion de SDL.h :

#include "SDL.h"
#undef main

Une fois ceci fait, vous pouvez utiliser sereinement le système vidéo de SDL au sein de votre application Qt :)

Modification du fichier projet

Comme toute librairie, son utilisation avec votre programme doit être expressément signalée sous peine d'erreurs de compilation et/ou de liaison. Les informations à ajouter dans le fichier projet sont :

le chemin vers les en-têtes SDL (ex: INCLUDEPATH += /usr/local/include/)
la librairie avec laquelle lier (et éventuellement son chemin) (ex: LIBS += -L/usr/local/lib/ -lSDL)

Exemple complet

Vous trouverez associé à ce tutoriel un exemple illustrant l'utilisation de la SDL pour un starfield - qui rappellera des souvenirs aux (ex-)possesseurs de vieilles machines et qui ont codé avant l’arrivée du S-VGA (définit comme étant haute-résolution à l’époque) ;-)

J'ai repris ici les points principaux de la classe :

[...]
 
#ifdef Q_WS_WIN
#include <SDL.h>
#elif defined Q_WS_X11
#include <SDL/SDL.h>
#endif
 
/* PIEGE: main est redéfini par SDL.h comme SDL_Main.
                On retire donc la définition puisque Qt le gère
*/
#undef main
 
[...]
 
class SDLWidget : public QWidget
{
    Q_OBJECT
 
public:
    SDLWidget()
    :refreshTimer(0), windowInitialized(false), screen(0), StarNumbers(100)
    {
        [...]
    }
 
    virtual ~SDLWidget()
    {
        SDL_Quit();
    }
 
protected:
    virtual void showEvent(QShowEvent *e)
    {
        if(!windowInitialized)
        {
            // C'est ici qu'on dis à SDL d'utiliser notre widget
            char windowid[64];
#ifdef Q_WS_WIN
 
			sprintf(windowid, "SDL_WINDOWID=0x%lx", reinterpret_cast<qlonglong>(winId()));
#elif defined Q_WS_X11
			sprintf(windowid, "SDL_WINDOWID=0x%lx", winId());
#else
			qFatal("Fatal: cast du winId() inconnu pour votre plate-forme; toute information est la bienvenue!");
#endif
            SDL_putenv(windowid);
 
            // Initialisation du système vidéo de SDL
            SDL_Init(SDL_INIT_VIDEO);
            screen = SDL_SetVideoMode(width(), height(), 32, SDL_SWSURFACE);
            windowInitialized = true;
        }
    }
 
private:
    [...]
 
private:
    [...]
 
private slots:
    void onRefresh()
    {
        if(windowInitialized && screen)
        {
            SDL_LockSurface(screen);
                // Nettoyage de l'écran
                SDL_FillRect(screen, NULL, 0);
                // Dessin du starfield
                drawStarfield();
            SDL_UnlockSurface(screen);
 
            // Rafraîchissement...
            SDL_UpdateRect(screen, 0, 0, 0, 0);
 
            // Et enfin, mise à jour des positions des étoiles
            updateStarfield();
        }
    }
 
private:
    [...]
};

N’oubliez pas d’ajouter les références d’inclusion et de bibliothèques de SDL au .pro, et laissez vous aller à un peu de nostalgie ;-)

Utilisation avancée

L'ensemble du code illustrant l'utilisation décrite ici est disponible sur la seconde pièce jointe.

La méthode décrite précédemment est suffisante si vous n'avez besoin de SDL que dans un seul widget. Mais si vous voulez utiliser SDL comme système d'affichage pour plusieurs widgets, alors il faut changer de stratégie. En effet, SDL ayant pris le parti d'utiliser une seule et unique variable d'environnement pointant vers un et un seul identifiant de fenêtre, il va nous falloir utiliser ce système différemment.

Nous allons donc devoir créer un widget invisible servant à initialiser le système SDL. (Vous trouverez une classe remplissant cette fonctionnalité dans les fichiers tools.h et tools.cpp (classe SDLContext) fournis avec l'archive.) Le dessin se fera alors sur diverses surfaces SDL (au moins 1 par widget où vous comptez l'utiliser en fait).

Il nous font donc aussi des fonctions de conversion entre QImage et SDL_Surface, ainsi qu'une fonction de création de SDL_Surface. Cette dernière est nécessaire afin de paramétrer les surfaces SDL de façon à ce que leur format soit compatible à 100% avec les formats proposés par QImage. Dans l'exemple, ces fonctions ne couvrent pas tout les cas nécessaires, il ne tient qu'à vous de les compléter selon vos besoins:

// Création d'une surface SDL rapidement convertible en QImage
SDL_Surface* createQImageCompliantSurface(Uint32 flags, int width, int height)
{
	static const int Rmask = 0x00FF0000;
	static const int Gmask = 0x0000FF00;
	static const int Bmask = 0x000000FF;
	static const int Amask = 0xFF000000;
 
	return SDL_CreateRGBSurface(flags, width, height, 32, Rmask, Gmask, Bmask, Amask);
}
 
/* Fonctions de conversion entre SDL_Surface et QImage
   SDLSurfaceToQImage **DOIT** recevoir une surface
   construite avec createQImageCompliantSurface
*/
QImage SDLSurfaceToQImage(SDL_Surface *s)
{
	SDL_LockSurface(s);
		QImage im(static_cast<uchar*>(s->pixels), s->w, s->h, QImage::Format_RGB32);
        SDL_UnlockSurface(s);
 
	return im;
}

2 améliorations conseillées:

il est intéressant de définir notre propre type encapsulant ceci afin de réduire à 0 le risque de passer une mauvaise surface.
on peut ajouter une méthode SDLSurfaceToQImage prenant en paramètre une référence vers un QImage afin de modifier les données d'un QImage précédemment créé. Dans les scènes requierant un affichage rapide, cela peut apporter une différence

Nous avons donc un système SDL fonctionnel pour l'appli ainsi que la possibilité d'avoir des surfaces dont la transformation en QImage est extrêmement rapide (puisqu'il s'agit de la copie brute des octets formant la surface). A la différence de la première partie du tutoriel, nous ne dessinons plus sur une surface affichée à l'écran (que nous utilisions ou non le double buffering ne change rien). Il va donc nous falloir surcharger paintEvent pour gérer l'affichage. La mise à jour de notre QImage se fera à chaque mise à jour de la surface. Inutile de le faire dans le paintEvent puisque certains de ces événements seront générés par le système sans qu'il y ait obligatoirement eu de modifications de la surface, par exemple le fait que le widget soit minimisé puis restauré/maximisé.

class Widget : public QWidget
{
protected:
   virtual void paintEvent(QPaintEvent *e)
   {
      QPainter p(this);
      p.drawImage(displayBuffer);
   }
 
   void modificationSurfaceSDL()
   {
      /* on modifie la surface renderer par diverses opérations de dessin */
      displayBuffer = SDLSurfaceToQImage(renderer);
      update(); // on demande par la même occasion un rafraichissement du widget
   }
 
private:
   SDL_Surface *renderer;
   QImage displayBuffer;
};

Voici le screenshot obligatoire présentant l'exemple en cours d'exécution:

Tutoriel Indépendant de Qt3

Visiteur — Mon, 19 Feb 2007 22:09:00 +0100

Le tutoriel indépendant de Qt est un livre en ligne visant à couvrir la plupart des matières impliquées dans le processus de développement des applications professionnelles Qt de qualité.

Version : Qt3
Auteur : e8johan, traduction Jean-Luc Biord (jlbrd)

Le tutoriel indépendant est disponible sur cette page : Tutoriel indépandant de Qt.

Ce tutoriel a été écrit pour le programmeur C++ pour qui Qt est assez nouveau. Il couvre tous les aspects de la programmation Qt pour le débutant :

Qt, couplage faible et programmation évènementielle
Le Modèle Objet de Qt
Ressources de Qt sur l’Internet
Les Outils de Qt
Une Application de base de Qt
Une application Qt faite à la main.
Le Carnet d’adresses
Fichiers, répertoires et flux.
XML
Validation de saisie
Qwt
Le Canvas
Listes, Arbres et Tableaux
OpenGL

Débuter avec Qt 3

Nicolas — Sun, 18 Feb 2007 22:39:00 +0100

Le seul ouvrage français traitant de Qt3, ce livre offre au débutant une introduction à Qt3.

Il est disponible en libre téléchargement en PDF sur ce site.

Informations

Auteurs : Jean-Luc Biord
Langue : français
ISBN : 295228430X
Pages : 171

Résumé

Le premier livre français traitant de Qt3, ce livre permet au débutant de comprendre les mécanismes de la programmation Qt.

Le livre n'est plus édité, par contre son auteur à décider de le laisser en libre téléchargement en PDF : téléchargez.

Table des matières

Pour commencer
- Les outils fournis par Qt
- Un premier programme
- Gestion des objets en mémoire
- Signaux et Slots

Dialogues
- Sous-classer QDialog
- Communication entre dialogues
- QFileDialog
- QMessageBox
- QInputDialog

Les principaux Widgets
- QPushButton
- QRadioButton
- QCheckBox
- QButtonGroup
- QListBox
- QLineEdit
- QSpinBox
- QTextEdit
- QComboBox
- QLabel

Disposer les widgets dans les dialogues
- Coordonnées absolues
- Position avec les layouts
- Fenêtres principales.
- Sous-classer QMainWindow
- Création des actions
- Menu et barres d’outils
- Barre de statut
- Ouvrir des dialogues

Les Entrées/Sorties
- Fichiers
- Flux de données
- Utiliser ensemble Fichiers et Flux de données

Quelques classes intéressantes
- QString
- Les modèles de classes

Utiliser Qt Designer
- Création et gestion de projets
- Dialogues
- Fenêtres principales
- Collection d’images

Techniques de débogage

C++ GUI Programming with Qt 3

Nicolas — Sun, 18 Feb 2007 22:08:00 +0100

Le premier livre officiel de Trolltech pour la programmation Qt (version 3.2). Il aborde tous les aspects de la bibliothèque : organisation des widgets, évènements, programmation 2D et 3D...

Il est actuellement en libre téléchargement en PDF sur le site de l'éditeur.

Informations

Auteurs : Jasmin Blanchette et Mark Summerfield
Editeur : Prentice Hall PTR
Collection : Bruce Perens' Open Source Series
Langue : anglais
ISBN : 0131240722
Pages : 464

Résumé

Le premier livre officiel de Trolltech pour la programmation Qt (version 3.2).

Ce livre couvre tous les aspects de la programmation Qt, avec une première partie offrant une approche simple pour le débutant, en détaillant pas à pas la création d'une application complète. La seconde partie détaille les différents aspects de la bibliothèque : organisation des widgets, évènements, programmation 2D et 3D...

Le CD comporte une version non-commerciale de Qt 3.2 pour Windows ainsi que les éditions GPL de Qt 3.2 sous Unix/Linux/Mac OSX.

Le livre est actuellement en libre téléchargement en PDF sur le site de Prentice Hall.

Table des matières

Basic Qt
- Getting Started.
- Creating Dialogs.
- Creating Main Windows.
- Implementing Application Functionality.
- Creating Custom Widgets.

Intermediate Qt
- Layout Management.
- Event Processing.
- 2D and 3D Graphics.
- Drag and Drop.
- Input/Output.
- Container Classes.
- Databases.
- Networking.
- XML.
- Internationalization.
- Providing Online Help.
- Multithreading.
- Platform-Specific Features.

Appendices
- Installing Qt.
- Qt's Class Hierarchy.