Add files via upload

Python Version/ffglitch/jscripts/Buffer.js

@@ -0,0 +1,75 @@
+// dd_ring_buffer.js
+// works kinda like an audio delay
+// stacks the previous n frames into a buffer
+
+// global variable holding forward motion vectors from previous frames
+var prev_fwd_mvs = [ ];
+
+// change these values to use a smaller or greater number of frames to
+// perform the average of motion vectors
+
+// try making the delay long enough to overlap an edit in the content ...
+var delay = 10;
+// divisor controls "feedback" ... or "feedforward" which ever is a better description ...
+var feedback = 0.5;			// a number between 0.000001 and .... yeah - controls how much of the buffered mv gets into the next pass
+
+var divisor = 1.0/feedback;
+
+function glitch_frame(frame)
+{
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+    // update variable holding forward motion vectors from previous
+    // frames. note that we perform a deep copy of the clean motion
+    // vector values before modifying them.
+    let json_str = JSON.stringify(fwd_mvs);
+    let deep_copy = JSON.parse(json_str);
+    // push to the end of array
+    prev_fwd_mvs.push(deep_copy);
+    // drop values from earliest frames to always keep the same tail
+    // length
+    if ( prev_fwd_mvs.length > delay )
+        prev_fwd_mvs = prev_fwd_mvs.slice(1);
+
+    // bail out if we still don't have enough frames
+    if ( prev_fwd_mvs.length != delay )
+        return;
+
+    // replace all motion vectors of current frame with an average
+    // of the motion vectors from the previous 10 frames
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+        // loop through all rows
+        let row = fwd_mvs[i];
+        let delay_row = prev_fwd_mvs[0][i];
+        let insert_row = prev_fwd_mvs[delay-1][i];
+
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+			let dmv = delay_row[j];
+            let imv = insert_row[j];
+            // THIS IS WHERE THE MAGIC HAPPENS
+
+		// temp copy of the incoming vectors
+			let x = mv[0];
+			let y = mv[1];
+		// pull their replacements out of the buffer
+            mv[0] = dmv[0];
+            mv[1] = dmv[1];
+		// feedback the 'old' with the 'new' for next time
+            imv[0] = (dmv[0] / divisor) + x;
+            imv[1] = (dmv[1] / divisor) + y;
+		// rinse and repeat
+
+        }
+    }
+}

Python Version/ffglitch/jscripts/Delay.js

@@ -0,0 +1,71 @@
+// dd_delay.js
+// works kinda like an audio delay
+// stacks the previous n frames into a buffer
+
+// global variable holding forward motion vectors from previous frames
+var prev_fwd_mvs = [ ];
+
+// change these values to use a smaller or greater number of frames to
+// perform the average of motion vectors
+
+// try making the delay long enough to overlap an edit in the content ...
+var delay = 20;
+
+function glitch_frame(frame)
+{
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+    // update variable holding forward motion vectors from previous
+    // frames. note that we perform a deep copy of the clean motion
+    // vector values before modifying them.
+    let json_str = JSON.stringify(fwd_mvs);
+    let deep_copy = JSON.parse(json_str);
+    // push to the end of array
+    prev_fwd_mvs.push(deep_copy);
+    // drop values from earliest frames to always keep the same tail
+    // length
+    if ( prev_fwd_mvs.length > delay )
+        prev_fwd_mvs = prev_fwd_mvs.slice(1);
+
+    // bail out if we still don't have enough frames
+    if ( prev_fwd_mvs.length != delay )
+        return;
+
+    // replace all motion vectors of current frame with an average
+    // of the motion vectors from the previous 10 frames
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+        // loop through all rows
+        let row = fwd_mvs[i];
+        let delay_row = prev_fwd_mvs[0][i];
+        let insert_row = prev_fwd_mvs[delay-1][i];
+
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+			let dmv = delay_row[j];
+            let imv = insert_row[j];
+            // THIS IS WHERE THE MAGIC HAPPENS
+
+		// temp copy of the incoming vectors
+			let x = mv[0];
+			let y = mv[1];
+		// pull their replacements out of the buffer
+            mv[0] = dmv[0];
+            mv[1] = dmv[1];
+		// feedback the 'old' with the 'new' for next time
+            imv[0] = x;
+            imv[1] = y;
+		// rinse and repeat
+
+        }
+    }
+}

Python Version/ffglitch/jscripts/Invert-Reverse.js

@@ -0,0 +1,58 @@
+// dd_RandomDamage(invertRandomN).js
+// invert x and y component of mv for random number of frames if threshold met for frame
+
+let threshold = 95;
+var TRIGGERED = 0;
+var nFrames = 10;
+var frameCount = 0;
+var MAGNITUDE = 20;
+
+function glitch_frame(frame)
+{
+
+	var do_or_not = Math.random() * 100;
+	if(do_or_not > threshold){
+		if(TRIGGERED > 0){
+
+		}else{
+			TRIGGERED = 1;
+			frameCount = 0;
+			nFrames = Math.random() * MAGNITUDE;
+		}
+	}
+	// only do the glitch if our random number crosses the threshold
+	if(TRIGGERED > 0 & frameCount <= nFrames){
+		frameCount++;
+
+		// bail out if we have no motion vectors
+		let mvs = frame["mv"];
+		if ( !mvs )
+			return;
+		// bail out if we have no forward motion vectors
+		let fwd_mvs = mvs["forward"];
+		if ( !fwd_mvs )
+			return;
+
+		var M_H = fwd_mvs.length/2;
+		// clear horizontal element of all motion vectors
+		for ( let i = 0; i < fwd_mvs.length; i++ )
+		{
+			// loop through all rows
+			let row = fwd_mvs[i];
+			var M_W = row.length/2;
+
+			for ( let j = 0; j < row.length; j++ )
+			{
+				// loop through all macroblocks
+				let mv = row[j];
+
+				// THIS IS WHERE THE MAGIC HAPPENS
+				// STOP XY
+				mv[0] = 0 - mv[0];
+				mv[1] = 0 - mv[1];
+			}
+		}
+	}else{
+		TRIGGERED = 0;
+	}
+}

Python Version/ffglitch/jscripts/Mirror.js

@@ -0,0 +1,52 @@
+// dd_mirror_X.js
+
+// clean buffer :
+var buffer = [ ];
+
+var ZOOM = -20;
+
+function glitch_frame(frame)
+{
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+	// note that we perform a deep copy of the clean motion
+    // vector values before modifying them.
+    let json_str = JSON.stringify(fwd_mvs);
+    let deep_copy = JSON.parse(json_str);
+	// stick em in the buffer
+    buffer = deep_copy;
+
+	var M_H = fwd_mvs.length/2;
+    // VERTICALLY
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+
+        // loop through all rows
+
+        let row = fwd_mvs[i];
+        var row2 = buffer[i];
+        //var row2 = fwd_mvs[(fwd_mvs.length-1)-i];
+
+        var M_W = row.length/2;
+
+		// HORIZONTALLY
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+			var mv2 = row2[(row.length - 1) - j];
+            // THIS IS WHERE THE MAGIC HAPPENS
+            //if(i>M_W){
+				mv[0] = 0-mv2[0];
+            	mv[1] = mv2[1];
+			//}
+        }
+    }
+}

Python Version/ffglitch/jscripts/Noise.js

@@ -0,0 +1,67 @@
+// dd_MultiplySlowest_50.js
+// Multiply slowest moving mv's
+var LARGEST = 0;
+var SOME_PERCENTAGE = 0.5;
+var MULTIPLE = 10;
+
+// global variable holding forward motion vectors from previous frames
+var prev_fwd_mvs = [ ];
+
+// change this value to use a smaller or greater number of frmes to average
+var tail_length = 20;
+
+function glitch_frame(frame)
+{
+	LARGEST = 0;
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+   	// 1st loop - find the fastest mv
+   	// this ends-up in LARGEST as the square of the hypotenuse (mv[0]*mv[0]) + (mv[1]*mv[1])
+    let W = fwd_mvs.length;
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+        let row = fwd_mvs[i];
+        // rows
+        let H = row.length;
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+
+            // THIS IS WHERE THE MEASUREMENT HAPPENS
+            var this_mv = (mv[0] * mv[0])+(mv[1] * mv[1]);
+            if ( this_mv > LARGEST){
+				LARGEST = this_mv;
+			}
+        }
+    }
+
+    // then find those mv's which are bigger than SOME_PERCENTAGE of LARGEST
+    // and then replace them with the average mv from the last n frames
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+	    {
+	        let row = fwd_mvs[i];
+	        // rows
+	        let H = row.length;
+	        for ( let j = 0; j < row.length; j++ )
+	        {
+	            // loop through all macroblocks
+	            let mv = row[j];
+
+	            // THIS IS WHERE THE MAGIC HAPPENS
+	            var this_mv = (mv[0] * mv[0])+(mv[1] * mv[1]);
+	            if (this_mv < (LARGEST * SOME_PERCENTAGE)){
+
+			     	mv[0] = mv[0] * MULTIPLE;
+					mv[1] = mv[1] * MULTIPLE;
+				}
+	        }
+    }
+}

Python Version/ffglitch/jscripts/Shear.js

@@ -0,0 +1,37 @@
+// dd_sheer.js
+
+var ZOOM = -20;
+
+function glitch_frame(frame)
+{
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+	var M_H = fwd_mvs.length/2;
+    // clear horizontal element of all motion vectors
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+
+        // loop through all rows
+
+        let row = fwd_mvs[i];
+        var M_W = row.length/2;
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+
+            // THIS IS WHERE THE MAGIC HAPPENS
+            //if(i>M_W){
+				mv[0] = mv[0] + ((i - M_W) / 100)*ZOOM;
+            	mv[1] = mv[1] + ((j - M_H) / 100)*ZOOM;
+			//}
+        }
+    }
+}

Python Version/ffglitch/jscripts/Shift.js

@@ -0,0 +1,74 @@
+// dd_RandomDamage(antiGrav).js
+// anitgravityify if threshold met for frame
+
+let threshold = 98;
+// global variable holding forward motion vectors from previous frames
+var old_mvs = [ ];
+// a variable for gravity
+var rt = 0;
+var gravity = 0
+var orig_gravity = 5;
+var TRIGGERED = 0;
+var frameCount = 10;
+var count = 0;
+
+function glitch_frame(frame)
+{
+	var do_or_not = Math.random() * 100;
+	// only do the glitch if our random number crosses the threshold
+	if(do_or_not > threshold | TRIGGERED == 1){
+		if(TRIGGERED == 0){
+			gravity = orig_gravity;
+			TRIGGERED = 1;
+			rt = 0;
+		}
+		// bail out if we have no motion vectors
+		let mvs = frame["mv"];
+		if ( !mvs )
+			return;
+		// bail out if we have no forward motion vectors
+		let fwd_mvs = mvs["forward"];
+		if ( !fwd_mvs )
+			return;
+
+		// buffer first set of vectors. . .
+		if(rt == 0){
+			let json_str = JSON.stringify(fwd_mvs);
+			let deep_copy = JSON.parse(json_str);
+			// push to the end of array
+			old_mvs[0] = (deep_copy);
+			rt = 1;
+		}
+
+		// clear horizontal element of all motion vectors
+		for ( let i = 0; i < fwd_mvs.length; i++ )
+		{
+			// loop through all rows
+			let row = fwd_mvs[i];
+			let old_row = old_mvs[0][i];
+			for ( let j = 0; j < row.length; j++ )
+			{
+				// loop through all macroblocks
+				let mv = row[j];
+				let omv = old_row[j];
+				// THIS IS WHERE THE MAGIC HAPPENS
+
+				mv[0] = mv[0];
+				//if(mv[1] < 0){
+					var nmv = mv[1];
+					mv[1] = omv[1];
+					omv[1] = nmv + omv[1] + gravity;
+					//gravity++;
+				//}else{
+				//	mv[1] = mv[1];
+				//}
+
+			}
+		}
+		count++;
+		if(count >= frameCount){
+			TRIGGERED = 0;
+			count = 0;
+		}
+	}
+}

Python Version/ffglitch/jscripts/Sink.js

@@ -0,0 +1,38 @@
+// dd_zero.js
+// only fuck things up if mv > movement_threshold
+var movement_threshold = 3;
+function glitch_frame(frame)
+{
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+    // columns
+    let W = fwd_mvs.length;
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+
+        let row = fwd_mvs[i];
+
+        // rows
+        let H = row.length;
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+
+            // THIS IS WHERE THE MAGIC HAPPENS
+            if ( (mv[0] * mv[0])+(mv[1] * mv[1]) > movement_threshold*movement_threshold){
+	    		//mv[0] = Math.sin(i/W*Math.PI*2)*mv[0];
+  	    		//mv[1] = Math.cos(j/H*Math.PI*2)*mv[1];
+  	    		mv[0] = 0;//mv[0] * 10;
+  	    		mv[1] = 0;//mv[1] * 10;
+			}
+        }
+    }
+}

Python Version/ffglitch/jscripts/Slam Zoom.js

@@ -0,0 +1,37 @@
+// dd_slam_zoom_in.js
+
+var ZOOM = 20;
+
+function glitch_frame(frame)
+{
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+	var M_H = fwd_mvs.length/2;
+    // clear horizontal element of all motion vectors
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+
+        // loop through all rows
+
+        let row = fwd_mvs[i];
+        var M_W = row.length/2;
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+
+            // THIS IS WHERE THE MAGIC HAPPENS
+            //if(i>M_W){
+				mv[0] = ((M_W - j) / 100)*ZOOM;
+            	mv[1] = ((M_H - i) / 100)*ZOOM;
+			//}
+        }
+    }
+}

Python Version/ffglitch/jscripts/Slice.js

@@ -0,0 +1,68 @@
+// dd_RandomDamage(progZoom).js
+// progressive Zoom x and y components of mv if threshold met for frame
+
+let threshold = 95;
+
+var ZOOM = 0;
+var doZOOM = 0;
+var TRIGGERED = 0;
+var nFrames = 5;
+var frameCount = 0;
+
+function glitch_frame(frame)
+{
+
+	var do_or_not = Math.random() * 100;
+	if(do_or_not > threshold){
+		if(TRIGGERED > 0){
+
+		}else{
+			TRIGGERED = 1;
+			frameCount = 0;
+			ZOOM = 0;
+		}
+	}
+	// only do the glitch if our random number crosses the threshold
+	if(TRIGGERED > 0 & frameCount <= nFrames){
+		frameCount++;
+		ZOOM+= 10
+
+		var do_dir = Math.random() * 100;
+		if(do_dir > 50){
+			doZOOM = 0 - ZOOM;
+		}else{
+			doZOOM = ZOOM
+		}
+		// bail out if we have no motion vectors
+		let mvs = frame["mv"];
+		if ( !mvs )
+			return;
+		// bail out if we have no forward motion vectors
+		let fwd_mvs = mvs["forward"];
+		if ( !fwd_mvs )
+			return;
+
+		var M_H = fwd_mvs.length/2;
+		// clear horizontal element of all motion vectors
+		for ( let i = 0; i < fwd_mvs.length; i++ )
+		{
+			// loop through all rows
+			let row = fwd_mvs[i];
+			var M_W = row.length/2;
+
+			for ( let j = 0; j < row.length; j++ )
+			{
+				// loop through all macroblocks
+				let mv = row[j];
+
+				// THIS IS WHERE THE MAGIC HAPPENS
+				// ZOOM X & Y VECTORS
+				mv[0] = mv[0] + ((M_W - j) / 10)*doZOOM;
+            	mv[1] = mv[1] + ((M_H - i) / 10)*doZOOM;
+
+			}
+		}
+	}else{
+		TRIGGERED = 0;
+	}
+}

Python Version/ffglitch/jscripts/Stop.js

@@ -0,0 +1,56 @@
+// dd_RandomDamage(stopXY).js
+// stop x and y component of mv for n framesif threshold met for frame
+
+let threshold = 95;
+var TRIGGERED = 0;
+var nFrames = 10;
+var frameCount = 0;
+
+function glitch_frame(frame)
+{
+
+	var do_or_not = Math.random() * 100;
+	if(do_or_not > threshold){
+		if(TRIGGERED > 0){
+
+		}else{
+			TRIGGERED = 1;
+			frameCount = 0;
+		}
+	}
+	// only do the glitch if our random number crosses the threshold
+	if(TRIGGERED > 0 & frameCount <= nFrames){
+		frameCount++;
+
+		// bail out if we have no motion vectors
+		let mvs = frame["mv"];
+		if ( !mvs )
+			return;
+		// bail out if we have no forward motion vectors
+		let fwd_mvs = mvs["forward"];
+		if ( !fwd_mvs )
+			return;
+
+		var M_H = fwd_mvs.length/2;
+		// clear horizontal element of all motion vectors
+		for ( let i = 0; i < fwd_mvs.length; i++ )
+		{
+			// loop through all rows
+			let row = fwd_mvs[i];
+			var M_W = row.length/2;
+
+			for ( let j = 0; j < row.length; j++ )
+			{
+				// loop through all macroblocks
+				let mv = row[j];
+
+				// THIS IS WHERE THE MAGIC HAPPENS
+				// STOP XY
+				mv[0] = 0;
+				mv[1] = 0;
+			}
+		}
+	}else{
+		TRIGGERED = 0;
+	}
+}

Python Version/ffglitch/jscripts/Vibrate.js

@@ -0,0 +1,29 @@
+var randomness = 10;
+var bias = (randomness/2);
+function glitch_frame(frame)
+{
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+    // clear horizontal element of all motion vectors
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+        // loop through all rows
+        let row = fwd_mvs[i];
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+
+            // THIS IS WHERE THE MAGIC HAPPENS
+				mv[0] = mv[0] + (Math.floor((Math.random() * randomness) -bias));
+            	mv[1] = mv[1] + (Math.floor((Math.random() * randomness) -bias));
+        }
+    }
+}

Python Version/ffglitch/jscripts/Zoom.js

@@ -0,0 +1,38 @@
+// dd_zoom_in.js
+
+var ZOOM = 20;
+
+function glitch_frame(frame)
+{
+    // bail out if we have no motion vectors
+    let mvs = frame["mv"];
+    if ( !mvs )
+        return;
+    // bail out if we have no forward motion vectors
+    let fwd_mvs = mvs["forward"];
+    if ( !fwd_mvs )
+        return;
+
+	var M_H = fwd_mvs.length/2;
+    // clear horizontal element of all motion vectors
+    for ( let i = 0; i < fwd_mvs.length; i++ )
+    {
+
+        // loop through all rows
+
+        let row = fwd_mvs[i];
+        var M_W = row.length/2;
+
+        for ( let j = 0; j < row.length; j++ )
+        {
+            // loop through all macroblocks
+            let mv = row[j];
+
+            // THIS IS WHERE THE MAGIC HAPPENS
+            //if(i>M_W){
+				mv[0] = mv[0] + ((M_W - j) / 100)*ZOOM;
+            	mv[1] = mv[1] + ((M_H - i) / 100)*ZOOM;
+			//}
+        }
+    }
+}