Docbook2Wiki: Initial conversion from Docbook

Docbook2Wiki — Thu, 06 Mar 2008 23:50:56 GMT

Initial conversion from Docbook

New page

{{QuickTime for Java: A Developer's Notebook/TOC}}
Even if you have more elaborate plans for QuickTime for Java, I'm going to assume that your plans will, at some point in time, require reading in a movie or other QuickTime-compatible file, locally or from the network. This chapter presents basic techniques of getting a <tt>Movie</tt> object, getting it into the Java display space, and adding more sophisticated controls so that your user (or just your code) can know what's happening inside a playing movie and take control.

== Building a Simple Movie Player ==

I'll begin with "the simplest thing that could possibly work:" an application to ask the user for the location of a QuickTime file, which is then opened and put in a Java AWT <tt>Frame</tt>.

=== How do I do that? ===

[[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-EX-1|Example 2-1]] shows the code for a simple movie player.

<div id="quicktimejvaadn-CHP-2-EX-1">
'''Example 2-1. Simple movie player'''

package com.oreilly.qtjnotebook.ch02;

import quicktime.*;
import quicktime.app.view.*;
import quicktime.std.movies.*;
import quicktime.io.*;

import com.oreilly.qtjnotebook.ch01.QTSessionCheck;

import java.awt.*;

public class BasicQTPlayer extends Frame {
public BasicQTPlayer (Movie m) throws QTException {
super ("Basic QT Player");
QTComponent qc = QTFactory.makeQTComponent (m);
Component c = qc.asComponent( );
add (c);
}

public static void main (String[ ] args) {
try {
QTSessionCheck.check( );
QTFile file =
QTFile.standardGetFilePreview (
QTFile.kStandardQTFileTypes);
OpenMovieFile omFile = OpenMovieFile.asRead (file);
Movie m = Movie.fromFile (omFile);
Frame f = new BasicQTPlayer (m);
f.pack( );
f.setVisible(true);
m.start( );
} catch (Exception e) {
e.printStackTrace( );
}
}
}
</div>

Compile this from the command line (remember, as shown in the previous chapter, you must specify <tt>QTJava.zip</tt> in the classpath; this is the Mac OS X version):

<div class="note">
'''Note'''

''If you've downloaded the book code, compile and run with ant run-ch02-basicqtplayer''.
</div>

cadamson% javac -d classes -classpath
src:/System/Library/Java/Extensions/QTJava.zip
src/com/oreilly/qtjnotebook/ch02/BasicQTPlayer.java

Then run the program from the command line:

cadamson% java -classpath classes
com.oreilly.qtjnotebook.ch02.BasicQTPlayer

When the program starts up, the user will initially see QuickTime's file selector, shown in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-1|Figure 2-1]].

<div id="quicktimejvaadn-CHP-2-FIG-1">
'''Figure 2-1. QuickTime file selector'''

[[Image:QuickTime for Java: A Developer's Notebook_I_2_tt22.png|QuickTime file selector]]
</div>

After the user selects a file (note that I have not provided any error handling if the user clicks Cancel!), the movie will open in a window at its default size and start playing, as seen in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-2|Figure 2-2]].

<div id="quicktimejvaadn-CHP-2-FIG-2">
'''Figure 2-2. Simple movie player'''

[[Image:QuickTime for Java: A Developer's Notebook_I_2_tt23.png|Simple movie player]]
</div>

Note that this program does not provide any means of quitting the application once the movie finishes playing (or before then, for that matter). Press Ctrl-C from the command line to kill the app. Mac users will also get a "Quit com.oreilly.qtjnotebook.ch02.BasicQTPlayer" menu item.

=== What just happened? ===

Take a look at the application. The class extends <tt>java.awt.Frame</tt> and supplies a constructor that takes a <tt>quicktime.std.movies.Movie</tt> object. Given this <tt>Movie</tt> , it asks the <tt>QTFactory</tt> (in package <tt>quicktime.app.view</tt>) for a <tt>QTComponent</tt>. From this object, it gets a <tt>java.awt.Component</tt> , which is added to the <tt>Frame</tt>.

The <tt>main( )</tt> method starts by doing the QuickTime session check from the last chapter. Then it brings up a file selector dialog, from which it gets a <tt>quicktime.io.QTFile</tt> , from which it gets an <tt>OpenMovieFile</tt>, which leads to the creation of a <tt>Movie</tt> object with <tt>Movie.fromFile( )</tt> . This <tt>Movie</tt> is then passed to the <tt>QTBasicPlayer</tt> constructor, and the resulting <tt>Frame</tt> is <tt>pack( )</tt>ed and shown. Finally, <tt>main( )</tt> calls the <tt>Movie</tt>'s <tt>start()</tt> method to play the movie.

Notice how practically every line of code in this application either declares that it throws <tt>QTException</tt> or is wrapped in a try-catch block. That's because pretty much every QuickTime Java call can potentially throw a <tt>QTException</tt>, which means you either need to catch it or (more frequently) declare that your method throws it to the caller. Presumably at some point further up the call chain, you'll catch the exception and do something responsible with it, such as bringing up an error dialog.

Another point of interest is the <tt>QTComponent</tt> . This is an interface that exposes methods that allow you to change the movie (or image) displayed by an on-screen widget. <tt>asComponent()</tt> returns an AWT <tt>Component</tt> that can be added to an AWT layout just like any other component. Now here's the dirty little secret: all <tt>QTComponent</tt>s received from the <tt>QTFactory</tt> really are AWT <tt>Component</tt>s, and can be cast safely. That means the <tt>asComponent( )</tt> call:

Component c = qc.asComponent( );

is functionally equivalent to:

Component c = (Component) qc;

Meaning that <tt>asComponent( )</tt> is really there just for compile-time type safety.

=== What about... ===

...using the AWT or Swing file selector? Sure, you can use these—they'll return a <tt>java.io.File</tt> object, which can then be used to get a <tt>QTFile</tt>. But the QuickTime file selector is arguably nicer, because on Windows it shows a little preview of the selected movie. Another thing to notice is the odd little constant <tt>kStandardQTFileTypes</tt>. The <tt>standardGetFilePreview( )</tt> call takes an <tt>int[ ]</tt> of up to four "types" of files to allow the user to select. The constant is a very convenient way to specify "just show typical file types that QuickTime can handle." You can also pass in <tt>null</tt> to show all files.

<div class="note">
'''Note'''

''[[QuickTime for Java: A Developer's Notebook/Working with Components|Chapter 4]] has more on the FOUR_CHAR_CODE integers used for these "types.''"
</div>

== Adding a Controller ==

This application isn't particularly user-friendly yet—the user can't start or stop the movie, move through it, or set the volume. Fortunately, it's easy to use a <tt>MovieController</tt> to get the standard QuickTime controller bar, an on-screen control widget that provides a play/pause button, a volume control, and the movie position control (typically called a "scrubber" in QuickTime parlance).

=== How do I do that? ===

Create a new class in the source file ''BasicQTController.java''. The <tt>main()</tt> is exactly the same as before, while the constructor adds one new line and changes another, as seen in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-EX-2|Example 2-2]].

<div id="quicktimejvaadn-CHP-2-EX-2">
'''Example 2-2. Getting a movie component with a controller'''

public class BasicQTController extends Frame {

public BasicQTController (Movie m) throws QTException {
super ("Basic QT Controller");
MovieController mc = new MovieController(m);
QTComponent qc = QTFactory.makeQTComponent (mc);
Component c = qc.asComponent( );
add (c);
pack( );
}
</div>

<div class="note">
'''Note'''

''Compile and run this example with ant run-ch02-basicqtcontroller''.
</div>

The result, when run, looks like the application in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-3|Figure 2-3]]. Notice the presence of the classic QuickTime control bar at the bottom of the window.

<div id="quicktimejvaadn-CHP-2-FIG-3">
'''Figure 2-3. Movie with on-screen controller'''

[[Image:QuickTime for Java: A Developer's Notebook_I_2_tt26.png|Movie with on-screen controller]]
</div>

=== What just happened? ===

This time, instead of asking the <tt>QTFactory</tt> to make a <tt>QTComponent</tt> from the <tt>Movie</tt>, the program creates a <tt>MovieController</tt> object from the <tt>Movie</tt> and asks the <tt>QTFactory</tt> to make a <tt>QTComponent</tt> from that. This eliminates the need for <tt>main( )</tt> to call <tt>start( )</tt>, because the user can start and stop the movie from the play/pause button on the control bar.

== Getting a Movie-Playing JComponent ==

The previous tasks have used the AWT, which seemingly nobody uses anymore. Many developers will want to create a Swing GUI, and thus they need a movie-playing <tt>JComponent</tt>. QuickTime for Java can provide one.

=== How do I do that? ===

[[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-EX-3|Example 2-3]] presents a rewrite of the previous <tt>BasicQTPlayer</tt> that does everything with Swing equivalents (<tt>JFrame</tt> instead of <tt>Frame</tt>, <tt>JComponent</tt> instead of <tt>Component</tt>, etc.).

<div id="quicktimejvaadn-CHP-2-EX-3">
'''Example 2-3. All-Swing simple movie player'''

package com.oreilly.qtjnotebook.ch02;

import quicktime.*;
import quicktime.app.view.*;
import quicktime.std.movies.*;
import quicktime.io.*;

import com.oreilly.qtjnotebook.ch01.QTSessionCheck;

import java.awt.*;
import javax.swing.*;

public class BasicSwingQTPlayer extends JFrame {

public BasicSwingQTPlayer (Movie m) throws QTException {
super ("Basic Swing QT Player");
MoviePlayer mp = new MoviePlayer (m);
QTJComponent qc = QTFactory.makeQTJComponent (mp);
JComponent jc = qc.asJComponent( );
getContentPane( ).add (jc);
pack( );
}

public static void main (String[ ] args) {
try {
QTSessionCheck.check( );
QTFile file =
QTFile.standardGetFilePreview (
QTFile.kStandardQTFileTypes);
OpenMovieFile omFile = OpenMovieFile.asRead (file);
Movie m = Movie.fromFile (omFile);
JFrame f = new BasicSwingQTPlayer (m);
f.pack( );
f.setVisible(true);
m.start( );
} catch (Exception e) {
e.printStackTrace( );
}
}
}
</div>

<div class="note">
'''Note'''

''Compile and run this example with ant run-ch02-basicswingqtplayer''.
</div>

This produces a simple movie-player window—as seen in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-4|Figure 2-4]]—using Swing, but visually indistinguishable from its AWT equivalent.

<div id="quicktimejvaadn-CHP-2-FIG-4">
'''Figure 2-4. Playing a movie with a Swing JComponent'''

[[Image:QuickTime for Java: A Developer's Notebook_I_2_tt27.png|Playing a movie with a Swing JComponent]]
</div>

=== What just happened? ===

Creating a <tt>QTJComponent</tt> (read that as "QT JComponent," not "QTJ Component"—I know, it confused everyone on the developer list at first, too) requires an object called a <tt>MoviePlayer</tt>, which can be simply created from a <tt>Movie</tt>. This is passed to <tt>QTFactory</tt> 's <tt>makeQTJComponent()</tt> method to get a <tt>QTJComponent</tt>, which in turn can be turned into a Swing <tt>JComponent</tt> with <tt>asJComponent( )</tt> .

=== What about... ===

...getting a control bar? Good question. QTJ doesn't provide one for Swing. Remember, the movie's display and the control bar are both native widgets—to display the movie in Swing, the movie has to be drawn to an off-screen region, then painted by Java onto the <tt>JComponent</tt> so that everything is "lightweight," in Java parlance. QTJ provides this for the movie but not for the control bar (perhaps because it would be difficult for the native QuickTime to keep track of your mouse movements in the Java space), so a developer would need to roll her own Swing widget for controlling the <tt>Movie</tt>, trapping mouse actions and calling appropriate methods on the <tt>Movie</tt> or <tt>MovieController</tt>.

<div class="note">
'''Note'''

''Methods to control a Movie or MovieController are introduced in the next task''.
</div>

And what about the awful performance? Good catch—depending on your source, the frame rate of this version might be far worse than the AWT equivalent. Think about the earlier paragraph that says the movie needs to be drawn into an off-screen buffer and then reimaged into Swing. Doesn't that sound a little redundant? Think the overhead is going to add up if you need to do it 30 times a second? It is, and it does. Performance of the <tt>QTJComponent</tt> is ''awful'' compared to that of the <tt>QTComponent</tt> . Not only does QTJ have to do extra work, but it also doesn't score hardware-accelerated graphics benefits it might otherwise be able to achieve by using its native rendering pipeline.

So, I'm going to tell you something that clashes with every other Java GUI book you've ever read: ''go ahead and mix Swing and AWT widgets'' . That's right. It's not going to cause blindness, the end of the world, or a drop in your home's resale value.

To be specific, you can freely mix AWT widgets, like the <tt>QTComponent</tt>, and Swing widgets in the same container as long as they don't overlap. Unless you're doing something tricky with Swing's "glass pane," or possibly the <tt>JLayeredPane</tt>, you're probably safe.

The common overlap problem comes from menus, both those that descend from the menu bar and pop-up menus. A lightweight Swing menu will go behind any AWT component, and the result isn't pretty. The way around this is to call <tt>setLightweightPopupEnabled(false)</tt> on all your menus that might overlap with your <tt>QTComponent</tt>.

By the way, this problem isn't limited to QTJ. Most Java toolkits that use native drawing spaces for performance reasons run into the same issue. Sun's JMF defaults to heavyweight components, as does the OpenGL-to-Java library JOGL. Getting AWT and Swing to play nice is a common issue for Java multimedia developers.

== Controlling a Movie Programmatically ==

For various reasons, an application might want to control the movie via its own method calls, in lieu of or in addition to the GUI provided by QuickTime's <tt>MovieController</tt>. One example of this is <tt>Movie.start( )</tt>. You can programmatically issue many more commands, some of which you can't issue with the default control.

=== How do I do that? ===

[[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-EX-4|Example 2-4]] shows a new class, <tt>BasicQTButtons.java</tt>. The <tt>main()</tt> is exactly the same as <tt>BasicQTPlayer</tt>, but the constructor has extra work to create some control buttons, and an <tt>actionPerformed( )</tt> method implements AWT's <tt>ActionListener</tt>.

<div class="note">
'''Note'''

''Compile and run this example with ant run-ch02-basicqtbuttons.''.
</div>

<div id="quicktimejvaadn-CHP-2-EX-4">
'''Example 2-4. Programmatic control of a movie'''

package com.oreilly.qtjnotebook.ch02;

import quicktime.*;
import quicktime.app.view.*;
import quicktime.std.movies.*;
import quicktime.io.*;

import com.oreilly.qtjnotebook.ch01.QTSessionCheck;

import java.awt.*;
import java.awt.event.*;

public class BasicQTButtons extends Frame
implements ActionListener {

Button revButton,
stopButton,
startButton,
fwdButton;

Movie theMovie;

public BasicQTButtons (Movie m) throws QTException {
super ("Basic QT Player");
theMovie = m;
QTComponent qc = QTFactory.makeQTComponent (m);
Component c = qc.asComponent( );
setLayout (new BorderLayout( ));
add (c, BorderLayout.CENTER);
Panel buttons = new Panel( );
revButton = new Button("<");
revButton.addActionListener (this);
stopButton = new Button ("0");
stopButton.addActionListener (this);
startButton = new Button ("1");
startButton.addActionListener (this);
fwdButton = new Button (">");
fwdButton.addActionListener (this);
buttons.add (revButton);
buttons.add (stopButton);
buttons.add (startButton);
buttons.add (fwdButton);
add (buttons, BorderLayout.SOUTH);
pack( );
}

public void actionPerformed (ActionEvent e) {
try {
if (e.getSource( ) = = revButton)
theMovie.setRate (theMovie.getRate( ) - 0.5f);
else if (e.getSource( ) = = stopButton)
theMovie.stop( );
else if (e.getSource( ) = = startButton)
theMovie.start( );
else if (e.getSource( ) = = fwdButton)
theMovie.setRate (theMovie.getRate( ) + 0.5f);
} catch (QTException qte) {
qte.printStackTrace( );
}
}

public static void main (String[ ] args) {
try {
QTSessionCheck.check( );
QTFile file =
QTFile.standardGetFilePreview (
QTFile.kStandardQTFileTypes);
OpenMovieFile omFile = OpenMovieFile.asRead (file);
Movie m = Movie.fromFile (omFile);
Frame f = new BasicQTButtons (m);
f.pack( );
f.setVisible(true);
m.start( );
} catch (Exception e) {
e.printStackTrace( );
}
}

}
</div>

Run this program to see a display like that shown in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-5|Figure 2-5]]. The buttons call functions to set the rate of the movie. The rate is 0 for a stopped movie, a negative number for a movie playing backward, and a positive number for a movie playing forward. A rate of 1.0 represents normal playing speed, so 0.5 would be half speed, and 2.0 would be double speed. The buttons have the following functions:

;<
: Reduces the rate by 0.5. For a playing movie (rate = 1.0), clicking this once will cut it to half speed (0.5), twice will stop it (0.0), three times will go to half-speed reverse (-0.5), four times to normal-speed reverse (-1.0), etc.
;0
: Stops the movie, by way of a call to <tt>Movie.stop()</tt>, which is the same as <tt>Movie.setRate(0)</tt>.
;1
: Plays the movie forward at normal speed, equivalent to <tt>Movie.setRate(1)</tt>.
;>
: Increases the rate by 0.5.

<div id="quicktimejvaadn-CHP-2-FIG-5">
'''Figure 2-5. Controlling movie play rate with AWT buttons'''

[[Image:QuickTime for Java: A Developer's Notebook_I_2_tt28.png|Controlling movie play rate with AWT buttons]]
</div>

=== What just happened? ===

This is a very simple example of methods that can be called to affect a movie's playback. These are the methods a developer creating his own control widget (i.e., ignoring the warning in the previous section) would need to use.

Another useful method is <tt>setVolume( )</tt>, a self-explanatory method that takes values from 0.0 (silence) to 1.0 (maximum). Also useful is a <tt>setTime( )</tt> method, which changes the current position in the movie.

<div class="note">
'''Note'''

''The next task covers QuickTime's concept of time, which is used as the parameter for setTime( )''.
</div>

=== What about... ===

...using some similar methods in <tt>MovieController</tt> ? A <tt>MovieController</tt> object, even if it's not used to get an on-screen control widget, provides some methods with equivalent functionality, but with different names and conventions. For example, <tt>stop()</tt>, <tt>start( )</tt>, and <tt>setRate( )</tt> are all effectively wrapped by a single method, <tt>play( )</tt> , which takes a rate argument. <tt>MovieController</tt> also has some unique functionality, such as only playing the selection, setting "looping" behavior (immediately returning to the beginning when the end is reached, or vice versa), and a method called <tt>setPlayEveryFrame()</tt> , which will force the movie to not drop frames, even if that requires it to play more slowly than it should.

== Showing a Movie's Current Time ==

Advanced users, particularly those doing editing, would like to know a movie's current time—i.e., where they are in the movie. The scrubber can provide a general idea of the movie's current time, but certain applications call for an exact value.

=== How do I do that? ===

[[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-EX-5|Example 2-5]]s <tt>BasicQTTimeDisplay</tt> code extends the <tt>BasicQTController</tt> by adding a <tt>Label</tt> to the bottom of the <tt>Frame</tt> . A Swing <tt>Timer</tt> calls <tt>actionPerformed( )</tt> every 250 milliseconds, and this method checks the current time of the movie and resets the label.

<div class="note">
'''Note'''

''The Swing version of Timer is used to ensure that changing the label occurs on the AWT event-dispatch thread''.

Compile and run this examnple with ant run-ch02-basicqttimedisplay.
</div>

<div id="quicktimejvaadn-CHP-2-EX-5">
'''Example 2-5. Displaying the current time of a movie'''

package com.oreilly.qtjnotebook.ch02;

import quicktime.*;
import quicktime.app.view.*;
import quicktime.std.movies.*;
import quicktime.io.*;

import com.oreilly.qtjnotebook.ch01.QTSessionCheck;

import java.awt.*;
import java.awt.event.*;

public class BasicQTTimeDisplay extends Frame
implements ActionListener {
Movie theMovie;
Label timeLabel;

public BasicQTTimeDisplay (Movie m) throws QTException {
super ("Basic QT Controller");
theMovie = m;
MovieController mc = new MovieController(m);
QTComponent qc = QTFactory.makeQTComponent (mc);
Component c = qc.asComponent( );
setLayout (new BorderLayout( ));
add (c, BorderLayout.CENTER);
timeLabel = new Label ("-:--", Label.CENTER);
add (timeLabel, BorderLayout.SOUTH);
javax.swing.Timer timer =
new javax.swing.Timer (250, this);
timer.start( );
pack( );
}

public void actionPerformed (ActionEvent e) {
if (theMovie = = null)
return;
try {
int totalSeconds = theMovie.getTime( ) /
theMovie.getTimeScale( );
int seconds = totalSeconds % 60;
int minutes = totalSeconds / 60;
String secString = (seconds > 9) ?
Integer.toString (seconds) :
("0" + Integer.toString (seconds));
String minString = Integer.toString (minutes);
timeLabel.setText (minString + ":" + secString);
} catch (QTException qte) {
qte.printStackTrace( );
}
}

public static void main (String[ ] args) {
try {
QTSessionCheck.check( );
QTFile file =
QTFile.standardGetFilePreview (
QTFile.kStandardQTFileTypes);
OpenMovieFile omFile = OpenMovieFile.asRead (file);
Movie m = Movie.fromFile (omFile);
Frame f = new BasicQTTimeDisplay (m);
f.pack( );
f.setVisible(true);
m.start( );
} catch (Exception e) {
e.printStackTrace( );
}
}
}
</div>

This produces the application seen in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-6|Figure 2-6]].

<div id="quicktimejvaadn-CHP-2-FIG-6">
'''Figure 2-6. Displaying the current time of a movie'''

[[Image:QuickTime for Java: A Developer's Notebook_I_2_tt29.png|Displaying the current time of a movie]]
</div>

=== What just happened? ===

Obviously, some funky math is happening in the <tt>actionPerformed( )</tt> method, which uses the <tt>Movie</tt> 's <tt>getTime()</tt> and <tt>getTimeScale( )</tt> methods to figure out the current time in seconds, from which the program calculates the minutes and seconds portions of label.

QuickTime has a concept of a "time scale," which represents the time-keeping system of a <tt>Movie</tt>. For a given time scale, ''n'', one unit of time in that time scale is 1/''n'' seconds. So, if a <tt>Movie</tt> had a time scale of 1,000, the units would be milliseconds. <tt>Movie</tt>s actually default to a time scale of 600, but the actual value is irrelevant—you just have to be sure to work with whatever value the movie uses. <tt>getTime( )</tt> returns the movie's current time in terms of the time scale, so for a time scale of 600, if <tt>getTime( )</tt> returns 3,600, the current time is exactly 6 seconds into the movie. Other prominent methods that work with the time scale are <tt>setTime()</tt> and <tt>getDuration( )</tt>.

<div class="note">
'''Note'''

''When we work with editing commands, we'll see that the Movie selection is also represented with time-scale values like these''.
</div>

=== What about... ===

...just using milliseconds or nanoseconds or something ''normal'' instead of this crazy time-scale stuff? Actually, this flexible system of time scales is one of the best things about QuickTime. There needs to be some system of keeping track of time in a <tt>Movie</tt>, and it's generally desirable for the units to be of a sufficient resolution so that all important times divide evenly—i.e., they can be represented as <tt>int</tt>s.

Most Java programmers are used to thinking about time in terms of milliseconds, but that's totally inadequate for media. For example, CD audio has 44,100 samples a second, meaning that each sample takes 0.02267 . . . ms. So, that's obviously not going to work. Insisting on some smaller unit (microseconds, nanoseconds, picoseconds, etc.) won't help, because you can never know that it will be good enough for some arbitrary piece of time-based data. QuickTime's system of time scales allows the system of measurement to be ideally suited to the media itself.

An interesting thought about the preceding example is that <tt>Movie</tt>'s default time base of 600 is also inadequate for CD audio. As it turns out, the tracks of a movie (more accurately, the "media" they refer to) can have their own time scales. So, a <tt>Movie</tt> can have one time scale, its video can have another, and the audio can have a third.

So, why is the default time scale 600? It appears to have originated with the 60 "ticks" per second used for time keeping on the oldest Macs, but it turns out to be a wonderfully common multiple of:

* 24 (frames per second in film)
* 25 (frames per second in PAL and SECAM video, used in Europe, Africa, South America, and parts of Asia)
* 30 (frames per second in NTSC video, used in North America and Japan)

Actually, that last example is not entirely true. NTSC color video is broadcast at an overall rate of 29.97 frames/sec, so to keep things straight, two frame numbers are dropped every minute (except for every 10th minute) to compensate for a synchronization problem in the color signal. QuickTime can handle these "drop-frame" video tracks by making the time scale 2,997 and each frame 100 units long. I told you it was handy!

== Listening for Movie State-Changes ==

One problem with polling to show the current time in the movie is that it's wasteful and inaccurate: it's optimal to check the time only when the movie's playing, and to eliminate latency, it would be nice to be notified when there's a sudden change in the current time, such as when the user slides the scrubber. Fortunately, there's a callback API to notify a program when things like this occur.

=== How do I do that? ===

This example revises the <tt>BasicQTButtons</tt> program. The new version, <tt>BasicQTCallback</tt>, asks to be notified when the rate changes. When the rate is 0, it will disable the stop button (labeled "0"), and when the rate is 1, it disables the play button (labeled "1"). For space, I'll list only the lines that have changed from <tt>BasicQTButtons</tt>.

First, there are two new imports: <tt>quicktime.std.clocks</tt>, which is where callbacks are defined, and <tt>quicktime.std</tt>, whose <tt>StdQTConstants</tt> provides constants to specify the callbacks' behavior:

import quicktime.std.*;
import quicktime.std.clocks.*;

Next, the constructor is changed to pass the <tt>Movie</tt> to an inner class' constructor:

MyQTCallback myCallback = new MyQTCallback (m);

And here's the inner class. It has a constructor that takes a <tt>Movie</tt> argument and an <tt>execute( )</tt> method:

class MyQTCallback extends RateCallBack {
public MyQTCallback (Movie m) throws QTException {
super (m.getTimeBase( ),
0,
StdQTConstants.triggerRateChange);
callMeWhen( );
}
public void execute( ) {
if (rateWhenCalled = = 0.0) {
startButton.setEnabled (true);
stopButton.setEnabled (false);
} else if (rateWhenCalled = = 1.0) {
startButton.setEnabled (false);
stopButton.setEnabled (true);
}
// indicate that we want to be called again
try {
callMeWhen( );
} catch (QTException qte) {
qte.printStackTrace( );

}
}
}

The result looks like the window in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-7|Figure 2-7]]. Notice how in the screenshot, the stop button ("0") is dimmed, indicating that the movie is already stopped. If the user hits "1," the movie will play and the play button will be disabled.

<div id="quicktimejvaadn-CHP-2-FIG-7">
'''Figure 2-7. Disabling buttons via callbacks'''

[[Image:QuickTime for Java: A Developer's Notebook_I_2_tt34.png|Disabling buttons via callbacks]]
</div>

=== What just happened? ===

The inner class creates a <tt>QTCallBack</tt> , specifically a subclass of <tt>RateCallBack</tt> . In its constructor, it indicates the conditions under which it wants to be called—by passing the <tt>triggerRateChange</tt> flag, it asks to be called any time the rate changes. It then invokes <tt>callMeWhen( )</tt> to actually register the callback.

QuickTime invokes the callback via the <tt>execute()</tt> method. This implementation checks the <tt>rateWhenCalled</tt> value, inherited from <tt>RateCallBack</tt>, to determine if the movie is stopped or started, and enables or disables buttons appropriately. Finally, it issues a new <tt>callMeWhen( )</tt> call to ask to get called back on future rate changes—QuickTime callbacks are one-time-only deals, not like the <tt>EventListener</tt>s that are typical in Java, so programmers have to remember to reregister for new callbacks after every <tt>execute()</tt>.

=== What about... ===

...that <tt>0</tt> argument to the <tt>RateCallBack</tt>'s constructor? Good question. This is one of those times where all the interesting values are defined only in the native documentation, not the Javadocs. The third argument, used to trigger the callback on any rate change, can be used with the constants <tt>triggerRateEquals</tt>, <tt>triggerRateNotEqual</tt>, <tt>triggerRateLT</tt> ("less than"), <tt>triggerRateLTE</tt> ("less than or equals"), etc., to define a behavior when the callback is made only when a certain condition is true. When using these triggers, the middle argument specifies the rate to be compared. For example, a callback could be set up to run only when the movie is playing, by passing <tt>0</tt> and <tt>triggerRateNotEquals</tt> as the second and third arguments, respectively.

<div class="note">
'''Note'''

''In the previous lab, a "rate not equal to 0" callback could be used to start or stop the time-label polling thread, so it would run only when the movie has a non-zero rate''.
</div>

Are there other kinds of callbacks? Glad you asked. There are four major callbacks, each with its own class in <tt>quicktime.std.clocks</tt>:

;<tt>RateCallBack</tt>
: Calls back when the rate changes, as seen in the earlier example.
;<tt>ExtremesCallBack</tt>
: Calls back when playback reaches the beginning or end of the <tt>Movie</tt>. Behavior is specified with <tt>triggerAtStart</tt> or <tt>triggerAtStop</tt>.
;<tt>TimeCallBack</tt>
: Calls back when playback reaches a specific time in the movie. The behavior flag determines if the callback occurs when moving forward (<tt>triggerTimeFwd</tt>), backward (<tt>triggerTimeBwd</tt>), or either forward or backward (<tt>triggerTimeEither</tt>).
;<tt>TimeJumpCallBack</tt>
: Calls back when the movie's current time changes in a way that is not consistent with its current play rate. The typical case here is that the user is grabbing the scrubber to move around the movie. Setting up this callback takes no parameters or behavior flags.

And what about more sophisticated callback setup and teardown? This example doesn't need to clean up anything, but a more sophisticated application, one that opens and closes multiple movies, would need to release callback resources. This is done with a call to the <tt>QTCallBack</tt> 's <tt>cancelAndCleanup()</tt> method.

There is also a simple <tt>cancel()</tt> method that can be used to cancel a callback previously registered with <tt>callMeWhen()</tt> . To change a callback, you must <tt>cancel( )</tt> it, then construct a new callback and register it with <tt>callMeWhen( )</tt>.

== Moving Frame by Frame ==

One popular feature for playback is the ability to step forward exactly one frame. It turns out to be trickier than one might initially expect: it's not like there's a <tt>Movie.nextFrame( )</tt> method. Indeed, a <tt>Movie</tt> might not have a video track at all, if it represents an MP3 or some other audio-only media. So, finding the next frame requires being a little smarter about looking inside the <tt>Movie</tt>'s structure.

=== How do I do that? ===

This example builds on the earlier <tt>BasicQTButtons</tt> code. In this example, the implementations of the forward and back buttons are altered so that instead of changing the play rate, they change the current time to be the next frame before or after the current time. For space, this example shows only the changes from the original <tt>BasicQTButtons</tt>.

This example needs to import <tt>quicktime.std</tt> to use <tt>StdQTConstants</tt> , and <tt>quicktime.std.clocks</tt> for some time-related classes. It also adds an instance variable <tt>visualTrack</tt>, which is found with the following call:

theMovie = m;
// find video track
visualTrack =
m.getIndTrackType (1,
StdQTConstants.visualMediaCharacteristic,
StdQTConstants.movieTrackCharacteristic);

If a visual track isn't found, the <tt>revButton</tt> and <tt>fwdButton</tt> are disabled later in the constructor.

Finally, a new implementation of <tt>actionPerformed()</tt> does the frame-step logic when the <tt>revButton</tt> or <tt>fwdButton</tt> is clicked:

if (e.getSource( ) = = revButton) {
TimeInfo ti =
visualTrack.getNextInterestingTime (
StdQTConstants.nextTimeMediaSample,
theMovie.getTime( ),
-1);
theMovie.setTime (new TimeRecord (theMovie.getTimeScale( ),
ti.time));
}
else if (e.getSource( ) = = stopButton)
theMovie.stop( );
else if (e.getSource( ) = = startButton)
theMovie.start( );
else if (e.getSource( ) = = fwdButton) {
TimeInfo ti =
visualTrack.getNextInterestingTime (
StdQTConstants.nextTimeMediaSample,
theMovie.getTime( ),
1);
theMovie.setTime (new TimeRecord (theMovie.getTimeScale( ),
ti.time));
}

<div class="note">
'''Note'''

''Compile and run this example with ant run-ch02-basicqtstepper''.
</div>

There's no screenshot for this example, because it's difficult to show a frame step in a static medium like a book.

=== What just happened? ===

This program finds the video track with a call to <tt>Movie.getIndTrackType()</tt> , which takes three arguments:

;Which instance to find
: This is 1-based, so passing <tt>1</tt> means "find the first matching track."
;A search criterion
: This is a constant from <tt>StdQTConstants</tt> that can be a media "type" (<tt>videoMediaType</tt>, <tt>soundMediaType</tt>, etc.), or it can be a "characteristic" (<tt>videoMediaCharacteristic</tt>, <tt>audioMediaCharacteristic</tt>). The characteristics are helpful in cases like this when several kinds of media are acceptable matches ("visual" media includes video, MPEG, Flash, and more).
;Flags to control the search
: This should be the value <tt>movieTrackMediaType</tt> if the previous argument is a media type or <tt>movieTrackCharacteristic</tt> if it is a characteristic.

An alternative way to find a suitable track would be to iterate over the tracks with <tt>Movie.getIndTrack( )</tt>, get the <tt>Media</tt> object from each discovered track, and use <tt>instanceof</tt> to see if it matches a given media class (<tt>VideoMedia</tt>, <tt>SoundMedia</tt>, etc.).

Assuming you can find such a track, the trick to finding the next frame is to use the media's <tt>getNextInterestingTime()</tt> method. There are several kinds of "interesting times," and to indicate interest in the next frame, which is more accurately the next "sample," you pass the behavior flag <tt>nextTimeMediaSample</tt>. The method also takes a parameter representing the time in the movie where it should start searching for the next frame (in this case, it's the current time) and the desired search direction (any positive <tt>int</tt> for a forward search, and any negative <tt>int</tt> for a backward search).

The value returned by <tt>getNextInterestingTime( )</tt> is a <tt>TimeInfo</tt> object. This program is interested only in the time field of this object, which is represented in the <tt>Movie</tt>'s time scale (not the <tt>Media</tt>'s, interestingly enough). It takes that value and advances the movie to the interesting time—i.e., the next frame—with a call to <tt>Movie.setTime( )</tt> .

=== What about... ===

...other kinds of times? The native <tt>GetMediaNextInterestingTime</tt> function offers the following behavior flags:

;<tt>NextTimeMediaSample</tt>
: The behavior used in this example.
;<tt>NextTimeMediaEdit</tt>
: Finds the next group of samples—i.e., the next thing that has been edited into the movie (editing is covered in the next chapter).
;<tt>NextTimeSyncSample</tt>
: Finds the next "sync sample"—i.e., the next sample that is completely self-contained. Many video compression formats send a sync sample (also known as a "key frame"), which is a complete image, while subsequent samples are just information about what has changed since the sync sample. In other words, these later frames aren't complete and cannot be rendered without information from one or more other samples.
;<tt>NextTimeEdgeOK</tt>
: Can be <tt>OR</tt>'ed in with other flags to indicate that it's OK to return the beginning or the end of the media as a valid "interesting time."

What's up with the first track being 1 instead of 0? As a curious legacy, one that feels more like Pascal than Java, most QuickTime methods that do an index-based <tt>get</tt> are one-based, not zero-based. In fact, if you try to <tt>getTrack(0)</tt>, you'll get a <tt>QTException</tt>.

<div class="warning">
'''Warning'''

The other gotcha is that although this example is written to work with any visual media, it won't work for MPEG-1 or MPEG-2 files. These files multiplex (or "mux") the audio and video into one stream, and QuickTime doesn't de-mux them in memory, so it has no easy way to find the next video sample. This is why there are separate <tt>MPEGMedia</tt> and <tt>MPEGMediaHandler</tt> classes in QTJ; the latter is a subclass of <tt>VisualMediaHandler</tt>, but it is also implementing <tt>AudioMediaHandler</tt> . Fortunately, MPEG-4, whose internal structure is friendlier to QuickTime, appears as separate audio and video tracks just like other QuickTime movies.
</div>

== Playing Movies from URLs ==

Along with loading movies from disk, QuickTime can also load them from URLs, and is pretty smart about network latency.

=== How do I do that? ===

[[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-EX-6|Example 2-6]] shows a totally new class, <tt>BasicQTURLController.java</tt>. This is a significant rethinking of the earlier <tt>BasicQTController</tt> class. This example creates a GUI from an empty "dummy" movie, then asks the user for a URL, gets a <tt>Movie</tt> from that, and replaces the dummy movie. By getting the movie last, it tempts fate to see how well QTJ can deal with loading a movie over the network.

<div id="quicktimejvaadn-CHP-2-EX-6">
'''Example 2-6. Loading and playing a movie from a URL'''

package com.oreilly.qtjnotebook.ch02;

import quicktime.*;
import quicktime.std.*;
import quicktime.app.view.*;
import quicktime.std.movies.*;
import quicktime.std.movies.media.*;
import quicktime.io.*;

import com.oreilly.qtjnotebook.ch01.QTSessionCheck;

import java.awt.*;

public class BasicQTURLController extends Frame {

QTComponent qc;

public BasicQTURLController ( ) throws QTException {
super ("Basic QT DataRef/Controller");
Movie dummyMovie = new Movie( );
qc = QTFactory.makeQTComponent (dummyMovie);
Component c = qc.asComponent( );
add (c);
pack( );
}

public static void main (String[ ] args) {
try {
QTSessionCheck.check( );
BasicQTURLController f =
new BasicQTURLController ( );
String url =
javax.swing.JOptionPane.showInputDialog (f,
"Enter URL");
DataRef dr = new DataRef (url);
Movie m = Movie.fromDataRef (dr,
StdQTConstants.newMovieActive);
MovieController mc = new MovieController (m);
f.qc.setMovieController (mc);
f.setVisible(true);
f.pack( );
m.prePreroll(0, 1.0f);
m.preroll(0, 1.0f);
m.start( );
} catch (Exception e) {
e.printStackTrace( );
}
}
}
</div>

<div class="note">
'''Note'''

''Compile and run this example with ant run-ch02-basicqturlcontroller''.
</div>

When this app is first run, the user sees a dialog asking for a URL. Enter a valid URL (notice that again, for simplicity, the examples don't meaningfully check input or handle errors gracefully). Assuming the URL has valid QuickTime content, the user will see a window like the one shown in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-8|Figure 2-8]].

<div id="quicktimejvaadn-CHP-2-FIG-8">
'''Figure 2-8. Movie played from a URL DataRef'''

[[Image:QuickTime for Java: A Developer's Notebook_I_2_tt37.png|Movie played from a URL DataRef]]
</div>

=== What just happened? ===

Some different techniques are in play in this example, the most important of which is showing that the <tt>Movie</tt> or <tt>MovieController</tt> displayed by a <tt>QTComponent</tt> can be replaced. The constructor creates a <tt>QTComponent</tt> from the empty <tt>dummyMovie</tt>, but after creating a <tt>Movie</tt> from the URL, a <tt>MovieController</tt> is created for it and is used to replace the contents of the visible <tt>QTComponent</tt> via the <tt>setMovieController( )</tt> call.

Two helper calls, <tt>prePreroll( )</tt> and <tt>preroll( )</tt>, allocate movie-playing resources up front, to reduce jitter and dropped frames when the movie starts playing. These methods take the same two arguments: the movie time and the rate that the program intends to start playing at.

This example uses a <tt>MovieController</tt> to make a point. As seen in [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-8|Figure 2-8]], the scrubber has an inner bar that is only partially filled in. This is a graphic representation of how much of the movie data has been downloaded. This example goes ahead and plays the movie immediately, trusting that it will download data faster than we can consume it. This isn't a safe assumption at all—dial-up users will stop almost immediately, though the controller gives them the ability to see how much they have and to play when they're ready.

As for getting the <tt>Movie</tt>, it's a pretty simple process: pass the URL to a <tt>DataRef</tt> constructor. These <tt>DataRef</tt> objects are something of a general-purpose media locator in QuickTime, used here for network access. The new <tt>Movie</tt> is then created with the <tt>fromDataRef( )</tt> call.

Notice the second argument to <tt>fromDataRef( )</tt>. This is an example of using QuickTime ''behavior flags'' , which are found throughout QuickTime. One of the more interesting concepts about the flags is that these behaviors can be combined. The flags are <tt>int</tt>s with a single bit turned on (meaning their actual values are powers of 2). The idea is that you can mathematically <tt>OR</tt> them together to combine multiple behaviors. The constants of the <tt>java.awt.Font</tt> class, like <tt>BOLD</tt> and <tt>ITALIC</tt>, work pretty much the same way. In this case, in addition to making the movie active, the program could set a behavior flag to tell QuickTime not to enable alternate tracks (if there are any), by making a call like this:

Movie m = Movie.fromDataRef (dr,
StdQTConstants.newMovieActive |
StdQTConstants.newMovieDontAutoAlternate);

The other flags mentioned for this call, <tt>newMovieDontResolveDataRefs</tt> and <tt>newMovieDontAskUnresolvedDataRefs</tt>, deal with esoteric cases where a movie is not self-contained and some of the media it refers to can't be found.

<div class="warning">
'''Warning'''

The Javadocs for <tt>Movie.fromDataRef( )</tt> advocate using the behavior flag <tt>StdQTConstants4.newMovieAsyncOK</tt> . That was useful in the old QTJ, but when used in this example in QTJ 6.1, it might allow the <tt>QTComponent</tt> to decide that your movie has zero height and zero width, because the movie gets handed to the <tt>QTComponent</tt> before the size metadata gets downloaded. As [[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-FIG-8|Figure 2-8]] shows, the preceding code does ''not'' block and wait for the whole movie to be downloaded. Advice for now: don't use it unless you think you're blocking on <tt>Movie.fromDataRef( )</tt>.
</div>

== Preventing "Tasking" Problems ==

All the tasks in this chapter have managed to avoid one of the more obscure hazards in QuickTime. This example tempts fate and exposes the problem by playing a movie that would otherwise freeze up.

=== How do I do that? ===

[[QuickTime for Java: A Developer's Notebook/Playing Movies#quicktimejvaadn-CHP-2-EX-7|Example 2-7]] reprises the command-line audio player from the first chapter, which takes a path to a file as a command-line argument, builds a <tt>Movie</tt>, and plays it, without getting any kind of GUI.

<div id="quicktimejvaadn-CHP-2-EX-7">
'''Example 2-7. Playing audio from the command line'''

package com.oreilly.qtjnotebook.ch01;

import quicktime.*;
import quicktime.app.time.*;
import quicktime.io.*;
import quicktime.std.*;
import quicktime.std.movies.*;

import java.io.*;

public class BasicAudioPlayer {

public static void main (String[ ] args) {
if (args.length != 1) {
System.out.println (
"Usage: BasicAudioPlayer <file>");
return;
}
try {
QTSessionCheck.check( );
QTFile f = new QTFile (new File(args[0]));
OpenMovieFile omf = OpenMovieFile.asRead(f);
Movie movie = Movie.fromFile (omf);
'''TaskAllMovies.addMovieAndStart( );'''
movie.start( );
} catch (QTException e) {
e.printStackTrace( );
}
}
}
</div>

Notice the line in bold. Take it out, recompile, and watch what happens. The program will likely hang or immediately exit, playing just a spurt of audio or none at all.

=== What just happened? ===

QuickTime movies need to explicitly be given CPU time to do their work: reading from disk or the network, decompressing and decoding, rendering to the screen, or playing to the speakers. This process is called "tasking." Looking at the Javadocs reveals that the <tt>Movie</tt> class has a <tt>task( )</tt> method that could be called to give time to a specific movie, and a static <tt>taskAll( )</tt> method that tasks all active movies.

Managing all these calls manually and being sure to call them frequently enough would be, of course, incredibly tedious. That's why QTJ provides <tt>TaskAllMovies</tt> , a wrapper for a <tt>Thread</tt> whose job is to call <tt>task()</tt> on all active movies. This example kicks off <tt>TaskAllMovies</tt> (assuming nothing else has done so), thereafter allowing it to be blissfully unaware of tasking.

=== What about... ===

...all the other examples? Why are we only hearing about this now? Well, <tt>TaskAllMovies</tt> is so useful that QTJ itself uses it extensively. Any time a program works with QTJ's GUI classes, by getting a <tt>Component</tt> for a <tt>Movie</tt> or <tt>MovieController</tt>, it picks up calls to <tt>TaskAllMovies</tt> automatically. In fact, it's a little difficult not to pick up automatic tasking calls from QTJ, short of opening audio-only movies with non-QTJ GUI widgets, or no GUI at all, as seen here.

<div class="note">
'''Note'''

''It's still important to know about tasking in case you stumble intosuch a case and can't figure out why your application is just sitting there''.
</div>

<div class="tip">
'''Tip'''

In the last section, a warning mentioned an edge case where using the <tt>newMovieAsyncOK</tt> flag might give you a <tt>QTComponent</tt> with zero size because <tt>Movie.fromDataRef( )</tt> returned immediately, before enough of the movie could be loaded to know how big it was.

Tasking helps you solve this problem. After <tt>fromDataRef()</tt>, you would go into a <tt>while</tt> loop, testing whether <tt>Movie.getBox( )</tt> returns non-zero dimensions. If it doesn't, call <tt>task( )</tt> on the movie to give QuickTime a chance to load more of it, maybe do a <tt>Thread.sleep()</tt> or <tt>Thread.yield( )</tt> to keep Java happy, and go back to the top of the <tt>while</tt>. Because QuickTime movies usually, but don't always, have metadata early in the file, an alternative to testing the size of the movie would be to call <tt>maxLoadedTimeInMovie()</tt> on the <tt>Movie</tt> object and wait for a non-zero value—this would also be better if there's any chance the <tt>Movie</tt> is audio only.

But seriously, it's not going to happen because you don't need <tt>newMovieAsyncOK</tt>. Chill.
</div>

In QTJ 6.0 and earlier, there were also URL-loading scenarios where a program might need to <tt>task( )</tt> a few times to download enough of the <tt>Movie</tt> to read in the metadata and get a valid size, but this behavior seems to have changed in 6.1, making explicit tasking even more of an edge case.

←Older revision		Revision as of 00:17, 7 March 2008
Line 73:		Line 73:
	'''Figure 2-1. QuickTime file selector'''		'''Figure 2-1. QuickTime file selector'''

-	[[Image:QuickTime for Java: A ~~Developer's~~ Notebook_I_2_tt22.png\|QuickTime file selector]]	+	[[Image:QuickTime for Java: A Developers Notebook_I_2_tt22.png\|QuickTime file selector]]
	</div>		</div>

Line 81:		Line 81:
	'''Figure 2-2. Simple movie player'''		'''Figure 2-2. Simple movie player'''

-	[[Image:QuickTime for Java: A ~~Developer's~~ Notebook_I_2_tt23.png\|Simple movie player]]	+	[[Image:QuickTime for Java: A Developers Notebook_I_2_tt23.png\|Simple movie player]]
	</div>		</div>

Line 148:		Line 148:
	'''Figure 2-3. Movie with on-screen controller'''		'''Figure 2-3. Movie with on-screen controller'''

-	[[Image:QuickTime for Java: A ~~Developer's~~ Notebook_I_2_tt26.png\|Movie with on-screen controller]]	+	[[Image:QuickTime for Java: A Developers Notebook_I_2_tt26.png\|Movie with on-screen controller]]
	</div>		</div>

Line 219:		Line 219:
	'''Figure 2-4. Playing a movie with a Swing JComponent'''		'''Figure 2-4. Playing a movie with a Swing JComponent'''

-	[[Image:QuickTime for Java: A ~~Developer's~~ Notebook_I_2_tt27.png\|Playing a movie with a Swing JComponent]]	+	[[Image:QuickTime for Java: A Developers Notebook_I_2_tt27.png\|Playing a movie with a Swing JComponent]]
	</div>		</div>

Line 359:		Line 359:
	'''Figure 2-5. Controlling movie play rate with AWT buttons'''		'''Figure 2-5. Controlling movie play rate with AWT buttons'''

-	[[Image:QuickTime for Java: A ~~Developer's~~ Notebook_I_2_tt28.png\|Controlling movie play rate with AWT buttons]]	+	[[Image:QuickTime for Java: A Developers Notebook_I_2_tt28.png\|Controlling movie play rate with AWT buttons]]
	</div>		</div>

Line 472:		Line 472:
	'''Figure 2-6. Displaying the current time of a movie'''		'''Figure 2-6. Displaying the current time of a movie'''

-	[[Image:QuickTime for Java: A ~~Developer's~~ Notebook_I_2_tt29.png\|Displaying the current time of a movie]]	+	[[Image:QuickTime for Java: A Developers Notebook_I_2_tt29.png\|Displaying the current time of a movie]]
	</div>		</div>

Line 552:		Line 552:
	'''Figure 2-7. Disabling buttons via callbacks'''		'''Figure 2-7. Disabling buttons via callbacks'''

-	[[Image:QuickTime for Java: A ~~Developer's~~ Notebook_I_2_tt34.png\|Disabling buttons via callbacks]]	+	[[Image:QuickTime for Java: A Developers Notebook_I_2_tt34.png\|Disabling buttons via callbacks]]
	</div>		</div>

Line 749:		Line 749:
	'''Figure 2-8. Movie played from a URL DataRef'''		'''Figure 2-8. Movie played from a URL DataRef'''

-	[[Image:QuickTime for Java: A ~~Developer's~~ Notebook_I_2_tt37.png\|Movie played from a URL DataRef]]	+	[[Image:QuickTime for Java: A Developers Notebook_I_2_tt37.png\|Movie played from a URL DataRef]]
	</div>		</div>

QuickTime for Java: A Developer's Notebook/Playing Movies - Revision history

Docbook2Wiki: Initial conversion from Docbook

Docbook2Wiki: Initial conversion from Docbook

Evanlenz: 1 revision(s)

Docbook2Wiki: Initial conversion from Docbook

Evanlenz: 1 revision(s)

Docbook2Wiki: Initial conversion from Docbook

Evanlenz: 1 revision(s)

Docbook2Wiki: Initial conversion from Docbook