view org/capture-video.org @ 422:6b0f77df0e53

building latex scaffolding for thesis.
author Robert McIntyre <rlm@mit.edu>
date Fri, 21 Mar 2014 01:17:41 -0400
parents 7e7f8d6d9ec5
children ebdedb039cbb
line wrap: on
line source
1 #+title: Capture Live Video Feeds from JMonkeyEngine
2 #+author: Robert McIntyre
3 #+email: rlm@mit.edu
4 #+description: Capture video from a JMonkeyEngine3 Application with Xuggle, and use gstreamer to compress the video to upload to YouTube.
5 #+keywords: JME3, video, Xuggle, JMonkeyEngine, YouTube, capture video, Java
6 #+SETUPFILE: ../../aurellem/org/setup.org
7 #+INCLUDE: ../../aurellem/org/level-0.org
10 * The Problem
11 So you've made your cool new JMonkeyEngine3 game and you want to
12 create a demo video to show off your hard work. Screen capturing is
13 the most straightforward way to do this, but it can slow down your
14 game and produce low-quality video as a result. A better way is to
15 record a video feed directly from the game while it is running.
17 In this post, I'll explain how you can alter your JMonkeyEngine3 game
18 to output video while it is running. The main trick is to alter the
19 pace of JMonkeyEngine3's in-game time: we allow the engine as much
20 time as it needs to compute complicated in-game events and to encode
21 video frames. As a result, the game appears to speed up and slow down
22 as the computational demands shift, but the end result is perfectly
23 smooth video output at a constant framerate.
26 * Video recording requires a steady framerate
27 ** The built-in =Timer= rushes to keep up.
28 #* Game-time vs. User-time vs. Video-time
30 Standard JME3 applications use a =Timer= object to manage time in the
31 simulated world. Because most JME3 applications (e.g. games) are
32 supposed to happen \ldquo{}live\rdquo{}, the built-in =Timer= requires
33 simulated time to match real time. This means that the application
34 must rush to finish all of its calculations on schedule: the more
35 complicated the calculations, the more the application is obligated to
36 rush. And if the workload becomes too much to handle on schedule,
37 =Timer= forces the application to cut corners: it demands fast,
38 approximate answers instead of careful, accurate ones. Although this
39 policy sometimes causes physically impossible glitches and choppy
40 framerates, it ensures that the user will never be kept waiting while
41 the computer stops to make a complicated calculation.
43 Now, the built-in =Timer= values speed over accuracy because real-time
44 applications require it. On the other hand, if your goal is to record
45 a glitch-free video, you need a =Timer= that will take its time to
46 ensure that all calculations are accurate, even if they take a long
47 time. In the next section, we will create a new kind of
48 =Timer=\mdash{}called =IsoTimer=\mdash{}which slows down to let the
49 computer finish all its calculations. The result is a perfectly steady
50 framerate and a flawless physical simulation.
52 # are supposed to happen \ldquo live \rdquo, this =Timer= requires the
53 # application to update in real-time. In order to keep up with the
54 # real world, JME applications cannot afford to take too much time on
55 # expensive computations. Whenever the workload becomes too much for
56 # the computer to handle on schedule, =Timer= forces the computer to
57 # cut corners, giving fast, approximate answers instead of careful,
58 # accurate ones. Although physical accuracy sometimes suffers as a
59 # result, this policy ensures that the user will never be kept waiting
60 # while the computer stops to make a complicated calculation.
62 #fast answers are more important than accurate ones.
64 # A standard JME3 application that extends =SimpleApplication= or
65 # =Application= tries as hard as it can to keep in sync with
66 # /user-time/. If a ball is rolling at 1 game-mile per game-hour in
67 # the game, and you wait for one user-hour as measured by the clock on
68 # your wall, then the ball should have traveled exactly one
69 # game-mile. In order to keep sync with the real world, the game
70 # throttles its physics engine and graphics display. If the
71 # computations involved in running the game are too intense, then the
72 # game will first skip frames, then sacrifice physics accuracy. If
73 # there are particularly demanding computations, then you may only get
74 # 1 fps, and the ball may tunnel through the floor or obstacles due to
75 # inaccurate physics simulation, but after the end of one user-hour,
76 # that ball will have traveled one game-mile.
78 # When we're recording video, we don't care if the game-time syncs
79 # with user-time, but instead whether the time in the recorded video
80 # (video-time) syncs with user-time. To continue the analogy, if we
81 # recorded the ball rolling at 1 game-mile per game-hour and watched
82 # the video later, we would want to see 30 fps video of the ball
83 # rolling at 1 video-mile per /user-hour/. It doesn't matter how much
84 # user-time it took to simulate that hour of game-time to make the
85 # high-quality recording.
86 ** COMMENT Two examples to clarify the point:
87 *** Recording from a Simple Simulation
89 **** Without a Special Timer
90 You have a simulation of a ball rolling on an infinite empty plane at
91 one game-mile per game-hour, and a really good computer. Normally,
92 JME3 will throttle the physics engine and graphics display to sync the
93 game-time with user-time. If it takes one-thousandth of a second
94 user-time to simulate one-sixtieth of a second game time and another
95 one-thousandth of a second to draw to the screen, then JME3 will just
96 sit around for the remainder of $\frac{1}{60} - \frac{2}{1000}$
97 user-seconds, then calculate the next frame in $\frac{2}{1000}$
98 user-seconds, then wait, and so on. For every second of user time that
99 passes, one second of game-time passes, and the game will run at 60
100 frames per user-second.
103 **** With a Special Timer
104 Then, you change the game's timer so that user-time will be synced to
105 video-time. Assume that encoding a single frame takes 0 seconds
106 user-time to complete.
108 Now, JME3 takes advantage of all available resources. It still takes
109 one-thousandth of a second to calculate a physics tick, and another
110 one-thousandth to render to the screen. Then it takes 0 seconds to
111 write the video frame to disk and encode the video. In only one second
112 of user time, JME3 will complete 500 physics-tick/render/encode-video
113 cycles, and $\frac{500}{60}=8\frac{1}{3}$ seconds of game-time will
114 have passed. Game-time appears to dilate $8\frac{1}{3}\times$ with
115 respect to user-time, and in only 7.2 minutes user-time, one hour of
116 video will have been recorded. The game itself will run at 500 fps.
117 When someone watches the video, they will see 60 frames per
118 user-second, and $\frac{1}{60}$ video-seconds will pass each frame. It
119 will take exactly one hour user-time (and one hour video-time) for the
120 ball in the video to travel one video-mile.
122 *** Recording from a Complex Simulation
124 *** Without a Special Timer
125 You have a simulation of a ball rolling on an infinite empty plane at
126 one game-mile per game-hour accompanied by multiple explosions
127 involving thousands of nodes, particle effects, and complicated shadow
128 shaders to create realistic shadows. You also have a slow
129 laptop. Normally, JME3 must sacrifice rendering and physics simulation
130 to try to keep up. If it takes $\frac{1}{120}$ of a user-second to
131 calculate $\frac{1}{60}$ game-seconds, and an additional
132 $\frac{1}{60}$ of a user-second to render to screen, then JME3 has
133 it's work cut out for it. In order to render to the screen, it will
134 first step the game forward by up to four physics ticks before
135 rendering to the screen. If it still isn't fast enough then it will
136 decrease the accuracy of the physics engine until game-time and user
137 time are synced or a certain threshold is reached, at which point the
138 game visibly slows down. In this case, JME3 continuously repeat a
139 cycle of two physics ticks, and one screen render. For every
140 user-second that passes, one game-second will pass, but the game will
141 run at 30 fps instead of 60 fps like before.
143 *** With a Special Timer
144 Then, you change the game's timer so that user-time will be synced to
145 video-time. Once again, assume video encoding takes $\frac{1}{60}$ of
146 a user-second.
148 Now, JME3 will spend $\frac{1}{120}$ of a user-second to step the
149 physics tick $\frac{1}{60}$ game-seconds, $\frac{1}{60}$ to draw to
150 the screen, and an additional $\frac{1}{60}$ to encode the video and
151 write the frame to disk. This is a total of $\frac{1}{24}$
152 user-seconds for each $\frac{1}{60}$ game-seconds. It will take
153 $(\frac{60}{24} = 2.5)$ user-hours to record one game-hour and
154 game-time will appear to flow two-fifths as fast as user time while
155 the game is running. However, just as in example one, when all is said
156 and done we will have an hour long video at 60 fps.
159 ** COMMENT proposed names for the new timer
160 # METRONOME
161 # IsoTimer
162 # EvenTimer
163 # PulseTimer
164 # FixedTimer
165 # RigidTimer
166 # FixedTempo
167 # RegularTimer
168 # MetronomeTimer
169 # ConstantTimer
170 # SteadyTimer
173 ** =IsoTimer= records time like a metronome
175 The easiest way to achieve this special timing is to create a new
176 timer that always reports the same framerate to JME3 every time it is
177 called.
180 =./src/com/aurellem/capture/IsoTimer.java=
181 #+include ../../jmeCapture/src/com/aurellem/capture/IsoTimer.java src java
183 If an Application uses this =IsoTimer= instead of the normal one, we
184 can be sure that every call to =simpleUpdate=, for example,
185 corresponds to exactly $(\frac{1}{fps})$ seconds of game-time.
187 * =VideoRecorder= manages video feeds in JMonkeyEngine.
190 ** =AbstractVideoRecorder= provides a general framework for managing videos.
192 Now that the issue of time is solved, we just need a function that
193 writes each frame to a video. We can put this function somewhere
194 where it will be called exactly once per frame.
196 The basic functions that a =VideoRecorder= should support are
197 recording, starting, stopping, and possibly a cleanup step
198 where it finalizes the recording (e.g. by writing headers for a video
199 file).
201 An appropriate interface describing this behavior could look like
202 this:
204 =./src/com/aurellem/capture/video/VideoRecorder.java=
205 #+include ../../jmeCapture/src/com/aurellem/capture/video/VideoRecorder.java src java
208 JME3 already provides exactly the class we need: the =SceneProcessor=
209 class can be attached to any viewport and the methods defined therein
210 will be called at the appropriate points in the rendering process.
212 However, it is also important to properly close the video stream and
213 write headers and such, and even though =SceneProcessor= has a
214 =.cleanup()= method, it is only called when the =SceneProcessor= is
215 removed from the =RenderManager=, not when the game is shutting down
216 when the user pressed ESC, for example. To obtain reliable shutdown
217 behavior, we also have to implement =AppState=, which provides a
218 =.cleanup()= method that /is/ called on shutdown.
220 Here is an AbstractVideoRecorder class that takes care of the details
221 of setup and teardown.
223 =./src/com/aurellem/capture/video/AbstractVideoRecorder.java=
224 #+include ../../jmeCapture/src/com/aurellem/capture/video/AbstractVideoRecorder.java src java
227 ** There are many options for handling video files in Java
229 If you want to generate video from Java, a great option is [[http://www.xuggle.com/][Xuggle]]. It
230 takes care of everything related to video encoding and decoding and
231 runs on Windows, Linux and Mac. Out of all the video frameworks for
232 Java, I personally like this one the best.
234 Here is a =VideoRecorder= that uses [[http://www.xuggle.com/][Xuggle]] to write each frame to a
235 video file.
237 =./src/com/aurellem/capture/video/XuggleVideoRecorder.java=
238 #+include ../../jmeCapture/src/com/aurellem/capture/video/XuggleVideoRecorder.java src java
240 With this, we are able to record video!
242 However, it can be hard to properly install Xuggle. If you would
243 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
244 Randelshofer's]] excellent pure Java AVI file writer.
246 =./src/com/aurellem/capture/video/AVIVideoRecorder.java=
247 #+include ../../jmeCapture/src/com/aurellem/capture/video/AVIVideoRecorder.java src java
249 This =AVIVideoRecorder= is more limited than the
250 =XuggleVideoRecorder=, but requires less external dependencies.
252 Finally, for those of you who prefer to create the final video from a
253 sequence of images, there is the =FileVideoRecorder=, which records
254 each frame to a folder as a sequentially numbered image file. Note
255 that you have to remember the FPS at which you recorded the video, as
256 this information is lost when saving each frame to a file.
258 =./src/com/aurellem/capture/video/FileVideoRecorder.java=
259 #+include ../../jmeCapture/src/com/aurellem/capture/video/FileVideoRecorder.java src java
264 * How to record videos yourself
266 ** Include this code.
268 No matter how complicated your application is, it's easy to add
269 support for video output with just a few lines of code.
270 # You can also record from multiple ViewPorts as the above example shows.
272 And although you can use =VideoRecorder= to record advanced
273 split-screen videos with multiple views, in the simplest case, you
274 want to capture a single view\mdash{} exactly what's on screen. In
275 this case, the following simple =captureVideo= method will do the job:
277 #+begin_src java
278 public static void captureVideo(final Application app,
279 final File file) throws IOException{
280 final AbstractVideoRecorder videoRecorder;
281 if (file.getCanonicalPath().endsWith(".avi")){
282 videoRecorder = new AVIVideoRecorder(file);}
283 else if (file.isDirectory()){
284 videoRecorder = new FileVideoRecorder(file);}
285 else { videoRecorder = new XuggleVideoRecorder(file);}
287 Callable<Object> thunk = new Callable<Object>(){
288 public Object call(){
289 ViewPort viewPort =
290 app.getRenderManager()
291 .createPostView("aurellem record", app.getCamera());
292 viewPort.setClearFlags(false, false, false);
293 // get GUI node stuff
294 for (Spatial s : app.getGuiViewPort().getScenes()){
295 viewPort.attachScene(s);
296 }
297 app.getStateManager().attach(videoRecorder);
298 viewPort.addProcessor(videoRecorder);
299 return null;
300 }
301 };
302 app.enqueue(thunk);
303 }
304 #+end_src
306 This method selects the appropriate =VideoRecorder= class for the file
307 type you specify, and instructs your application to record video to
308 the file.
310 Now that you have a =captureVideo= method, you use it like this:
312 - Establish an =Isotimer= and set its framerate :: For example, if
313 you want to record video with a framerate of 30 fps, include
314 the following line of code somewhere in the initialization of
315 your application:
316 #+begin_src java :exports code
317 this.setTimer(new IsoTimer(30));
318 #+end_src
320 - Choose the output file :: If you want to record from the game's
321 main =ViewPort= to a file called =/home/r/record.flv=, then
322 include the following line of code somewhere before you call
323 =app.start()=;
325 #+begin_src java :exports code
326 Capture.captureVideo(app, new File("/home/r/record.flv"));
327 #+end_src
330 ** Simple example
333 This example will record video from the ocean scene from the
334 JMonkeyEngine test suite.
335 #+begin_src java
336 File video = File.createTempFile("JME-water-video", ".avi");
337 captureVideo(app, video);
338 app.start();
339 System.out.println(video.getCanonicalPath());
340 #+end_src
343 I've added support for this under a class called
344 =com.aurellem.capture.Capture=. You can get it [[http://hg.bortreb.com/jmeCapture/][here]].
347 ** Hello Video! example
349 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
350 augmented it with video output as follows:
352 =./src/com/aurellem/capture/examples/HelloVideo.java=
353 #+include ../../src/com/aurellem/capture/examples/HelloVideo.java src java
355 The videos are created in the =hello-video= directory
357 #+begin_src sh :results verbatim :exports both
358 du -h hello-video/*
359 #+end_src
361 #+results:
362 : 932K hello-video/hello-video-moving.flv
363 : 640K hello-video/hello-video-static.flv
365 And can be immediately uploaded to YouTube
367 - [[http://www.youtube.com/watch?v=C8gxVAySaPg][hello-video-moving.flv]]
368 #+BEGIN_HTML
369 <iframe width="425" height="349"
370 src="http://www.youtube.com/embed/C8gxVAySaPg"
371 frameborder="0" allowfullscreen>
372 </iframe>
373 #+END_HTML
374 - [[http://www.youtube.com/watch?v=pHcFOtIS07Q][hello-video-static.flv]]
375 #+BEGIN_HTML
376 <iframe width="425" height="349"
377 src="http://www.youtube.com/embed/pHcFOtIS07Q"
378 frameborder="0" allowfullscreen>
379 </iframe>
381 #+END_HTML
384 * COMMENT More Examples
385 ** COMMENT Hello Physics
387 =HelloVideo= is boring. Let's add some video capturing to
388 =HelloPhysics= and create something fun!
390 This example is a modified version of =HelloPhysics= that creates four
391 simultaneous views of the same scene of cannonballs careening into a
392 brick wall.
394 =./jme3/src/test/jme3test/helloworld/HelloPhysicsWithVideo.java=
395 #+include ./jme3/src/test/jme3test/helloworld/HelloPhysicsWithVideo.java src java
397 Running the program outputs four videos into the =./physics-videos=
398 directory.
400 #+begin_src sh :exports both :results verbatim
401 ls ./physics-videos | grep -
402 #+end_src
404 #+results:
405 : lower-left.flv
406 : lower-right.flv
407 : upper-left.flv
408 : upper-right.flv
410 The videos are fused together with the following =gstreamer= commands:
412 #+begin_src sh :results silent
413 cd physics-videos
415 gst-launch-0.10 \
416 filesrc location=./upper-right.flv ! decodebin ! \
417 videoscale ! ffmpegcolorspace ! \
418 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
419 videobox border-alpha=0 left=-640 ! \
420 videomixer name=mix ! ffmpegcolorspace ! videorate ! \
421 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
422 jpegenc ! avimux ! filesink location=upper.flv \
423 \
424 filesrc location=./upper-left.flv ! decodebin ! \
425 videoscale ! ffmpegcolorspace ! \
426 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
427 videobox right=-640 ! mix.
428 #+end_src
430 #+begin_src sh :results silent
431 cd physics-videos
433 gst-launch-0.10 \
434 filesrc location=./lower-left.flv ! decodebin ! \
435 videoscale ! ffmpegcolorspace ! \
436 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
437 videobox border-alpha=0 left=-640 ! \
438 videomixer name=mix ! ffmpegcolorspace ! videorate ! \
439 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
440 jpegenc ! avimux ! filesink location=lower.flv \
441 \
442 filesrc location=./lower-right.flv ! decodebin ! \
443 videoscale ! ffmpegcolorspace ! \
444 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
445 videobox right=-640 ! mix.
446 #+end_src
448 #+begin_src sh :results silent
449 cd physics-videos
451 gst-launch-0.10 \
452 filesrc location=./upper.flv ! decodebin ! \
453 videoscale ! ffmpegcolorspace ! \
454 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
455 videobox border-alpha=0 bottom=-480 ! \
456 videomixer name=mix ! ffmpegcolorspace ! videorate ! \
457 video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \
458 jpegenc ! avimux ! filesink location=../youtube/helloPhysics.flv \
459 \
460 filesrc location=./lower.flv ! decodebin ! \
461 videoscale ! ffmpegcolorspace ! \
462 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
463 videobox top=-480 ! mix.
464 #+end_src
466 #+begin_src sh :results verbatim
467 du -h youtube/helloPhysics.flv
468 #+end_src
470 #+results:
471 : 180M physics-videos/helloPhysics.flv
474 That's a terribly large size!
475 Let's compress it:
477 ** COMMENT Compressing the HelloPhysics Video
478 First, we'll scale the video, then, we'll decrease it's bit-rate. The
479 end result will be perfect for upload to YouTube.
481 #+begin_src sh :results silent
482 cd youtube
484 gst-launch-0.10 \
485 filesrc location=./helloPhysics.flv ! decodebin ! \
486 videoscale ! ffmpegcolorspace ! \
487 `: # the original size is 1280 by 960` \
488 video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \
489 videoscale ! \
490 `: # here we scale the video down` \
491 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
492 `: # and here we limit the bitrate` \
493 theoraenc bitrate=1024 quality=30 ! \
494 oggmux ! progressreport update-freq=1 ! \
495 filesink location=./helloPhysics.ogg
496 #+end_src
498 #+begin_src sh :results verbatim
499 du -h youtube/helloPhysics.ogg
500 #+end_src
502 #+results:
503 : 13M youtube/helloPhysics.ogg
505 [[http://www.youtube.com/watch?v=WIJt9aRGusc][helloPhysics.ogg]]
507 #+begin_html
508 <iframe width="425" height="349"
509 src="http://www.youtube.com/embed/WIJt9aRGusc?hl=en&fs=1"
510 frameborder="0" allowfullscreen>
511 </iframe>
512 #+end_html
515 ** COMMENT failed attempts
516 Let's try the [[http://diracvideo.org/][Dirac]] video encoder.
518 #+begin_src sh :results verbatim
519 cd youtube
520 START=$(date +%s)
521 gst-launch-0.10 \
522 filesrc location=./helloPhysics.flv ! decodebin ! \
523 videoscale ! ffmpegcolorspace ! \
524 video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \
525 schroenc ! filesink location=./helloPhysics.drc > /dev/null
526 echo `expr $(( $(date +%s) - $START))`
527 #+end_src
530 #+results:
531 : 142
533 That took 142 seconds. Let's see how it does compression-wise:
535 #+begin_src sh :results verbatim
536 du -h ./youtube/helloPhysics.drc
537 #+end_src
539 #+results:
540 : 22M ./physics-videos/helloPhysics.drc
543 #+begin_src sh :results verbatim
544 cd youtube
545 START=$(date +%s)
546 gst-launch-0.10 \
547 filesrc location=./helloPhysics.flv ! decodebin ! \
548 videoscale ! ffmpegcolorspace ! \
549 video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \
550 theoraenc ! oggmux ! filesink location=./helloPhysics.ogg \
551 > /dev/null
552 echo `expr $(( $(date +%s) - $START))`
553 #+end_src
555 #+results:
556 : 123
558 #+begin_src sh :results verbatim
559 du -h youtube/helloPhysics.ogg
560 #+end_src
562 #+results:
563 : 59M physics-videos/helloPhysics.ogg
566 =*.drc= files can not be uploaded to YouTube, so I'll go for the
567 avi file.
570 ** COMMENT text for videos
571 Video output from JMonkeyEngine3 (www.jmonkeyengine.org/) using Xuggle
572 (www.xuggle.com/). Everything is explained at
573 http://aurellem.org/cortex/capture-video.html.
576 Video output from JMonkeyEngine3 (www.jmonkeyengine.org/) HelloPhysics
577 demo application using Xuggle (www.xuggle.com/). Everything is
578 explained at http://aurellem.org/cortex/capture-video.html. Here,
579 four points of view are simultaneously recorded and then glued
580 together later.
582 JME3 Xuggle Aurellem video capture
585 * Showcase of recorded videos
586 I encoded most of the original JME3 Hello demos for your viewing
587 pleasure, all using the =Capture= and =IsoTimer= classes.
589 ** HelloTerrain
590 [[http://youtu.be/5_4wyDFwrVQ][HelloTerrain.avi]]
592 #+begin_html
593 <iframe width="425" height="349"
594 src="http://www.youtube.com/embed/5_4wyDFwrVQ"
595 frameborder="0" allowfullscreen>
596 </iframe>
597 #+end_html
599 ** HelloAssets
600 [[http://www.youtube.com/watch?v=oGg-Q6k1BM4][HelloAssets.avi]]
602 #+begin_html
603 <iframe width="425" height="349"
604 src="http://www.youtube.com/embed/oGg-Q6k1BM4?hl=en&fs=1"
605 frameborder="0" allowfullscreen>
606 </iframe>
607 #+end_html
609 ** HelloEffects
610 [[http://www.youtube.com/watch?v=TuxlLMe53hA][HelloEffects]]
612 #+begin_html
613 <iframe width="425" height="349"
614 src="http://www.youtube.com/embed/TuxlLMe53hA?hl=en&fs=1"
615 frameborder="0" allowfullscreen>
616 </iframe>
617 #+end_html
619 ** HelloCollision
620 [[http://www.youtube.com/watch?v=GPlvJkiZfFw][HelloCollision.avi]]
622 #+begin_html
623 <iframe width="425" height="349"
624 src="http://www.youtube.com/embed/GPlvJkiZfFw?hl=en&fs=1"
625 frameborder="0" allowfullscreen>
626 </iframe>
627 #+end_html
629 ** HelloAnimation
630 [[http://www.youtube.com/watch?v=SDCfOSPYUkg][HelloAnimation.avi]]
632 #+begin_html
633 <iframe width="425" height="349"
634 src="http://www.youtube.com/embed/SDCfOSPYUkg?hl=en&fs=1"
635 frameborder="0" allowfullscreen>
636 </iframe>
637 #+end_html
639 ** HelloNode
640 [[http://www.youtube.com/watch?v=pL-0fR0-ilQ][HelloNode.avi]]
642 #+begin_html
643 <iframe width="425" height="349"
644 src="http://www.youtube.com/embed/pL-0fR0-ilQ?hl=en&fs=1"
645 frameborder="0" allowfullscreen>
646 </iframe>
647 #+end_html
649 ** HelloLoop
650 [[http://www.youtube.com/watch?v=mosZzzcdE5w][HelloLoop.avi]]
652 #+begin_html
653 <iframe width="425" height="349"
654 src="http://www.youtube.com/embed/mosZzzcdE5w?hl=en&fs=1"
655 frameborder="0" allowfullscreen>
656 </iframe>
657 #+end_html
660 *** COMMENT x-form the other stupid
661 progressreport update-freq=1
663 gst-launch-0.10 \
664 filesrc location=./helloPhy ! decodebin ! \
665 videoscale ! ffmpegcolorspace ! \
666 video/x-raw-yuv, width=1280, height=960, framerate=25/1 ! \
667 x264enc ! avimux ! filesink location=helloPhysics.avi \
670 gst-launch-0.10 \
671 filesrc location=./HelloAnimationStatic.flv ! decodebin ! \
672 videoscale ! ffmpegcolorspace ! \
673 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
674 videobox border-alpha=0 left=-640 ! \
675 videomixer name=mix ! ffmpegcolorspace ! videorate ! \
676 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
677 x264enc ! avimux ! progressreport update-freq=1 ! \
678 filesink location=../youtube/HelloAnimation.avi \
679 \
680 filesrc location=./HelloAnimationMotion.flv ! decodebin ! \
681 videoscale ! ffmpegcolorspace ! \
682 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
683 videobox right=-640 ! mix.
685 gst-launch-0.10 \
686 filesrc location=./HelloCollisionMotion.flv ! decodebin ! \
687 videoscale ! ffmpegcolorspace ! \
688 video/x-raw-yuv, width=800, height=600, framerate=25/1 ! \
689 x264enc bitrate=1024 ! avimux ! \
690 filesink location=../youtube/HelloCollision.avi
692 gst-launch-0.10 \
693 filesrc location=./HelloEffectsStatic.flv ! decodebin ! \
694 videoscale ! ffmpegcolorspace ! \
695 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
696 videobox border-alpha=0 left=-640 ! \
697 videomixer name=mix ! ffmpegcolorspace ! videorate ! \
698 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
699 x264enc bitrate=1024 ! avimux ! progressreport update-freq=1 ! \
700 filesink location=../youtube/HelloEffects.avi \
701 \
702 filesrc location=./HelloEffectsMotion.flv ! decodebin ! \
703 videoscale ! ffmpegcolorspace ! \
704 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
705 videobox right=-640 ! mix.
707 gst-launch-0.10 \
708 filesrc location=./HelloTerrainMotion.flv ! decodebin ! \
709 videoscale ! ffmpegcolorspace ! \
710 video/x-raw-yuv, width=800, height=600, framerate=25/1 ! \
711 x264enc bitrate=1024 ! avimux ! \
712 filesink location=../youtube/HelloTerrain.avi
715 gst-launch-0.10 \
716 filesrc location=./HelloAssetsStatic.flv ! decodebin ! \
717 videoscale ! ffmpegcolorspace ! \
718 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
719 videobox border-alpha=0 left=-640 ! \
720 videomixer name=mix ! ffmpegcolorspace ! videorate ! \
721 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
722 x264enc bitrate=1024 ! avimux ! progressreport update-freq=1 ! \
723 filesink location=../youtube/HelloAssets.avi \
724 \
725 filesrc location=./HelloAssetsMotion.flv ! decodebin ! \
726 videoscale ! ffmpegcolorspace ! \
727 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
728 videobox right=-640 ! mix.
731 gst-launch-0.10 \
732 filesrc location=./HelloNodeStatic.flv ! decodebin ! \
733 videoscale ! ffmpegcolorspace ! \
734 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
735 videobox border-alpha=0 left=-640 ! \
736 videomixer name=mix ! ffmpegcolorspace ! videorate ! \
737 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
738 x264enc bitrate=1024 ! avimux ! progressreport update-freq=1 ! \
739 filesink location=../youtube/HelloNode.avi \
740 \
741 filesrc location=./HelloNodeMotion.flv ! decodebin ! \
742 videoscale ! ffmpegcolorspace ! \
743 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
744 videobox right=-640 ! mix.
746 gst-launch-0.10 \
747 filesrc location=./HelloLoopStatic.flv ! decodebin ! \
748 videoscale ! ffmpegcolorspace ! \
749 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
750 videobox border-alpha=0 left=-640 ! \
751 videomixer name=mix ! ffmpegcolorspace ! videorate ! \
752 video/x-raw-yuv, width=1280, height=480, framerate=25/1 ! \
753 x264enc bitrate=1024 ! avimux ! progressreport update-freq=1 ! \
754 filesink location=../youtube/HelloLoop.avi \
755 \
756 filesrc location=./HelloLoopMotion.flv ! decodebin ! \
757 videoscale ! ffmpegcolorspace ! \
758 video/x-raw-yuv, width=640, height=480, framerate=25/1 ! \
759 videobox right=-640 ! mix.