Intégration du multimédia à Java avec JMF [30 mn de lecture - paru le 11/4/2003 - Public : Confirmé]

Auteur

Jérôme LEFÈVRE Elève-Ingénieur Supinfo Paris Promotion SUPINFO 2005    Lui écrire    Tous les projets de cet auteur    Le mini-CV de cet auteur

2. Développer avec JMF

2.1. Lire un média

Maintenant que nous avons expliqué le fonctionnement global de JMF, nous allons pouvoir nous intéresser à des actions un peu plus spécifiques. Nous commencerons donc logiquement par les principes de lecture d’un fichier multimédia avec JMF.

Pour cela, nous allons voir comment créer un lecteur (Player) puis comment l’utiliser. La méthode createPlayer() du Manager permet de créer l’objet du type Player. Lors de la création du lecteur, le manager utilise l’url du média que l’on souhaite ouvrir ou un MediaLocator qui permet de définir l’adresse d’une source de données. Une fois le lecteur créé on peut avoir les composants de visualisation avec la méthode getVisualComponent() puis ajouter à l’application ou à l’applet le composant visuel du lecteur (qui permet de contrôler la lecture par exemple).

Beaucoup des méthodes d’un lecteur ne peuvent être appelées qu’à partir de l’état Realized, pour s’assurer que le lecteur a bien atteint cet état le plus simple est de faire appel à la méthode createRealizedPlayer() du manager pour créer le Player. Cette méthode permet d’obtenir directement un Player en état Realized (le programme reste bloqué tant que le Player n’est pas créé, c’est à dire en état Realized).

Pour lancer la lecture, on aura recours plus tard à la méthode start() du lecteur (qui passera automatiquement par les états intermédiaires nécessaires).

2.2. Capturer un média

JMF permet également de capturer des données grâce à des périphériques tels qu’un micro, ou une webcam (à condition qu’elle soit prise en charge, voir 1.2). Le flux récupéré peut ensuite être affiché, stocké dans un fichier, réencodé etc. Voici les étapes nécessaires à la capture d’un média :

• Sélectionner le(s) périphérique(s) de capture que l’on souhaite utiliser grâce au CaptureDeviceManager.
• Récupérer un objet du type CaptureDeviceInfo pour le périphérique sélectionné. Un objet du type CaptureDeviceInfo contient de nombreuses informations concernant le périphérique sélectionné.
• A partir de cet objet, créer un MediaLocator qui servira ensuite à créer une source de données (DataSource).
• Et finalement, créer puis démarrer un lecteur (Player) ou un processeur (Processor).

Comme nous l’avons vu un peu plus tôt, le CaptureDeviceManager permet de gérer les périphériques de capture en listant tous les périphériques que JMF peut utiliser. Il faut ensuite faire appel à la méthode getDeviceList() de ce manager pour obtenir la liste des périphériques. On applique ensuite la méthode getDevice() pour récupérer un objet de type CaptureDeviceInfo concernant le périphérique choisi.

Une fois le périphérique sélectionné, il faut l’utiliser. Pour ce faire on utilise l’objet CaptureDeviceInfo récupéré comme expliqué pour créer le MediaLocator du périphérique de capture. Ce MediaLocator sera ensuite utilisé pour créer un Player ou un Processor ou bien une source de données qui sera utilisée en entrée d’un Player ou Processor. Appelez ensuite la méthode start() pour lancer la capture.

2.3. Transmettre un média en temps réel

          1.3.1. Présentation

JMF permet d’envoyer ou de recevoir des médias en temps réel. Ce genre de distribution des données se fait de plus en plus courant sur Internet dans de nombreuses applications. On peut citer comme exemple les applications de téléconférence, radio et télé live, concerts diffusés en live…

Dans la pratique, un média diffusé de cette façon peut être visualisé avant d’être arrivé entièrement à destination. Le poste client peut lire le média en même temps qu’il le reçoit et aucune notion de durée totale n’est préalable au lancement de la lecture.

Le protocole utilisé pour ce type de transfert est le RTP : Real-Time Transport Protocol. Ce protocole s’appuie sur UDP. Il n’y a donc aucun garantie que les paquets arrivent tous à destination et dans le bon ordre. C’est ici qu’intervient RTCP : Real-Time Transport Control Protocol qui assure un transport sûr des données.

Les APIs nécessaires à la prise en charge du RTP dans JMF sont contenus dans les packages suivants : javax.media.rtp, javax.media.rtp.event, et javax.media.rtp.rtcp.

Lors de la réception d’un flux RTP, vous pouvez lire le média ou l’enregistrer.

          1.3.2. Dans la pratique

Pour transmettre un flux RTP, il faut d’abord utiliser un processeur pour créer une source de données encodées pour le RTP puis la transmettre à un gestionnaire de sessions (SessionManager) ou à un DataSink pour contrôler la transmission.

Il y a 2 méthodes pour transmettre des flux RTP :
• Utiliser un MediaLocator qui a les paramètres d’une session RTP pour construire un DataSink RTP avec la méthode Manager.createDataSink().
• Utiliser un gestionnaire de sessions pour créer un flux à envoyer et contrôler la transmission.

Dans le cas de l’utilisation d’un DataSink, vous pourrez seulement transmettre le premier flux de la source de donnée. Pour transmettre un flux RTP multiple ou avoir accès à des statistiques de session, il faudra utiliser le gestionnaire de sessions (SessionManager).

Utiliser un DataSink est la manière la plus simple de transmettre des données RTP. Mais pour envoyer plusieurs flux RTP, il faut utiliser le gestionnaire de sessions. Les étapes sont les suivantes :
• Créer un processeur qui convertira toutes les pistes d’une source de données à un format adapté au RTP.
• Récupérer la source de données sortante du processeur
• Appeler la méthode createSendStream() d’un gestionnaire de sessions préalablement instancié en lui passant en paramètres la source de données et un index de flux.
• Démarrer le gestionnaire de session avec la méthode startSession()
• Contrôler la transmission avec les méthodes SendStream

Il est parfois nécessaire d’envoyer un flux via plusieurs sessions RTP (s’il y a plusieurs clients) ou d’encoder à différents formats une même source de données. Si vous souhaitez envoyer un flux encoder dans un format spécifique sur plusieurs sessions RTP, il vous faudra cloner la source de données provenant du processeur, cela est possible en créant une source de données clobable grâce au Manager et en appelant la méthode getClone() sur la source de données.