C++Talk.NET

FR C++ · Guest

Bonjour à tous,

comme le titre l'indique, j'ai un souci de design de classe.

J'ai créé trois classes qui me permettent d'afficher de la vidéo
grâce à DirectShow.

J'ai une classe DS_InfosVideo, DS_AffichVideo, qui sont assez
explicites, et une dernière classe TVideoAffich qui est la fenêtre
qui affichera la vidéo, et qui a comme membres privés les deux
classes précédentes...

Je peux afficher 3 types de vidéo: les fichiers vidéo, des fichiers
XML pour la prévisualisation de montages vidéo, et de la vidéo en
temps-réel provenant d'une caméra numérique.

J'ai donc utilisé l'idiome du constructeur nommé pour chacune de ces
3 classes, ce qui me permet de charger les bonnes infos.

Par exemple, pour un fichier vidéo:

class TVideoAffich
{
private:
DS_InfosVideo * Infos;
DS_AffichVideo * Affich;
public:
static TVideoAffich * CreateFromFile(const std::string & path)
{
Infos = DS_InfosVideo::CReateFromFile(path);
Affich = DS_AffichVideo::CReateFromFile(path);
}
};

Pour l'instant, je limite le rendu de la vidéo à un renderer que j'ai
choisi.

Ce que j'aimerai faire maintenant, c'est proposer d'autres choix de
renderer.

Mais je ne me vois pas faire des fonctions du genre pour chacune des
classes:

static TVideoAffich * CreateFromFileVMRRenderer(const std::string &
path);
static TVideoAffich * CreateFromFileBasicRenderer(const std::string &
path);
static TVideoAffich * CreateFromSBEVMRRenderer(const std::string &
path);

etc...

Je voyais bien un truc du genre:

template <class Input>
class DS_InfosVideo : public Input
{
public:
DS_InfosVideo(const std::string & path);
};

template <class Input , class Renderer>
class TVideoAffich : public Input, public Renderer
{
private:
DS_InfosVideo<Input> * Infos;
DS_AffichVideo<Input,Renderer> * Affich;
public:
TVideoAffich(const std::string & path);
};

Seulement la classe Input passée à TVideoAffich n'est pas la même
que celle que doit recevoir DS_InfosVideo ni celle de DS_AffichVideo...

Est-ce que c'est possible de poser des conditions à la compilation, de
telle sorte qu'on ait un truc du genre:

pour TVideoAffich
si Input == VideoAffichInputFile
{
DS_InfosVideo<Infos_Input_File> * Infos;
si Renderer == VideoAffichVMRRenderer
DS_AffichVideo<Affich_Input_File,Affich_VMR_Renderer> * Affich;
sinon
DS_AffichVideo<Affich_Input_File,Affich_Basic_Renderer> *
Affich;
}
sinon
{
///
}

Voilà tout :)

Merci d'avance

Mike

Fabien LE LEZ · Guest

On 16 Jun 2006 05:40:38 -0700,

Michael · Guest

En fait ce n'est pas tout à fait ça...

La classe Infos se charge de récupérer les caractéristiques de la
source (largeur, hauteur, framerate, etc...), avec des fonctions
différentes selon la source.

La classe Affich se charge de connecter une source à une destination,
mais la manière de traiter la source est différente de la classe
Infos.

La classe qui chapeaute le tout se sert de Infos pour la taille de la
fenêtre, et de Affich pour afficher la vidéo sur cette même
fenêtre...

Ce que je veux, c'est pouvoir définir pour la classe qui chapeaute le
tout la manière dont Infos et Affich vont s'occuper de la source et de
l'affichage...

Donc:

VideoAffich<Basic,Fichier> t; entrainerait Infos<Fichier> et
Affich<Basic,Fichier>..

J'ai essayé de m'en sortir avec de la templatisation partielle:

class Infos_InputFile {}
class Affich_InputFile {}
class Affich_AffichVMR {}
class Affich_AffichBasic {}

class TVA_InputFichier {}
class TVA_InputXML {}

class TVA_RenderVMR {}
class TVA_RenderBasic {}

template <class Input , class Renderer>
class TVideoAffich
{
private:
typedef Infos<Input> infos;
typedef Affich<Input,Render> affich;

infos i;
affich a:
public:
TVideoAffich();

void SetPosition(const int position) { // }
};

et en spécialisant pour chacune des solutions possibles

template <>
class TVideoAffich<TVA_InputFile,TVA_RenderBasic>
{
private:
typedef Infos<Infos_InputFile> infos;
typedef Affich<Affich_InputFile,Affich_RenderBasic> affich;

infos i;
affich a:
public:
TVideoAffich();
};

Mais si je fais par exemple:

typedef TVideoAffich<TVA_InputFile,TVA_RenderBasic> toto;
toto t;
t.SetPOsition( Cool

;

ça ne marche pas parce que SetPOsition n'est pas définie pour la
spécialisation utilisée...

Sinon, plutôt que de passer une classe comme paramètre template, je
pensais passer un entier issu d'une énumération, et en fonction de la
valeur de cette enum utiliser derrière les bons template...

du genre:

enum InputType { File , XML , XBE };
enum RendererType { VMR , Basic };

template <InputType input, RendererType render>
class TVideoAffich
{
private:
typedef Infos<input> infos;
typedef Affich<input,render> affich;

infos i;
affich a;
public:
//.....
};

Et pour Infos par exemple:

template<int Input>
class Infos
{

};

Et là je bloque: comment changer le comportement de Infos en fonction
de la valeur de l'énumération, et de préférence à la compilation?

La spécialisation fonctionne comme ça:

template<>
class Infos<0>
{
//File
};

template<>
class Infos<1>
{
//XML
};

Après, peut-être tout simplement que les template ne sont pas la
solution, mais je ne vois pas comment faire dans ce cas...

J''espère avoir été clair Wink

Sylvain Togni · Guest

Michael a écrit :

Fabien LE LEZ · Guest

On 16 Jun 2006 08:24:48 -0700, "Michael" <michael.delva (AT) gmail (DOT) com>:

Fabien LE LEZ · Guest

On 16 Jun 2006 08:24:48 -0700, "Michael" <michael.delva (AT) gmail (DOT) com>:

Fabien LE LEZ · Guest

On 16 Jun 2006 08:24:48 -0700, "Michael" <michael.delva (AT) gmail (DOT) com>:

Michael · Guest

J'ai bien sûr déjà pensé à l'héritage, mais ça me pose un
problème:

pour le moment j'ai uniquement le paramètre Input qui varie, parce que
j'ai un seul Renderer défini.

Donc j'ai les classes:

class InfosVideo;
class InfosVideo_XML : public : InfosVideo;
class InfosVideo_FileL : public : InfosVideo;
class InfosVideo_SBE : public : InfosVideo;

class AffichVideo;
class AffichVideo_XML : public : AffichVideo;
class AffichVideo_FileL : public : AffichVideo;
class AffichVideo_SBE : public : AffichVideo;

ce qui ne me pose pas vraiment de soucis.

Mais je compte proposer un renderer de plus. Ca ne change rien aux
classes InfosVideo et dérivées, mais du coup ça multiplie le nombre
de classes AffichVideo par 2!

class AffichVideo_XML_VMR : public : AffichVideo;
class AffichVideo_XML_Overlay : public : AffichVideo;
etc...

Et donc si on ajoute encore des options, ça devient vite ingérable...

J'avais donc pensé aux templates pour faire quelque chose comme les
policies.

On a une classe de départ, et on change 2 paramètres template pour
définir de quel type est le fichier d'entrée, et grâce à quel
renderer il va s'afficher.

On passe donc ces deux paramètres à la classe qui englobe InfosVideo
et AffichVideo, qui elle se charge derrière de les instancier avec les
bons paramètres template, propres à chacune. (Le paramètre Input de
AffichVideo n'est pas le même que celui de InfosVideo)...

Il serait possible je pense de faire un truc du genre:

template <class InputTypeInfos , class InputTypeAffich, class
RenderType>
class Global
{
private:
Infos<InputTypeInfos> i;
Affich<InputTypeAffich,RenderType> a;
//...
}

Mais j'aimerai éviter la redondance entre InputTypeInfos et
InputTypeAffich qui indiquent tous les deux qu'il s'agit de le même
entrée...

J'avoue ne pas vraiment voir de solution à base de template, sûrement
parce que je ne maitrise pas encore vraiment.

Mais une solution à base de polymorphisme me semble compliquée
également...

Jean-Marc Bourguet · Guest

"Michael" <michael.delva (AT) gmail (DOT) com> writes:

Fabien LE LEZ · Guest

On 16 Jun 2006 12:08:43 -0700, "Michael" <michael.delva (AT) gmail (DOT) com>:

Michael · Guest

J'ai du mal m'exprimer alors...

InfosVideo n'est pas une interface qu'on peut assimiler à une
source... Elle utilise des interfaces COM uniquement dédiées à la
récupération des infos d'une source vidéo.

Par contre AffichVideo est composée de deux "sous-objets": une source
(dont les interfaces COM sont différentes selon le type de la source :
XML, Fichier...) et un renderer, qui, peut-importe la source affiche le
rendu de cette source; Ce renderer peut lui aussi être de différents
types (VMR, Overlay, etc...)

Donc j'ai bien de multiples interfaces à gérer : Nbre sources dispos
* Nbre renderer dispos...

Fabien LE LEZ · Guest

On 16 Jun 2006 14:28:17 -0700, "Michael" <michael.delva (AT) gmail (DOT) com>:

Sylvain · Guest

Michael wrote on 16/06/2006 21:08:

Michael · Guest

Bon, suivant vos conseils, j'en suis arrivé à ça:

class AV_Input
{
};

class AV_InputFile : public AV_Input
{
};

class AV_InputXML : public AV_Input
{
};

class AV_Renderer
{
};

class AV_RendererVMR : public AV_Renderer
{
};

class AV_RendererBasic : public AV_Renderer
{
};

class AffichVideo
{
private:
AV_Renderer * Renderer;
AV_Input * Input;
public:
AffichVideo(AV_Renderer * renderer, AV_Input * input)
: Renderer(renderer),Input(input)
{}
};

Ce qui m'oblige à l'utiliser comme ça:

AffichVideo * affich = new AffichVideo(new AV_RendererVMR(),new
AV_InputFile());
affich->toto();

Je suis un peu embêté avec les new...

J'aurais préféré, si c'est possible, utiliser une syntaxe comme celle-ci:

AffichVideo * affich = new AffichVideo(AV_RendererVMR(),AV_InputFile());

Et utiliser des références dans AffichVideo. Mais mes premiers essais ne
sont pas très concluants.

Mais je pense que je suis obligé avec le polymorphisme?

Fabien LE LEZ · Guest

On 19 Jun 2006 17:21:14 GMT, Michael <michael.at.gmail.dot.com>: