Forums Développement Multimédia

Les formations Mediabox
Les formations Mediabox

Détecter les dimensions maximales de capture vidéo

Compatible ActionScript 2. Cliquer pour en savoir plus sur les compatibilités.Par Arthy (Le Crabe)

Voici une classe qui devrait être utile pour ceux qui manipulent la capture de vidéo via le player flash, comme par exemple une webcam pour enregistrer un flux vidéo sur un Flash Media Server.

En effet, Flash nous permet de récupérer un device vidéo pour l'enregistrement mais ne nous permet pas d'en connaître ses dimensions de captures maximales.

Dans la plupart des cas on travaillent sur de petites dimensions communes à tous ces périphériques (160×120 15fps par exemple). Mais impossible d'en connaître les capacités optimum.

Voici donc une classe qui vous permettra de récupérer les dimensions maximales de capture, et vérifier la compatibilité de certains ratio.

Exemple

L"extension Adobe Flash Plugin est nécessaire pour afficher ce contenu.

La classe

/** Cette classe enrichie la classe native Camera
 *  avec 3 fonctions :
 * 	- getMaxCaptureSize
 * 	- getCompatibleRatios
 * 	- isCompatibleRatio
 *  @version 1.0
 *  @since 1.0
 *  @author Arthy - www.lecrabe.net
 */
 
class net.lecrabe.medias.advCamera extends Camera{
 
 	// Propriété de la classe
	public static var className:String = "advCamera" ;
	public static var classPackage:String = "net.arthy.medias.advCamera";
	public static var version:String = "1.0.0";
	public static var author:String = "Arthy";
	public static var link:String = "http://www.lecrabe.net" ;
 
 	/**
	* retourne un objet contenant la dimension maximale de capture parmi les ratios disponibles
	*@param oCam	l'objet caméra à  tester
	*@param fps	le fps souhaité (le fps obtenu peut être différent si la résolution ne le supporte pas)
	* 		prends le fps courant si non précisé
	*@return objet	retourne un objet contenant les dimensions max de capture au fps demandé 
	*/
	public static function getMaxCaptureSize(oCam:Camera, fps:Number):Object{
		var aValidRatios = new Array();				// tableau pour stocker les ratios valides
		aValidRatios = getCompatibleRatios(oCam, fps);		// remplissage du tableau
 
		// recherche des dimensions maximales parmis les ratios valides
		var wmax = 0;
		var hmax = 0;
		var fpsmax;
		for (var i=0; i<aValidRatios.length; i++){
			var  w = aValidRatios[i].w;
			var h = aValidRatios[i].h;
			if (w>=wmax && h>=hmax){
				// mise a jour des dimensions max
				wmax = w;
				hmax = h;
				fpsmax = aValidRatios[i].fps;
			}
		}
 
		return {wMax:wmax, hMax:hmax, fpsMax:fpsmax};
	}
 
	/**
	* retourne un tableau d'objets stockant les ratios valides et les dimensions max de capture correspondantes
	*@param oCam	l'objet caméra à  tester
	*@param fps	le fps souhaité (la dimension max peut varier selon fps)
	*@return array	un tableau contenant les objets des ratios disponibles
	*/
	public static function getCompatibleRatios(oCam:Camera, fps:Number):Array{
		var aValidRatios = new Array();	// tableau de stockage des ratios valides
 
		// liste des formats de ratios à  vérifier
		// rajouter des formats de ratios s'il en manque dans ce tableau
		var aFormats = [
			"4:3",			// format le plus répandu (format natif du cinéma muet)
			"16:9",			// format télévisé
			"11:9" ,		// format spécial webcam
			"1.85:1",	 	// format panoramique le plus utilisé
			"21:9"			// cinémascope  
		];
 
		// boucle de test de formats de ratios
		for (var i=0; i<aFormats.length; i++){
			var test:Object = isCompatibleRatio(oCam, aFormats[i], fps);
			if (test!=undefined){
				// si l'objet test est non-vide, le ratio est vérifié
				aValidRatios.push({ratio:aFormats[i], w:test.w, h:test.h, fps:test.fps});
			}
		}
		return aValidRatios;
	}
 
	/**
	* retourne un objet non vide si le ratio est vérifié (et contenant les dimensions max de capture correspondantes)
	* attention le fps obtenu pour le ratio peut avoir changé dans l'objet de retour par rapport à celui demandé
	* @param oCam		l'objet caméra à tester
	* @param ratio		le ratio à tester au format String ("4:3", "16:9".....)
	* @param fps		le fps souhaité (la dimension max peut varier selon fps)
	* @return Object	un objet non-vide si le ratio est validé et contenant les dimensions de capture max
	*/
	public static function isCompatibleRatio(oCam:Camera, ratio:String, fps:Number):Object{
		// crée l'objet de retour
		var result = new Object();
 
		// crée un format extrême au ratio demandé
		var temp = ratio.split(":");
		var wtest = Number(temp[0])*2000;
		var htest = Number(temp[1])*2000;		
 
		// sauvegarde les infos actuelles de la webcam
		var save_wCam = oCam.width;
		var save_hCam = oCam.height;
		var save_fpsCam = oCam.fps;
 
		// test la taille de capture maximale
		if (fps==undefined){
			// on ne force pas le fps
			oCam.setMode(wtest, htest, oCam.fps, false);
		} else {
			// on force le fps pour le test
			oCam.setMode(wtest, htest, fps, false);
		}
 
		// check le ratio obtenu
		var ratio = oCam.width/oCam.height;
 
		if (ratio==(wtest/htest)){
			// le ratio est supporté -> on enregistre la taille max dans ce ratio
			result =  {w:oCam.width, h:oCam.height, fps:oCam.fps};
		} else result = null;
 
		// on remet la webcam dans ses dimensions initiales
		oCam.setMode(save_wCam, save_hCam, save_fpsCam, false);
 
		return result;
	}	
}

Utilisation

Importer la classe et crée une première instance vidéo :

import net.lecrabe.medias.advCamera;
 
// prends le premier device disponible
// (à vous de gérer la selection du bon device)
var myCamera:Camera = advCamera.get();
 
// attach le flux vidéo sur l'objet vidéo cam_vid posé sur la scène
cam_vid.attachVideo(myCamera);

Vérifier qu'un format vidéo est disponible - advCamera.isCompatibleRatio

Pour vérifier si le device est compatible avec un ratio particulier, il suffit d'appeler la fonction “advCamera.isCompatibleRatio”:

var oReponse:Object = advCamera.isCompatibleRatio(myCamera, "4:3");

ou

var oReponse:Object = advCamera.isCompatibleRatio(myCamera, "4:3", 30);
  • soit vous ne précisez pas de fps, alors la fonction prends le fps actuel du device et vous retourne les dimensions max de capture pour ce fps
  • soit vous “forcez” le fps et la fonction vous retourne les dimensions maximales pour ce fps

La fonction vous renvoie un objet :

  • vide si le device n'est pas compatible avec le ratio demandé
  • non-vide si le device est bien compatible avec ce ratio et contient alors
    • la propriété “w” qui est la largeur maximale dans ce ratio
    • la propriété “h” qui est la hauteur maximale dans ce ratio
    • la propriété “fps” qui est le fps maximal compatible avec ces dimensions

En effet il arrive que ce fps soit plus faible que celui passé dans la fonction, mais il correspond bien au fps maximum ET compatible avec les dimensions retournées.


Exemple en forçant le FPS:

// on initialise la webcam sur une dimension connue
myCamera.setMode(160, 120, 15, true);
 
var oReponse:Object = advCamera.isCompatibleRatio(myCamera, "4:3", 30);
 
if (oReponse==undefined) {
	trace("ratio non compatible !");
} else {
	trace("ratio compatible avec dimensions max "+oReponse.w+"x"+oReponse.h+" à "+oReponse.fps+"fps");
	// on utilise ce mode maximal
	myCamera.setMode(oReponse.w, oReponse.h, oReponse.fps);
}

on obtient avec une “Logitech QuickCam Pro 4000” :

ratio compatible avec dimensions max 352x264 à 30fps

Exemple en ne forçant pas le FPS:

// on initialise la webcam sur une dimension connue
myCamera.setMode(160, 120, 15, true);
 
var oReponse:Object = advCamera.isCompatibleRatio(myCamera, "4:3");
 
if (oReponse==undefined) {
	trace("ratio non compatible !");
} else {
	trace("ratio compatible avec dimensions max "+oReponse.w+"x"+oReponse.h+" à "+oReponse.fps+"fps");
	// on utilise ce mode maximal
	myCamera.setMode(oReponse.w, oReponse.h, oReponse.fps);
}

on obtient avec une “Logitech QuickCam Pro 4000” :

ratio compatible avec dimensions max 640x480 à 15fps

Dans cet exemple on voit bien que la webcam offre une solution 640×480 à 15fps, mais ne supporte pas cette taille à 30fps et propose alors une dimension plus petite 352×268 30fps.

NOTE : Si vous donnez un FPS trop grand (60fps par exemple), la fonction vous retourne alors la dimension maximale de capture avec le FPS maximale supporté par la webcam (dans l'exemple précédent, on obtiendrait la résolution 320×240 30fps).

Obtenir tous les formats disponibles pour la caméra - advCamera.getCompatibleRatios

Pour obtenir les ratios possibles avec le device en cours, utiliser la fonction “advCamera.getCompatibleRatios”.

A priori un device n'utilise qu'un ratio (c'est le cas pour les webcam) mais certains device semblent en proposer plusieurs.

La fonction renvoie un tableau d'objets des ratios compatibles avec le device, chaque objet contient les propriétés suivantes :

  • “ratio”: le ratio compatible avec le device
  • “w” : la largeur max de ce ratio
  • “h” : la hauteur max de ce ratio

Cette fonction utilise un tableau qui vérifie tous les ratios connus des formats vidéos. Libre à vous d'en rajouter directement dans la classe, mais respectez la syntaxe “4:3”, “16:9”…etc

Voici l'appel à faire pour obtenir ce tableau d'objets:

var aReponse:Array = advCamera.getCompatibleRatios(myCamera);

ou

var aReponse:Array = advCamera.getCompatibleRatios(myCamera, 30);

Encore une fois il est possible de forcer le FPS pour obtenir les dimensions à un FPS précis (voir la fonction “isCompatibleRatio” pour plus de détails)

Exemple pour récupérer la liste des ratios compatible au FPS courant:

var aReponse:Array = advCamera.getCompatibleRatios(myCamera);
if (aReponse.length>0){
	for (var i=0; i<aReponse.length; i++){
		trace("ratio compatible : type="+aReponse[i].ratio+" avec dimensions max "+aReponse[i].w+"x"+aReponse[i].h+" à "+aReponse[i].fps+"fps")
	}
} else {
	trace("pas de ratio compatible");
}

Obtenir la taille de capture maximale du device - advCamera.getMaxCaptureSize

Pour obtenir la taille max de capture du device en cours, utiliser la fonction “advCamera.getMaxCaptureSize”.

Cette fonction appelle la fonction précédente et en extrait la plus grande taille de capture parmi les ratios compatibles.

La fonction renvoie un tableau d'objets des ratios compatibles avec le device, chaque objet contient les propriétés suivantes :

  • “ratio”: le ratio compatible avec le device
  • “w” : la largeur max de ce ratio
  • “h” : la hauteur max de ce ratio
var oReponse:Array = advCamera.getMaxCaptureSize(myCamera);

ou

var oReponse:Array = advCamera.getMaxCaptureSize(myCamera, 30);

Encore une fois, si on précise le FPS on obtient la dimension maximale de capture à ce fps précis, sinon la fonction renvoie la dimension maximale en utilisant le fps en cours du device.

// on initialise la webcam dans une dimension fixe
myCamera.setMode(160, 120, 15);
 
// je cherche la dimension de capture max à 30fps
var oReponse:Object = advCamera.getMaxCaptureSize(myCamera, 30);
 
if (oReponse==undefined) {
	trace("pas de ratio compatible !");
} else {
	trace("plus grand ratio compatible : type="+oReponse.ratioMax+" avec dimensions max "+oReponse.wMax+"x"+oReponse.hMax+" à "+oReponse.fpsMax+"fps");
	// on utilise ce mode maximal pour passer en 30fps
	myCamera.setMode(oReponse.wMax, oReponse.hMax, oReponse.fpsMax);
}

Téléchargement

La classe : Cliquer ici

Un exemple (fla) : Cliquer ici


Arthy - Le Crabe - http://www.lecrabe.net