Le Château de Fougeret

J'aime pas la discussion autour du topic, mais j'aime bien l'étalonnage de la vidéo qui est vraiment chouette je trouve

 

Un exemple tout con Imag'in Visuals, il faut souvent pas grand chose, pas la peine de se prendre la tête avec des gros logiciels je pense, de toute façon j'utilise que du gratuit, du linux, et du light, donc...

 

Je trouve simpliste de parler d'éloge de la paresse. Tout simplement une création géniale n'a pas forcément besoin d'énormément de travail, et une création qui a demandé beaucoup de travail ne sera pas forcément bien.

Je pense par exemple à ce photographe (Michael Wesely) qui a fait des durées expositions d'un an voir deux pour ses photos. Donc un an à se tourner les pouces, certes, mais derrière il y a une idée géniale et aussi l'élaboration d'un moyen pour arriver à ses fins.

On peut aller très loin dans le délire de Sylvanounet, mais c'est une voie à approfondir.

 

1 an?
Je vais aller voir ça de suite

Pour ma part et à mon modeste niveau de débutant, effectivement c'est loin d'être de la paresse, mais j'imagine bien que de l’extérieur ça doit pas être évident à comprendre, surtout pour ceux qui changent d'objectifs, de focale, ou de sujet net/flou pleins de fois durant un tournage, etc...

Rien que pour le nombre de pixel dans l'image ou son rapport largeur/hauteur, a un moment donné je me suis posé la question tout con, sur quoi ça part l'idée du full hd par exemple, le 1920x1080? Ou bien encore le 2.35:1 au cinéma, etc...? On en vient rapidement à la conclusion que pour le full hd 1920x1080, la seule chose qui justifie cela c'est juste que c'est une extrapolation via un calcul tout simple par rapport au 4/3... Mais ça n'a absolument aucune autre réalité informatique ni même par rapport à nos yeux.

Donc pour déterminer le rapport l/h optimal d'une image, je me suis dit, prenons une moyenne généralement admise par la science concernant le champ de vision d'un œil, sachant qu'il est en amande, sachant qu'il y en a deux, sachant qu'il y a des cônes et des bâtonnets les uns sensibles plutôt à la longueur d'onde, les autre plutôt sensible à l'amplitude (le niveau d'énergie), que donc le cerveau reconstitue une image mentale complète grâce à la mémoire et avec un micro balayage oculaire à chaque instant, etc...

J'en suis venu à la conclusion de rogner une image en forme de deux ellipses superposés avec un rapport assez précis entre la hauteur et la largeur, mais que de toute façon si ce truc la n'était pas projeté sur une surface assez grande pour couvrir le champ de vision, et bien ça n'avait absolument aucun sens.

Bref, si on ne peut pas trouver un sens physiologique à la dimension d'une image, en plus au vue de la diversité du vivant, alors trouvons un sens informatique. Le seul sens réel que j'ai trouvé, étant programmeur, c'est le multiple de.
C'est pourquoi le plus logique pour moi, et ce sont les standards à la maison, c'est le 1024x512, 2048x1024, 4096x2048, pour le coup, si on se tiens à la propagande, ça fait 1k, 2k, 4k, en revanche quand on calcule ça ferait plus du 0.5k, 2k, et 8k...

 

Je pense que la créativité c'est d'abord du travail ; des idées aussi, certes, mais surtout du travail ; en audiovisuel comme dans tout autre domaine.

 

Ca se teste quand même sur du format très court avec des plans lents en demandant au spectateur de mettre le nez sur son écran.

Après tu peux tout simplement prendre le nombre d'or, qui a une vérité harmonique unanimement reconnue.

 

"La paresse serait-elle créatrice ? "

La réponse est indéniablement oui. (et c'est beaucoup de boulot)

C'est en ayant eu marre de pelleter qu'il a inventé la pelleteuse mécanique.
C'est en ayant eu marre d’agiter son éventail qu'il a inventé le ventilateur
C'est en ayant eu marre de pédaler qu'il a inventé le Solex
etc.

 

En tout cas je peux vous assurer que pour ma part ça a été très loin d'être un voyage immobile, quand on met plusieurs mois à faire tourner une carte son scarlett 18i8 et un nord lead 4 sur linux, que y avait plusieurs forums de plusieurs sites à aider la chose, qu'on essaye une dizaine de linux sur clé usb, différents noyaux, différents réglages, qu'on réinstalle du windows pour modifier le firmware de la carte parce le logiciel qui permet de communiquer le truc ne se laisse pas démarrer en émulation sur système différent de windows, qu'on ramène plusieurs fois des cartes son chez les boutiques, etc... et qu'au final au bout de plusieurs mois on trouve la solution tout seul.

Même chose pour l'encodage/décodage en ligne de commande, si on va au bout de la logique, tenir compte qu'en mov h264 aac (le meilleur format pour la fonction netstream de flash player en as3 NetStream - Guide de référence de l?API Adobe ActionScript® 3 (AS3 )), il faut bouger les meta-données au début du fichier... Bref des mois de test pour faire le tour de tout.

Et ne parlons même pas de réaliser le lecteur de vidéo soit même, voici la class:

Code:

// Package
package other.file
{
	// Flash
	import flash.media.Video;
	import flash.net.NetConnection;
	import flash.net.NetStream;
	import flash.media.SoundTransform;
	import flash.events.IOErrorEvent;
	import flash.events.AsyncErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.events.NetStatusEvent;
	
	// Class
	public final class Mov
	{
		// Define
		private var _duration:Number = new Number (0);
		private var _durationHms:String = new String ("");
		private var _ready:Boolean = new Boolean (false);
		private const _NET_CONNECTION:NetConnection = new NetConnection();
		private var _netStream:NetStream;
		private var _video:Video = new Video (0, 0);
		private var _scale:Number = new Number (1);
		private var _scaleX:Number = new Number (1);
		private var _scaleY:Number = new Number (1);
		private const _VOLUME_PANORAMIC:SoundTransform = new SoundTransform (1, 0);
		private var _pause:Boolean = new Boolean (false);
		private var _oneVideoPlayed:Boolean = new Boolean (false);
		private var _timeHms:String = new String ("");
		private var _timeDurationHms:String = new String ("");
		private var _filter:Array = new Array (null);
		private var _lengthFilter:uint = new uint (0);
		
		// Constructor
		public function Mov (width:Number, height:Number, framePerSecond:uint, buffer:Number, smooth:Boolean):void
		{
			const DELAY:Number = new Number (1 / framePerSecond);
			const CLIENT:Object = new Object();
			
			function onMetaData (object:Object):void
			{
				_duration = object.duration - DELAY;
				
				if (Math.floor (object.duration - DELAY) < 60)
				{
					_durationHms = ((Math.floor (object.duration - DELAY) % 3600) % 60) + "s";
				}
				else if (Math.floor (object.duration - DELAY) < 3600)
				{
					_durationHms = (((Math.floor (object.duration - DELAY) % 3600) - ((Math.floor (object.duration - DELAY) % 3600) % 60)) / 60) + "m " + ((Math.floor (object.duration - DELAY) % 3600) % 60) + "s";
				}
				else
				{
					_durationHms = ((Math.floor (object.duration - DELAY) - (Math.floor (object.duration - DELAY) % 3600)) / 3600) + "h " + (((Math.floor (object.duration - DELAY) % 3600) - ((Math.floor (object.duration - DELAY) % 3600) % 60)) / 60) + "m " + ((Math.floor (object.duration - DELAY) % 3600) % 60) + "s";
				}
				
				if (_ready == false)
				{
					_ready = true;
				}
			}
			
			CLIENT.onMetaData = onMetaData;
			
			function iOError (iOErrorEvent:IOErrorEvent):void
			{
				trace (iOErrorEvent);
			}
			
			function asyncError (asyncErrorEvent:AsyncErrorEvent):void
			{
				trace (asyncErrorEvent);
			}
			
			function securityError (securityErrorEvent:SecurityErrorEvent):void
			{
				trace (securityErrorEvent);
			}
			
			_NET_CONNECTION.addEventListener (IOErrorEvent.IO_ERROR, iOError, false, 0, false);
			_NET_CONNECTION.addEventListener (AsyncErrorEvent.ASYNC_ERROR, asyncError, false, 0, false);
			_NET_CONNECTION.addEventListener (SecurityErrorEvent.SECURITY_ERROR, securityError, false, 0, false);
			_NET_CONNECTION.connect (null, null);
			
			_netStream = new NetStream (_NET_CONNECTION, NetStream.CONNECT_TO_FMS);
			
			_netStream.bufferTime = buffer;
			_netStream.client = CLIENT;
			
			function netStatus (netStatusEvent:NetStatusEvent):void
			{
				trace (netStatusEvent);
			}
			
			_netStream.addEventListener (IOErrorEvent.IO_ERROR, iOError, false, 0, false);
			_netStream.addEventListener (AsyncErrorEvent.ASYNC_ERROR, asyncError, false, 0, false);
			_netStream.addEventListener (NetStatusEvent.NET_STATUS, netStatus, false, 0, false);
			
			_video = new Video (width, height);
			
			_video.smoothing = smooth;
			_video.attachNetStream (_netStream);
		}
		
		// Method
		public function get duration():Number
		{
			return _duration;
		}
		
		// Method
		public function get durationHms():String
		{
			return _durationHms;
		}
		
		// Method
		public function get ready():Boolean
		{
			return _ready;
		}
		
		// Method
		public function transform (x:Number, y:Number, r:Number, scale:Number, scaleX:Number, scaleY:Number, alpha:Number, visible:Boolean, parent:Object):void
		{
			_video.x = x;
			_video.y = y;
			_video.rotation = r;
			_scale = scale;
			_scaleX = scaleX;
			_scaleY = scaleY;
			_video.scaleX = scale * scaleX;
			_video.scaleY = scale * scaleY;
			_video.alpha = alpha;
			_video.visible = visible;
			
			parent.addChild (_video);
		}
		
		// Method
		public function get x():Number
		{
			return _video.x;
		}
		
		// Method
		public function set x (x:Number):void
		{
			_video.x = x;
		}
		
		// Method
		public function get y():Number
		{
			return _video.y;
		}
		
		// Method
		public function set y (y:Number):void
		{
			_video.y = y;
		}
		
		// Method
		public function get r():Number
		{
			return _video.rotation;
		}
		
		// Method
		public function set r (r:Number):void
		{
			_video.rotation = r;
		}
		
		// Method
		public function get scale():Number
		{
			return _scale;
		}
		
		// Method
		public function set scale (scale:Number):void
		{
			_scale = scale;
			_video.scaleX = scale * _scaleX;
			_video.scaleY = scale * _scaleY;
		}
		
		// Method
		public function get scaleX():Number
		{
			return _scaleX;
		}
		
		// Method
		public function set scaleX (scaleX:Number):void
		{
			_scaleX = scaleX;
			_video.scaleX = _scale * scaleX;
		}
		
		// Method
		public function get scaleY():Number
		{
			return _scaleY;
		}
		
		// Method
		public function set scaleY (scaleY:Number):void
		{
			_scaleY = scaleY;
			_video.scaleY = _scale * scaleY;
		}
		
		// Method
		public function get alpha():Number
		{
			return _video.alpha;
		}
		
		// Method
		public function set alpha (alpha:Number):void
		{
			_video.alpha = alpha;
		}
		
		// Method
		public function get visible():Boolean
		{
			return _video.visible;
		}
		
		// Method
		public function set visible (visible:Boolean):void
		{
			_video.visible = visible;
		}
		
		// Method
		public function addParent (parent:Object):void
		{
			parent.addChild (_video);
		}
		
		// Method
		public function removeParent():void
		{
			_video.parent.removeChild (_video);
		}
		
		// Method
		public function volumePanoramic (volume:Number, panoramic:Number):void
		{
			if (volume != _VOLUME_PANORAMIC.volume)
			{
				_VOLUME_PANORAMIC.volume = volume;
			}
			
			if (panoramic != _VOLUME_PANORAMIC.pan)
			{
				_VOLUME_PANORAMIC.pan = panoramic;
			}
			
			_netStream.soundTransform = _VOLUME_PANORAMIC;
		}
		
		// Method
		public function load (path:String):void
		{
			const VISIBLE:Boolean = new Boolean (_video.visible);
			const VOLUME:Number = new Number (_VOLUME_PANORAMIC.volume);
			
			if (_video.visible == true)
			{
				_video.visible = false;
			}
			
			if (_ready == true)
			{
				_ready = false;
			}
			
			if (_pause == true)
			{
				_pause = false;
			}
			
			if (_oneVideoPlayed == false)
			{
				_oneVideoPlayed = true;
			}
			else
			{
				_duration = 0;
				_netStream.close();
				_video.clear();
			}
			
			if (_VOLUME_PANORAMIC.volume != 0)
			{
				_VOLUME_PANORAMIC.volume = 0;
			}
			
			_netStream.play (path);
			_netStream.pause();
			_netStream.seek (0);
			_video.clear();
			
			_pause = true;
			
			if (_video.visible != VISIBLE)
			{
				_video.visible = VISIBLE;
			}
			
			if (_VOLUME_PANORAMIC.volume != VOLUME)
			{
				_VOLUME_PANORAMIC.volume = VOLUME;
			}
		}
		
		// Method
		public function play (path:String):void
		{
			if (_ready == true)
			{
				_ready = false;
			}
			
			if (_pause == true)
			{
				_pause = false;
			}
			
			if (_oneVideoPlayed == false)
			{
				_oneVideoPlayed = true;
			}
			else
			{
				_duration = 0;
				_netStream.close();
				_video.clear();
			}
			
			_netStream.play (path);
		}
		
		// Method
		public function playCall (path:String, volume:Number, panoramic:Number, callFunction:Function):void
		{
			if (_ready == true)
			{
				_ready = false;
			}
			
			if (_pause == true)
			{
				_pause = false;
			}
			
			if (_oneVideoPlayed == false)
			{
				_oneVideoPlayed = true;
			}
			else
			{
				_duration = 0;
				_netStream.close();
				_video.clear();
			}
			
			if (volume != _VOLUME_PANORAMIC.volume)
			{
				_VOLUME_PANORAMIC.volume = volume;
			}
			
			if (panoramic != _VOLUME_PANORAMIC.pan)
			{
				_VOLUME_PANORAMIC.pan = panoramic;
			}
			
			_netStream.soundTransform = _VOLUME_PANORAMIC;
			
			function netStatusStop (netStatusEvent:NetStatusEvent):void
			{
				if (netStatusEvent.info.code == "NetStream.Play.Stop")
				{
					_netStream.close();
					_NET_CONNECTION.close();
					_video.clear();
					
					_ready = false;
					
					_netStream.removeEventListener (NetStatusEvent.NET_STATUS, netStatusStop, false);
					
					callFunction();
				}
			}
			
			_netStream.addEventListener (NetStatusEvent.NET_STATUS, netStatusStop, false, 0, false);
			_netStream.play (path);
		}
		
		// Method
		public function get pause():Boolean
		{
			return _pause;
		}
		
		// Method
		public function togglePause():void
		{
			if (_pause == false)
			{
				_netStream.pause();
				_pause = true;
			}
			else
			{
				_netStream.resume();
				_pause = false;
			}
		}
		
		// Method
		public function time (time:Number):void
		{
			_netStream.seek (time);
		}
		
		// Method
		public function get timeHms():String
		{
			if (Math.floor (_netStream.time) < 60)
			{
				_timeHms = ((Math.floor (_netStream.time) % 3600) % 60) + "s";
			}
			else if (Math.floor (_netStream.time) < 3600)
			{
				_timeHms = (((Math.floor (_netStream.time) % 3600) - ((Math.floor (_netStream.time) % 3600) % 60)) / 60) + "m " + ((Math.floor (_netStream.time) % 3600) % 60) + "s";
			}
			else
			{
				_timeHms = ((Math.floor (_netStream.time) - (Math.floor (_netStream.time) % 3600)) / 3600) + "h " + (((Math.floor (_netStream.time) % 3600) - ((Math.floor (_netStream.time) % 3600) % 60)) / 60) + "m " + ((Math.floor (_netStream.time) % 3600) % 60) + "s";
			}
			
			return _timeHms;
		}
		
		// Method
		public function get timeDurationHms():String
		{
			if (Math.floor (_netStream.time) < 60)
			{
				_timeDurationHms = ((Math.floor (_netStream.time) % 3600) % 60) + "s / " + _durationHms;
			}
			else if (Math.floor (_netStream.time) < 3600)
			{
				_timeDurationHms = (((Math.floor (_netStream.time) % 3600) - ((Math.floor (_netStream.time) % 3600) % 60)) / 60) + "m " + ((Math.floor (_netStream.time) % 3600) % 60) + "s / " + _durationHms;
			}
			else
			{
				_timeDurationHms = ((Math.floor (_netStream.time) - (Math.floor (_netStream.time) % 3600)) / 3600) + "h " + (((Math.floor (_netStream.time) % 3600) - ((Math.floor (_netStream.time) % 3600) % 60)) / 60) + "m " + ((Math.floor (_netStream.time) % 3600) % 60) + "s / " + _durationHms;
			}
			
			return _timeDurationHms;
		}
		
		// Method
		public function get playing():Number
		{
			if (_duration > 0)
			{
				return _netStream.time / _duration;
			}
			else
			{
				return 0;
			}
		}
		
		// Method
		public function get loading():Number
		{
			if (_netStream.bytesTotal > 0)
			{
				return _netStream.bytesLoaded / _netStream.bytesTotal;
			}
			else
			{
				return 0;
			}
		}
		
		// Method
		public function get ending():Boolean
		{
			if (_duration > 0 && _netStream.time >= _duration && _ready == true && _pause == false)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		
		// Method
		public function get xCenter():Number
		{
			return _video.width / 2;
		}
		
		// Method
		public function get yCenter():Number
		{
			return _video.height / 2;
		}
		
		// Method
		public function get width():Number
		{
			return _video.width;
		}
		
		// Method
		public function set width (width:Number):void
		{
			_video.width = width;
		}
		
		// Method
		public function get height():Number
		{
			return _video.height;
		}
		
		// Method
		public function set height (height:Number):void
		{
			_video.height = height;
		}
		
		// Method
		public function get mouseX():Number
		{
			return _video.mouseX;
		}
		
		// Method
		public function get mouseY():Number
		{
			return _video.mouseY;
		}
		
		// Method
		public function get mouseOver():Boolean
		{
			if (_video.mouseX >= 0 && _video.mouseX <= _video.width && _video.mouseY >= 0 && _video.mouseY <= _video.height)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		
		// Method
		public function addMask (mask:Object):void
		{
			_video.mask = mask.displayObject;
		}
		
		// Method
		public function removeMask():void
		{
			_video.mask = null;
		}
		
		// Method
		public function addFilter (filter:Object):void
		{
			_filter [_lengthFilter] = filter;
			_video.filters = _filter;
			
			_lengthFilter++;
		}
		
		// Method
		public function removeFilter():void
		{
			_filter = new Array (null);
			_video.filters = null;
			_lengthFilter = 0;
		}
	}
}

En fait vous ne vous rendez même pas compte que si on va au bout de ses idées, et qu'on veut tout réaliser soit même, et non pas pomper des choses à droite à gauche comme le font beaucoup de gens finalement, c'est un boulo monstre...

Donc non, aucune paraisse la dedans, oubliez cette idée.

Par contre j'ai regardé et j'adore les photos de Michael Wesely de 1 ou 2 ans d'exposition, celle en couleur est magnifique, quand on sait qu'il y a 1 ou 2 ans de mouvements la dedans, ça donne une dimension totalement extraordinaire, on voit même la trajectoire du soleil, etc... C'est un génie ce mec.