Guilherme Martins

This project was entirely created with MAX.

einstein-videoplayer

Einstein VideoPlayer

Andrew Benson

The second installment of Jitter Recipes is a collection of simple examples that began as weekly posts to the MaxMSP mailing list. Here you will find some clever solutions, advanced trans-coding techniques, groovy audio/visual toys, and basic building blocks for more complex processing. The majority of these recipes are specific implementations of a more general patching concept. As with any collection of recipes, you will want to take these basic techniques and personalize them for your own uses. I encourage you to take them all apart, add in your own touches and make these your own.

All the books in this series:  Book 1, Book 2, Book 3, Book 4 

Using jit.buffer~ to create simple audio solutions.

This example shows a couple of techniques that take advantage of the matrix interface of jit.buffer~.

On the left half we are recording a live signal into the upper buffer. This buffer is then output as a matrix, and fed through the jit.slide object to slowly fade between buffer states. This faded buffer-matrix is then loaded into the second jit.buffer~, which is what we will use for playback 

On the right half, we use a multislider and jit.fill to provide an easy drawing interface for waveshaping. Inside of the "use exprfill" subpatch, we've provided several common expressions that can be used to fill a jit.matrix with a windowing curve. This is particularly useful for doing granular synthesis.

Recording gestural parameter data over time

When recording high resolution videos from Jitter, it is often very difficult to get acceptable results from real-time manipulation of parameters. For this reason, it is often helpful to record real-time parameter changes on a frame-by-frame basis, and then play back these parameters at a rate that jitter can keep up with.

On the left half, we are using the pattrsorage object to save the state of all the named UI objects for each "frame". The benefit of this implementation is the ease and robustness of the pattr-family of objects as well as the ability to save the state of objects such as matrixctrl. 

The right half uses a matrix to store our parameter values, and then records frames into a jit.qt.record object.

Note that we're using jit.coerce to force our float32 matrix into an acceptable format for QuickTime (char).

Using Matrix feedback and distortion to create movement

This example is functionally very similar to the VideoSynth1 patch, except that we're using jit.repos instead of jit.rota to do the image distortion.

We are using jit.poke~ to perform automatic drawing on a named matrix (see VideoSynth1) 

This matrix is then distorted using jit.repos and then fed back to be drawn again using our named matrix.

To generate a constantly shifting repos-matrix, we've implemented a similar tactic as that used for the drawing (see bot2 subpatch). This matrix is then mixed with a matrix of normalized coordinates generated by the jit.expr object. This has the effect of gently repositioning the matrix at each frame, thus giving us smooth movement.

The output of jit.repos is then mirrored by sending it to jit.glue and inverting the x-dimension of the right input using jit.dimmap.

Using the stroke messages to jit.gl.sketch to render curves in OpenGL

Using a matrix to generate sketch commands for procedural drawing

With the introduction of JSUI, "stroke" commands were exposed for generating spline-curves. While this is pretty well-documented in the JavaScriptinMax PDF, many people aren't aware that you can also use these commands with jit.gl.sketch to do curvy line drawings.

The movement of the points is generated by adding a matrix of motion-vectors (see ParticleRave-a-delic) 

This matrix of point-locations is then sent to jit.iter to be broken down into 3-part lists.

For every matrix that is sent, we reset our sketch object and then begin our stroke using the "beginstroke line" message, and specifying the order (or smoothness of our curve) as well as color and width.

Each point of the matrix is then sent using the "strokepoint...."

Using expressions to generate values across a matrix

Reshaping a NURBS by setting control-point coordinates

Sometimes, when learning the ins and outs of OpenGL, it helps to be able to see just how this matrix of vertices is affecting our geometry. This example uses jit.cellblock to provide a visual interface to our matrix data. This allows us to perform precise distortions of our surface, which can be very useful for generating interesting graphics.

Using the "exprfill" message, we load our first two planes with signed-normalized values across the x and y dimension respectively. This gives us values between -1. and 1. By filling these matrices in such a way, we create a plane across the x and y coordinates of our GL-world. 

The z-plane is left empty for us to fill in as desired to create spatial distortion.

All of these matrices are then packed into one 3-plane matrix and sent on as the "ctlmatrix" for jit.gl.nurbs

We use jit.gl.slab to map a movie onto our jit.gl.nurbs shape. We could also load a shader program into this object to do processing on our texture.

Creating one's own particle system using matrix operations

Rendering multiple copies of the same geometry

Manipulating text using matrix operations

This patch was published for Xmas 2005, which should explain its holiday aesthetic. A particle matrix is generated which is then rendered as floating text-strings as well as vertices of a jit.gl.mesh. The text is also messed with a bit using some matrix processing.

The majority of these recipes are specific implementations of a more general patching concept. As with any collection of recipes, you will want to take these basic techniques and personalize them for your own uses.

jitter-recipes-book-2

Jitter Recipes: Book 2, Recipes 14-25

zeal

VIZZable is a suite of video performance plugins for Ableton Live. Version 2 is completely rewritten to to take advantage of the new new features of Max 6.1, specifically Gen. This means all the effects run on the GPU, are really fast and are infact much faster than the standard VIZZIE modules in Max.  There is a template included to build your own gen-based effects.

Note to syphon users. Due to a bug in Max, I’m not able to bake syphon into these devices. If you’d like to harness syphon, you can by downloading and installing the syphon plugins for Max from here: http://syphon.v002.info/ and using the unfrozen VIEWR and SYPHR devices in the syphonplugs folder included in the VIZZable zip.

Join our video in max for live users group here.


vizzable2

VIZZable2

This project was built in Max/MSP/Jitter and Max For Live

vizzable

VIZZable

Lilli Wessling Hart

Cycling '74

Controlling a Media Facade: The Bix Simulator and VJ software ES-X.

Interview created and produced by Sue Costabile for Cycling '74.


Installation and Performance
Controlling a Media Facade: The Bix Simulator and VJ software ES-X.
Interview created and produced by Sue Costabile for Cycling '74.

Cycling74 Perspectives: John deKron

Controlling a Media Facade: The Bix Simulator and VJ software ES-X.
Watch John's video.

a-video-interview-with-john-dekron-media-video-artist

A Video Interview with John deKron, Media & Video Artist

mirrorboy

All this app is entirely designed and patched with Max6.

anotag-akiba-vj-software

AnoTag - Akiba-kei VJ Software

Fabrizio Poce

V-Module is a Max for Live (M4L) environment and relies on the synergy of Max/MSP/Jitter and Ableton Live: Jitter as main "engine" and Live as user interface. 

v-module

V-Module

In third installment of Jitter Recipe Collection, there are more snacks for the Patching Enthusiast! This Jitter Recipe "AnaglyphRender" builds on the "RenderMaster" recipe posted recently to create a realtime 3-D anaglyph image.

Download the Book 3 Max 4.6 patches and the Max 5 patches

Performing transformations on a 3D matrix

Generating video-synthesis with audio signals

The mechanics of this patch are very similar to the RagingSwirl patch, applied to video processing instead of OpenGL geometry. In this example, we are actually distorting and manipulating a 3D matrix, but only viewing one slice of it. The jit.charmap is used to turn our 1-plane matrix into a full color image.

Using the "bot" subpatch, our matrix is continuously drawn into with the jit.poke~ object.

This is then rotated across 2 different dimensions using a combination of jit.dimmap and jit.rota (see RagingSwirl).

Next, we take one 2D slice of the larger matrix for display using the "srcdim" messages.

This is then converted to a 4-plane matrix and colorized using jit.charmap. By using an upsampled color map, we are able to constrain the palette, and decide between a smooth, cloudy look or a flat, hard-edged look.

Using the alpha channel to do complex blending effects

This demonstrates a way to generate an alpha-channel based on an analysis of the video. Here we use the amount of movement (difference) between consecutive frames, and then impose a threshold to decide what pixels will be visible. The effect resembles that of a degraded digital video signal, and can be used to generate all sorts of pixel debris.

The most important aspect of the processing is the generation of an alpha mask. To do this we first convert our video stream to grayscale using jit.rgb2luma.

The matrix is then downsampled using random "dim" messages, generated by the random object.

This is then compared to the previous frame using jit.op @op absdiff to get the absolute difference between the two. Note that we are taking advantage of the trigger object to perform this slight of hand.

Once we have generated our difference map, we then use jit.op @op > to create a threshold. This means that it will turn on any pixel that has changed more than the threshold. This will then serve as our alpha mask, but passing it into the first inlet of the jit.pack object.

Once our alpha channel has been packed in with our live feed, this is then blended with our current image using jit.alphablend. The resulting image is then fed back to be blended with the next frame using a named matrix.

I get a lot of questions about dealing with text in video patches. Whether you are using text as labels, titles, or subtitles, you will generally want it to be in the foreground. In order to do this successfully, while maintaining the transparency of the jit.gl.text2d's bounding box, you must impose a drawing order.

The key thing to this patch is maintaining the render order. To do this, we turn the @automatic off for all of our gl.objects, and then use the trigger object to bang them in sequence.

Using the jit.str.fromsymbol object, we route the text output from the textfield and convert it to a jitter matrix for rendering single-line text.

The jit.textfile object is very useful for dealing with formatted text. Simply double-click the object to bring up a text editing window.

By turning on @blend_enable for the jit.gl.text2d object, we make sure that only the text itself is displayed.

To generate the shadowed text, we actually render the text twice - once in black, and then offset in white.

Generating timing effects with frame messages

This example is a simple patch that demonstrates a way to generate looping effects with jit.qt.movie. This is very useful for those who are interested in working with looping videos, and creating realtime editing patches. With a little tweaking, this patch could serve as the basis for more complex playback procedures.

First, we need to set jit.qt.movie's autostart attribute to be off, to prevent it from playing back the movie file automatically.

The key to understanding this patch is the use of the accum (as a counter) along with the modulo (%) operator. This allows us to count loops.

One tricky bit is the use of the route object to obtain the framecount of each movie loaded into the jit.qt.movie object. This sets the modulo size of the entire movie, which makes sure that we always send frame numbers that are within the range of actual frames in the movie.

When the stutter toggle is turned on, a shorter loop of numbers is generated that is added to the current frame number.

These numbers are then sent to jit.qt.movie using the "frame" message.

Using an environment map to create reflective surfaces

Using geometrical expressions to create shapes

This patch takes an audio signal and generates a cascading, lumpy surface. Using some simple expressions, this surface is then distorted to create a pregnant lump. Environment mapping creates a liquid-like reflective surface.

We take the vector of audio grabbed by jit.catch~ and render it to a single row of a matrix. This matrix is then stretched down slightly and fedback. This generates the cascading effect.

In third installment of Jitter Recipe Collection, the Jitter Recipe “AnaglyphRender” builds on the “RenderMaster” recipe posted to create a realtime 3-D anaglyph image.

jitter-recipes-book-3

Jitter Recipes: Book 3, Recipes 26-43

auvi@auv-i.com

FREE collection of 85 Jitter objects for Max 5 (OS X). Auvi performs unique complex video effects in real-time, and is optimized for extremely fast performance.

project93-auvi

Auvi

StvDee

MaxMSP, Jitter, and Javascript have been used exclusively for the development of this project.

Search Results