#+title: Capture Live Video Feeds from JMonkeyEngine

 #+author: Robert McIntyre

 #+email: rlm@mit.edu

 #+description: Capture video from a JMonkeyEngine3 Application with Xuggle, and use gstreamer to compress the video to upload to YouTube.

 #+keywords: JME3, video, Xuggle, JMonkeyEngine, youtube, capture video, Java

 #+SETUPFILE: ../../aurellem/org/setup.org

 #+INCLUDE: ../../aurellem/org/level-0.org

 

 

 * The Problem

 So you've made your cool new JMonkeyEngine3 game and you want to

 create a demo video to show off your hard work. Screen capturing is

 the most straightforward way to do this, but it can slow down your

 game and produce low-quality video as a result. A better way is to

 record a video feed directly from the game while it is

 running.

 

 In this post, I'll explain how you can alter your JMonkeyEngine3 game

 to output video while it is running. The main trick is to alter the

 pace of JMonkeyEngine3's in-game time: we allow the engine as much

 time as it needs to compute complicated in-game events and to encode

 video frames. As a result, the game appears to speed up and slow down

 as the computational demands shift, but the end result is perfectly

 smooth video output at a constant framerate.

 

 

 * Video recording requires a steady framerate

 ** The built-in =Timer= rushes to keep up.

 #* Game-time vs. User-time vs. Video-time

 

 Standard JME3 applications use a =Timer= object to manage time

 in the simulated world. Because most JME3 applications (e.g. games)

 are supposed to happen \ldquo{}live\rdquo{}, the built-in =Timer=

 requires simulated time to match real time. This means that the

 application must rush to finish all of its calculations on

 schedule: the more complicated the calculations, the more the

 application is obligated to rush. And if the workload becomes too

 much to handle on schedule, =Timer= forces the application to cut

 corners: it demands fast, approximate answers instead of careful,

 accurate ones.  Although this policy sometimes causes physically impossible

 glitches and choppy framerates, it ensures that the user will never be

 kept waiting while the computer stops to make a complicated

 calculation.

 

 Now, the built-in =Timer= values speed over accuracy because real-time

 applications require it. On the other hand, if your goal is to record a

 glitch-free video, you need a =Timer= that will take its time to

 ensure that all calculations are accurate, even if they take a long time. In the next section, we

 will create a new kind of =Timer=\mdash{}called =IsoTimer=\mdash{}which

 slows down to let the computer finish all its calculations. The result

 is a perfectly steady framerate and a flawless physical simulation.

 

 # are supposed to happen \ldquo live \rdquo, this =Timer= requires the

 # application to update in real-time. In order to keep up with the real world, JME applications cannot

 # afford to take too much time on expensive computations. Whenever the

 # workload becomes too much for the computer to handle on schedule,

 # =Timer= forces the computer to cut corners, giving fast, approximate

 # answers instead of careful, accurate ones. Although physical accuracy sometimes

 # suffers as a result, this policy ensures that the user will never be

 # kept waiting while the computer stops to make a complicated

 # calculation.

 

 #fast answers are more important than accurate ones. 

 

 # A standard JME3 application that extends =SimpleApplication= or

 # =Application= tries as hard as it can to keep in sync with

 # /user-time/.  If a ball is rolling at 1 game-mile per game-hour in the

 # game, and you wait for one user-hour as measured by the clock on your

 # wall, then the ball should have traveled exactly one game-mile. In

 # order to keep sync with the real world, the game throttles its physics

 # engine and graphics display.  If the computations involved in running

 # the game are too intense, then the game will first skip frames, then

 # sacrifice physics accuracy.  If there are particuraly demanding

 # computations, then you may only get 1 fps, and the ball may tunnel

 # through the floor or obstacles due to inaccurate physics simulation,

 # but after the end of one user-hour, that ball will have traveled one

 # game-mile.

 

 # When we're recording video, we don't care if the game-time syncs with

 # user-time, but instead whether the time in the recorded video

 # (video-time) syncs with user-time. To continue the analogy, if we

 # recorded the ball rolling at 1 game-mile per game-hour and watched the

 # video later, we would want to see 30 fps video of the ball rolling at

 # 1 video-mile per /user-hour/. It doesn't matter how much user-time it

 # took to simulate that hour of game-time to make the high-quality

 # recording.

 ** COMMENT Two examples to clarify the point:

 *** Recording from a Simple Simulation

 

 **** Without a Special Timer

 You have a simulation of a ball rolling on an infinite empty plane at

 one game-mile per game-hour, and a really good computer. Normally,

 JME3 will throttle the physics engine and graphics display to sync the

 game-time with user-time. If it takes one-thousandth of a second

 user-time to simulate one-sixtieth of a second game time and another

 one-thousandth of a second to draw to the screen, then JME3 will just

 sit around for the remainder of $\frac{1}{60} - \frac{2}{1000}$

 user-seconds, then calculate the next frame in $\frac{2}{1000}$

 user-seconds, then wait, and so on. For every second of user time that

 passes, one second of game-time passes, and the game will run at 60

 frames per user-second.

 

 

 **** With a Special Timer

 Then, you change the game's timer so that user-time will be synced to

 video-time. Assume that encoding a single frame takes 0 seconds

 user-time to complete.

 

 Now, JME3 takes advantage of all available resources. It still takes

 one-thousandth of a second to calculate a physics tick, and another

 one-thousandth to render to the screen. Then it takes 0 seconds to

 write the video frame to disk and encode the video. In only one second

 of user time, JME3 will complete 500 physics-tick/render/encode-video

 cycles, and $\frac{500}{60}=8\frac{1}{3}$ seconds of game-time will

 have passed.  Game-time appears to dilate $8\frac{1}{3}\times$ with

 respect to user-time, and in only 7.2 minutes user-time, one hour of

 video will have been recorded. The game itself will run at 500 fps.

 When someone watches the video, they will see 60 frames per

 user-second, and $\frac{1}{60}$ video-seconds will pass each frame. It

 will take exactly one hour user-time (and one hour video-time) for the

 ball in the video to travel one video-mile.

 

 *** Recording from a Complex Simulation 

 

 *** Without a Special Timer

 You have a simulation of a ball rolling on an infinite empty plane at

 one game-mile per game-hour accompanied by multiple explosions

 involving thousands of nodes, particle effects, and complicated shadow

 shaders to create realistic shadows. You also have a slow

 laptop. Normally, JME3 must sacrifice rendering and physics simulation

 to try to keep up.  If it takes $\frac{1}{120}$ of a user-second to

 calculate $\frac{1}{60}$ game-seconds, and an additional

 $\frac{1}{60}$ of a user-second to render to screen, then JME3 has

 it's work cut out for it.  In order to render to the screen, it will

 first step the game forward by up to four physics ticks before

 rendering to the screen. If it still isn't fast enough then it will

 decrease the accuracy of the physics engine until game-time and user

 time are synched or a certain threshold is reached, at which point the

 game visibly slows down. In this case, JME3 continuously repeat a

 cycle of two physics ticks, and one screen render. For every

 user-second that passes, one game-second will pass, but the game will

 run at 30 fps instead of 60 fps like before.

 

 *** With a Special Timer

 Then, you change the game's timer so that user-time will be synced to

 video-time. Once again, assume video encoding takes $\frac{1}{60}$ of

 a user-second.

 

 Now, JME3 will spend $\frac{1}{120}$ of a user-second to step the

 physics tick $\frac{1}{60}$ game-seconds, $\frac{1}{60}$ to draw to

 the screen, and an additional $\frac{1}{60}$ to encode the video and

 write the frame to disk. This is a total of $\frac{1}{24}$

 user-seconds for each $\frac{1}{60}$ game-seconds. It will take

 $(\frac{60}{24} = 2.5)$ user-hours to record one game-hour and game-time

 will appear to flow two-fifths as fast as user time while the game is

 running. However, just as in example one, when all is said and done we

 will have an hour long video at 60 fps.

 

 

 ** COMMENT proposed names for the new timer

 # METRONOME

 # IsoTimer

 # EvenTimer

 # PulseTimer

 # FixedTimer

 # RigidTimer

 # FixedTempo

 # RegularTimer

 # MetronomeTimer

 # ConstantTimer

 # SteadyTimer

 

 

 ** =IsoTimer= records time like a metronome

 

 The easiest way to achieve this special timing is to create a new

 timer that always reports the same framerate to JME3 every time it is

 called.

 

 

 =./src/com/aurellem/capture/IsoTimer.java=

 #+include ../../jmeCapture/src/com/aurellem/capture/IsoTimer.java src java

 

 If an Application uses this =IsoTimer= instead of the normal one, we

 can be sure that every call to =simpleUpdate=, for example, corresponds

 to exactly $(\frac{1}{fps})$ seconds of game-time.

 

 * =VideoRecorder= manages video feeds in JMonkeyEngine.

 

 

 ** =AbstractVideoRecorder= provides a general framework for managing videos.

 

 Now that the issue of time is solved, we just need a function that

 writes each frame to a video.  We can put this function somewhere

 where it will be called exactly once per frame.

 

 The basic functions that a =VideoRecorder= should support are

 recording, starting, stopping, and possibly a cleanup step

 where it finalizes the recording (e.g. by writing headers for a video

 file).

 

 An appropiate interface describing this behaviour could look like

 this:

 

 =./src/com/aurellem/capture/video/VideoRecorder.java=

 #+include ../../jmeCapture/src/com/aurellem/capture/video/VideoRecorder.java src java

 

 

 JME3 already provides exactly the class we need: the =SceneProcessor=

 class can be attached to any viewport and the methods defined therein

 will be called at the appropriate points in the rendering process.

 

 However, it is also important to properly close the video stream and

 write headers and such, and even though =SceneProcessor= has a

 =.cleanup()= method, it is only called when the =SceneProcessor= is

 removed from the =RenderManager=, not when the game is shutting down

 when the user pressed ESC, for example. To obtain reliable shutdown

 behaviour, we also have to implement =AppState=, which provides a

 =.cleanup()= method that /is/ called on shutdown.

 

 Here is an AbstractVideoRecorder class that takes care of the details

 of setup and teardown.

 

 =./src/com/aurellem/capture/video/AbstractVideoRecorder.java=

 #+include ../../jmeCapture/src/com/aurellem/capture/video/AbstractVideoRecorder.java src java

 

 

 ** There are many options for handling video files in Java

 

 If you want to generate video from Java, a great option is [[http://www.xuggle.com/][Xuggle]]. It

 takes care of everything related to video encoding and decoding and

 runs on Windows, Linux and Mac.  Out of all the video frameworks for

 Java, I personally like this one the best.

 

 Here is a =VideoRecorder= that uses [[http://www.xuggle.com/][Xuggle]] to write each frame to a

 video file.

 

 =./src/com/aurellem/capture/video/XuggleVideoRecorder.java=

 #+include ../../jmeCapture/src/com/aurellem/capture/video/XuggleVideoRecorder.java src java

 

 With this, we are able to record video!

 

 However, it can be hard to properly install Xuggle. If you would rather not use Xuggle, here is an alternate class that uses

 [[http://www.randelshofer.ch/blog/2008/08/writing-avi-videos-in-pure-java/][Werner Randelshofer's]] excellent pure Java AVI file writer.

 

 =./src/com/aurellem/capture/video/AVIVideoRecorder.java=

 #+include ../../jmeCapture/src/com/aurellem/capture/video/AVIVideoRecorder.java src java

 

 This =AVIVideoRecorder= is more limited than the

 =XuggleVideoRecorder=, but requires less external dependencies.

 

 Finally, for those of you who prefer to create the final video from a

 sequence of images, there is the =FileVideoRecorder=, which records

 each frame to a folder as a sequentially numbered image file. Note

 that you have to remember the FPS at which you recorded the video, as

 this information is lost when saving each frame to a file.

 

 =./src/com/aurellem/capture/video/FileVideoRecorder.java=

 #+include ../../jmeCapture/src/com/aurellem/capture/video/FileVideoRecorder.java src java

 

 

 

 

 * How to record videos yourself

 

 ** Include this code.

 

   No matter how complicated your application is, it's easy to add

   support for video output with just a few lines of code.

 #  You can also record from multiple ViewPorts as the above example shows.

 

 And although you can use =VideoRecorder= to record advanced split-screen videos with multiple views, in the simplest case, you want to capture a single view\mdash{}

 exactly what's on screen. In this case, the following simple =captureVideo=

 method will do the job:

 

 #+begin_src java

 public static void captureVideo(final Application app, 

 				final File file) throws IOException{

     final AbstractVideoRecorder videoRecorder;

     if (file.getCanonicalPath().endsWith(".avi")){

 	videoRecorder = new AVIVideoRecorder(file);}

     else if (file.isDirectory()){

 	videoRecorder = new FileVideoRecorder(file);}

     else { videoRecorder = new XuggleVideoRecorder(file);}

     

     Callable<Object> thunk = new Callable<Object>(){

 	public Object call(){

 	    ViewPort viewPort = 

 	    app.getRenderManager()

 	    .createPostView("aurellem record", app.getCamera());

 	    viewPort.setClearFlags(false, false, false);

 	    // get GUI node stuff

 	    for (Spatial s : app.getGuiViewPort().getScenes()){

 		viewPort.attachScene(s);

 	    }

 	    app.getStateManager().attach(videoRecorder);

 	    viewPort.addProcessor(videoRecorder);

 	    return null;

 	}

     };

     app.enqueue(thunk);

 }

 #+end_src

 

 This method selects the appropriate =VideoRecorder= class

 for the file type you specify, and instructs your

 application to record video to the file.

 

 

 

 

 Now that you have a =captureVideo= method, you use it like this:

 

   - Establish an =Isotimer= and set its framerate :: For example, if

        you want to record video with a framerate of 30 fps, include

        the following line of code somewhere in the initializtion of

        your application: 

 #+begin_src java :exports code

 this.setTimer(new IsoTimer(30));

 #+end_src

 

   - Choose the output file :: If you want to record from the game's

        main =ViewPort= to a file called =/home/r/record.flv=, then

        include the following line of code somewhere before you call =app.start()=;

 

   #+begin_src java :exports code

 Capture.captureVideo(app, new File("/home/r/record.flv"));

   #+end_src

 

   

 ** Simple example

 

 

 This example will record video from the ocean scene from the

 JMonkeyEngine test suite.

 #+begin_src java

 File video = File.createTempFile("JME-water-video", ".avi");

 captureVideo(app, video);

 app.start();

 System.out.println(video.getCanonicalPath());

 #+end_src

 

 

 I've added support for this under a class called

 =com.aurellem.capture.Capture=. You can get it [[http://hg.bortreb.com/jmeCapture/][here]].

 

 

 ** Hello Video! example

 

 I've taken [[http://code.google.com/p/jmonkeyengine/source/browse/trunk/engine/src/test/jme3test/helloworld/HelloLoop.java][=./jme3/src/test/jme3test/helloworld/HelloLoop.java=]] and

 augmented it with video output as follows:

 

 =./src/com/aurellem/capture/examples/HelloVideo.java=

 #+include ../../src/com/aurellem/capture/examples/HelloVideo.java src java

 

 The videos are created in the =hello-video= directory

 

 #+begin_src sh :results verbatim :exports both

 du -h hello-video/*

 #+end_src

 

 #+results:

 : 932K	hello-video/hello-video-moving.flv

 : 640K	hello-video/hello-video-static.flv

 

 And can be immediately uploaded to youtube

 

 - [[http://www.youtube.com/watch?v=C8gxVAySaPg][hello-video-moving.flv]]

 #+BEGIN_HTML

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/C8gxVAySaPg" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+END_HTML

 - [[http://www.youtube.com/watch?v=pHcFOtIS07Q][hello-video-static.flv]]

 #+BEGIN_HTML

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/pHcFOtIS07Q" 

 	frameborder="0" allowfullscreen>

 </iframe>

 

 #+END_HTML

 

   

 * COMMENT More Examples

 ** COMMENT Hello Physics

 =HelloVideo= is boring. Let's add some video capturing to =HelloPhysics=

 and create something fun!

 

 This example is a modified version of =HelloPhysics= that creates four

 simultaneous views of the same scene of cannonballs careening into a

 brick wall.

 

 =./jme3/src/test/jme3test/helloworld/HelloPhysicsWithVideo.java=

 #+include ./jme3/src/test/jme3test/helloworld/HelloPhysicsWithVideo.java src java

 

 Running the program outputs four videos into the =./physics-videos=

 directory.

 

 #+begin_src sh :exports both :results verbatim

 ls ./physics-videos | grep -

 #+end_src

 

 #+results:

 : lower-left.flv

 : lower-right.flv

 : upper-left.flv

 : upper-right.flv

 

 The videos are fused together with the following =gstreamer= commands:

 

 #+begin_src sh :results silent

 cd physics-videos

 

 gst-launch-0.10 \

  filesrc location=./upper-right.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox border-alpha=0 left=-640 ! \

  videomixer name=mix ! ffmpegcolorspace ! videorate ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

  jpegenc ! avimux  ! filesink location=upper.flv \

  \

  filesrc location=./upper-left.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox right=-640 ! mix.

 #+end_src

 

 #+begin_src sh :results silent

 cd physics-videos

 

 gst-launch-0.10 \

  filesrc location=./lower-left.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox border-alpha=0 left=-640 ! \

  videomixer name=mix ! ffmpegcolorspace ! videorate ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

  jpegenc ! avimux  ! filesink location=lower.flv \

  \

  filesrc location=./lower-right.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox right=-640 ! mix.

 #+end_src

 

 #+begin_src sh :results silent

 cd physics-videos

 

 gst-launch-0.10 \

  filesrc location=./upper.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

  videobox border-alpha=0 bottom=-480 ! \

  videomixer name=mix ! ffmpegcolorspace ! videorate ! \

  video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \

  jpegenc ! avimux  ! filesink location=../youtube/helloPhysics.flv \

  \

  filesrc location=./lower.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

  videobox top=-480 ! mix.

 #+end_src

 

 #+begin_src sh :results verbatim

 du -h youtube/helloPhysics.flv

 #+end_src

 

 #+results:

 : 180M	physics-videos/helloPhysics.flv

 

 

 Thats a terribly large size!

 Let's compress it:

 

 ** COMMENT Compressing the HelloPhysics Video

 First, we'll scale the video, then, we'll decrease it's bitrate. The

 end result will be perfect for upload to YouTube.

 

 #+begin_src sh :results silent

 cd youtube

 

 gst-launch-0.10 \

  filesrc location=./helloPhysics.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  `: # the original size is 1280 by 960` \

  video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \

  videoscale ! \

  `: # here we scale the video down` \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  `: # and here we limit the bitrate` \

  theoraenc bitrate=1024 quality=30 ! \

  oggmux ! progressreport update-freq=1 ! \

  filesink location=./helloPhysics.ogg 

 #+end_src

 

 #+begin_src sh :results verbatim

 du -h youtube/helloPhysics.ogg

 #+end_src

 

 #+results:

 : 13M	youtube/helloPhysics.ogg

 

 [[http://www.youtube.com/watch?v=WIJt9aRGusc][helloPhysics.ogg]]

 

 #+begin_html

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/WIJt9aRGusc?hl=en&fs=1" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+end_html

 

 

 ** COMMENT failed attempts

 Let's try the [[http://diracvideo.org/][Dirac]] video encoder.

 

 #+begin_src sh :results verbatim

 cd youtube

 START=$(date +%s) 

 gst-launch-0.10 \

  filesrc location=./helloPhysics.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \

  schroenc ! filesink location=./helloPhysics.drc > /dev/null

 echo `expr $(( $(date +%s) - $START))`

 #+end_src

 

 

 #+results:

 : 142

 

 That took 142 seconds. Let's see how it does compression-wise:

 

 #+begin_src sh :results verbatim

 du -h ./youtube/helloPhysics.drc

 #+end_src

 

 #+results:

 : 22M	./physics-videos/helloPhysics.drc

 

 

 #+begin_src sh :results verbatim

 cd youtube

 START=$(date +%s) 

 gst-launch-0.10 \

  filesrc location=./helloPhysics.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \

  theoraenc ! oggmux ! filesink location=./helloPhysics.ogg \

  > /dev/null

 echo `expr $(( $(date +%s) - $START))`

 #+end_src

 

 #+results:

 : 123

 

 #+begin_src sh :results verbatim

 du -h youtube/helloPhysics.ogg

 #+end_src

 

 #+results:

 : 59M	physics-videos/helloPhysics.ogg

 

 

 =*.drc= files can not be uploaded to YouTube, so I'll go for the

 avi file.

 

 

 ** COMMENT text for videos

 Video output from JMonkeyEngine3 (www.jmonkeyengine.org/) using Xuggle

 (www.xuggle.com/).  Everything is explained at

 http://aurellem.org/cortex/capture-video.html.

 

 

 Video output from JMonkeyEngine3 (www.jmonkeyengine.org/) HelloPhysics

 demo application using Xuggle (www.xuggle.com/).  Everything is

 explained at http://aurellem.org/cortex/capture-video.html.  Here,

 four points of view are simultaneously recorded and then glued

 together later.

 

  JME3 Xuggle Aurellem video capture

  

  

 * Showcase of recorded videos

 I encoded most of the original JME3 Hello demos for your viewing

 pleasure, all using the =Capture= and =IsoTimer= classes.

 

 ** HelloTerrain

 [[http://youtu.be/5_4wyDFwrVQ][HelloTerrain.avi]]

 

 #+begin_html

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/5_4wyDFwrVQ" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+end_html

 

 ** HelloAssets

 [[http://www.youtube.com/watch?v=oGg-Q6k1BM4][HelloAssets.avi]]

 

 #+begin_html

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/oGg-Q6k1BM4?hl=en&fs=1" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+end_html

 

 ** HelloEffects

 [[http://www.youtube.com/watch?v=TuxlLMe53hA][HelloEffects]]

 

 #+begin_html

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/TuxlLMe53hA?hl=en&fs=1" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+end_html

 

 ** HelloCollision

 [[http://www.youtube.com/watch?v=GPlvJkiZfFw][HelloCollision.avi]]

 

 #+begin_html

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/GPlvJkiZfFw?hl=en&fs=1" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+end_html

 

 ** HelloAnimation

 [[http://www.youtube.com/watch?v=SDCfOSPYUkg][HelloAnimation.avi]]

 

 #+begin_html

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/SDCfOSPYUkg?hl=en&fs=1" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+end_html

 

 ** HelloNode

 [[http://www.youtube.com/watch?v=pL-0fR0-ilQ][HelloNode.avi]]

 

 #+begin_html

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/pL-0fR0-ilQ?hl=en&fs=1" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+end_html

 

 ** HelloLoop

 [[http://www.youtube.com/watch?v=mosZzzcdE5w][HelloLoop.avi]]

 

 #+begin_html

 <iframe width="425" height="349" 

 	src="http://www.youtube.com/embed/mosZzzcdE5w?hl=en&fs=1" 

 	frameborder="0" allowfullscreen>

 </iframe>

 #+end_html

 

 

 *** COMMENT x-form the other stupid 

 progressreport update-freq=1 

 

 gst-launch-0.10 \

  filesrc location=./helloPhy ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \

  x264enc ! avimux ! filesink location=helloPhysics.avi \

 

 

 gst-launch-0.10 \

  filesrc location=./HelloAnimationStatic.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox border-alpha=0 left=-640 ! \

  videomixer name=mix ! ffmpegcolorspace ! videorate ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

   x264enc ! avimux ! progressreport update-freq=1 ! \

   filesink location=../youtube/HelloAnimation.avi \

  \

  filesrc location=./HelloAnimationMotion.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox right=-640 ! mix.

 

 gst-launch-0.10 \

  filesrc location=./HelloCollisionMotion.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=800, height=600, framerate=25/1 ! \

  x264enc bitrate=1024 ! avimux ! \

  filesink location=../youtube/HelloCollision.avi 

 

 gst-launch-0.10 \

  filesrc location=./HelloEffectsStatic.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox border-alpha=0 left=-640 ! \

  videomixer name=mix ! ffmpegcolorspace ! videorate ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

   x264enc bitrate=1024 ! avimux ! progressreport update-freq=1 ! \

   filesink location=../youtube/HelloEffects.avi \

  \

  filesrc location=./HelloEffectsMotion.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox right=-640 ! mix.

 

 gst-launch-0.10 \

  filesrc location=./HelloTerrainMotion.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=800, height=600, framerate=25/1 ! \

  x264enc bitrate=1024 ! avimux ! \

  filesink location=../youtube/HelloTerrain.avi 

 

 

 gst-launch-0.10 \

  filesrc location=./HelloAssetsStatic.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox border-alpha=0 left=-640 ! \

  videomixer name=mix ! ffmpegcolorspace ! videorate ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

   x264enc bitrate=1024 ! avimux ! progressreport update-freq=1 ! \

   filesink location=../youtube/HelloAssets.avi \

  \

  filesrc location=./HelloAssetsMotion.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox right=-640 ! mix.

 

 

 gst-launch-0.10 \

  filesrc location=./HelloNodeStatic.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox border-alpha=0 left=-640 ! \

  videomixer name=mix ! ffmpegcolorspace ! videorate ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

   x264enc bitrate=1024 ! avimux ! progressreport update-freq=1 ! \

   filesink location=../youtube/HelloNode.avi \

  \

  filesrc location=./HelloNodeMotion.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox right=-640 ! mix.

 

 gst-launch-0.10 \

  filesrc location=./HelloLoopStatic.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox border-alpha=0 left=-640 ! \

  videomixer name=mix ! ffmpegcolorspace ! videorate ! \

  video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \

   x264enc bitrate=1024 ! avimux ! progressreport update-freq=1 ! \

   filesink location=../youtube/HelloLoop.avi \

  \

  filesrc location=./HelloLoopMotion.flv ! decodebin ! \

  videoscale ! ffmpegcolorspace ! \

  video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \

  videobox right=-640 ! mix.