Autoplay

As John Brunner once wrote, "It's supposed to be automatic, but actually you have to push this button." You can simplify the user interface by having the QuickTime movie start playing automatically. The user doesn't have to do anything. People are singularly amazed when they click into a website and it just starts talking.

AUTOPLAY="True" | "False" (the default is "False" )

Example: <EMBED SRC="My.mov" HEIGHT="256" WIDTH="320"
AUTOPLAY="True">

People can set their own default value for autoplay using their QuickTime settings, so set this to False if you want to be 100% certain that the movie won't start until the user clicks a button.

Note: If your Web page opens the movie in QuickTime Player, as described in Click Here, Play There , you can make the movie autoplay by clicking the Auto Play Enabled checkbox in the movie's Info window, as described in Settings You Can Save .

Hide the Controller

Hiding the controller is normally a bad idea, because the user can't stop or rewind the movie--if you haven't set AUTOPLAY="True" , they can't even start the movie. But for a background sound, a hidden controller can be just the ticket. For background sound, you normally combine QuickTime's CONTROLLER and AUTOPLAY parameters with the browser's HIDDEN parameter.

CONTROLLER="True" | "False" (default is "True" except for .swf files)

Example: <EMBED SRC="Sound.mov" HEIGHT="2" WIDTH="2"
AUTOPLAY="True" HIDDEN="True" CONTROLLER="False">

You also want to disable the controller when showing a poster movie or when the movie is controlled by wired sprites or a Flash track. (We'll get into poster movies, wired sprites, and Flash tracks later.)

Audio Volume

By default, the QuickTime Plug-in plays audio at full volume, which is 100% of the loudness the user has selected in the computer's Sound control panel. You can use the VOLUME parameter to create quiet background music or barely perceptible whispering. Note that MIDI is generally louder than recorded sound, so setting the volume to 75% is a good way to play MIDI sounds at the expected level.

VOLUME=" Percent " (0-300)

Example: <EMBED SRC="MyMIDI.mov" HEIGHT="16" WIDTH="180"
AUTOPLAY="True" VOLUME="75">

Values of greater than 100 can be used to overdrive the audio. This should be done cautiously because it can create distortion and clipping, not to mention annoyance.

Tip: If you choose to include looping background music on your site, set a low volume. That way, fewer people will want to strangle you.

Play Something Else, Man

You can tell the QuickTime Plug-in to play a different file than the one specified by the SRC parameter of the <EMBED> tag. This is crucial, because the browser uses the SRC parameter to decide which plug-in to use. If the SRC parameter specifies a QuickTime image ( .qti ), the browser will choose the QuickTime Plug-in. You can then use the QTSRC parameter to tell the plug-in to play a QuickTime movie, Flash .swf , MIDI, MP3, or other file type. This is discussed in more detail in Chapter 3, "Bust a .Mov."

QTSRC=" Filename "

Example: <EMBED SRC="UNeedQT4.qti" TYPE="image/x-quicktime" HEIGHT="16" WIDTH="180" QTSRC="Hot.mp3">

Set QTSRC to the name of the file you really want the plug-in to play. You can include a relative path or the full URL.

Another important feature of the QTSRC parameter is that the QuickTime Plug-in gets the specified file using its own HTTP, RTSP, or file handling processes. This means that it works properly with RTSP URLs used for streaming movies and with local files that the browser itself might mishandle. It also means you can set a maximum download speed with the QTSRCCHOKESPEED parameter, described next.

The browser still downloads the file indicated by the SRC parameter, even though the plug-in ignores it. This is basically wasted bandwidth, so specify a small throw-away image in the SRC parameter. A good choice is UNeedQT4.qti , which you can find in the BasicTraining folder of the CD. By the way, the SRC parameter has to point to a real file, or the browser gets confused.

Slow Down!

Okay, normally you want the movie to download faster, not slower. But a large movie can bring your server to its knees when someone downloads it using a T1 connection, even though twenty people could watch the same movie simultaneously using 56K modems. That's because the viewer with the T1 connection is using 1.5 megabits per second of bandwidth, the same as twenty-four 56K modems.

So if a movie has a data rate of less than 56,000 bits per second, for example, you want to limit the download speed to 56K--people can still watch the movie as it downloads, but someone with a fast Internet connection won't hog all your server's bandwidth.

You limit the bandwidth for a movie by setting its choke speed. The parameter is QTSRCCHOKESPEED . It applies only to movies specified by the QTSRC parameter, as described in Play Something Else, Man .

QTSRCCHOKESPEED=" MaxSpeed " (in bits per second)

Example: <EMBED SRC="UNeedQT4.qti" TYPE="image/x-quicktime" HEIGHT="16" WIDTH="180" QTSRC="Hot.mp3"
QTSRCCHOKESPEED="130000">

Use a choke speed setting a little higher than the data rate of the movie to allow for network overhead. For a 128 Kbit/sec MP3, for example, set the choke speed to 130000 so people with fast connections can hear it in real time, but people with really fast connections won't use up all your Web server's bandwidth.

You can also set QTSRCCHOKESPEED="movierate" and QuickTime will do its best to use only as much bandwidth as needed to play the movie smoothly.

You also want to set the choke speed when delivering movies that mix streaming and nonstreaming tracks, so you can reserve some bandwidth for the streaming parts. For details, see Chapter 17, "Mixing It Up: Streaming and Nonstreaming."

Tip: As of this writing (QuickTime 4.1.2), QTSRCCHOKESPEED only limits the download speed of the actual movie file specified by QTSRC . Any data contained in external files, including alternate movies, is unaffected. For now, use QTSRCCHOKESPEED with self-contained movies.

Click Here, Play There

You can associate a URL with a QuickTime movie, so the URL loads when someone clicks inside the movie's display area. This lets you do a lot of interesting things. The URL can specify a Web page, a JavaScript function, or a second movie. If the URL specifies a Web page, that page can include an embedded movie of its own.

You can specify a target for the URL, so it loads in another frame or another window. You can also target the URL to replace the current movie in the QuickTime Plug-in, or to load in the QuickTime Player application, launching it if necessary.

This last is particularly useful. You see, you can't directly tell the browser to launch an application using HTML; that's an Internet no-no. So if you want a movie to launch in QuickTime Player, this is how you do it. You embed a movie for the plug-in, typically a single image with no controller, and tell the plug-in to launch a different movie in QuickTime Player when someone clicks the image. An example of this is Poster2.htm (in the Special Delivery folder on the CD), shown on the next page.

HREF=" url " TARGET=" FrameName " TARGETCACHE="True" | "False"

Example: <EMBED SRC="Poster.mov" HEIGHT="256" WIDTH="320"
CONTROLLER="False" HREF="Actual.mov"
TARGET="quicktimeplayer">

Start and End Times

You can tell the plug-in to play just part of a movie by setting the start time, the end time, or both. You might do this to create a series of buttons, each of which plays a different clip from the same movie. This technique is particularly useful with streaming movies.

STARTTIME=" StartTime " ENDTIME=" EndTime "

Example: <EMBED SRC="Long.mov" HEIGHT="176" WIDTH="120"
STARTTIME="00:01:10.0" ENDTIME="00:02:10.0"
AUTOPLAY="True">

Times are in Hours:Minutes:Seconds.Fractions relative to the start of the movie ( 00:00:00.0 ). The Fractions are expressed in 1/30ths of a second. For 30 frames-per-second video, each fractional time unit is one frame. The example above plays one minute of Long.mov , starting one minute and ten seconds into the movie. You can specify just a start time or just an end time.

You normally want to set AUTOPLAY="True" when you specify a start or end time, so the clip just plays; otherwise the user might try to position the controller to play a different clip.

Note: Setting start and end times for a clip is useful for real-time streaming movies or local movies on a disk--it's less useful for Fast Start movies over the Internet because the whole movie downloads, not just the specified clip.

Play a Series of Movies

You can tell the QuickTime Plug-in to play a series of movies, one after the other. When the current movie finishes, the next movie in the list starts. This can be a good way to deliver a long movie; users never need to store more than a small piece of it on their computers at any time.
QTNEXT n ="< Filename > T< Target >" or "GOTO n "

Example: <EMBED SRC="First.mov" HEIGHT="176" WIDTH="120" QTNEXT1="<Second.mov> T<myself>"
QTNEXT2="<Third.mov> T<myself>">

You have to append a number between 1 and 255 to each QTNEXT . They execute in numerical order.

Note that you must place angle brackets around the < Filename > and T< Target > values, and quotes must surround both values jointly:
"< Filename > T< Target >" .

Set < Filename > to the name of the file you want to play next. You can include a relative path or the full URL.

The T< Target > parameter is optional. It specifies where the movie plays. If it's not specified, the next movie replaces the current browser window or frame, and any subsequent QTNEXT statements are lost. The special value of T<myself> targets the QuickTime Plug-in, and is normally the value you want; the next movie replaces the current movie, and subsequent QTNEXT statements are executed in turn. The target can also be the name of a browser window or frame. If no window or frame of that name exists, a new browser window with that name is created. You can also specify T<quicktimeplayer> as a target, which opens the movie in QuickTime Player.

IMPORTANT
The special targets T<myself> and T<quicktimeplayer> are
case-sensitive in some versions of QuickTime. Use all lowercase.

Each QTNEXT statement has an index number, which is the order in which the movies play. If you specify a QTNEXT1 , then a QTNEXT5 , and then a QTNEXT10 , for example, the three of them execute in numerical order, and their index numbers are 1, 5, and 10. Want to keep your sanity? Number the QTNEXT statements in simple numerical order: 1, 2, 3...

The special index value of 0 is assigned to the original movie named in the SRC parameter (or the QTSRC parameter, if it was specified).

Why have index numbers? Because instead of a filename, you can specify <GOTO n > , where n is the index of the QTNEXT you want to go to. You normally do this to create a simple loop:
<EMBED SRC="First.mov" HEIGHT="176" WIDTH="120"
QTNEXT1="<Second.mov> T<myself>"
QTNEXT2="<Third.mov> T<myself>"
QTNEXT3="<GOTO0>">

This example plays First.mov , then Second.mov , then Third.mov , then goes back to First.mov (index 0), in an endless loop. You can use values other than 0 to cause QTNEXT statements to play in arbitrary order, or to start looping from some midpoint. For example,
<EMBED SRC="Intro.mov" HEIGHT="176" WIDTH="120"
QTNEXT1="<First.mov> T<myself>"
QTNEXT2="<Second.mov> T<myself>"
QTNEXT3="<GOTO1>">
would play the Intro.mov just once, then play First.mov and Second.mov in an endless loop.

Note: A bug in QuickTime 4.1 caused GOTO0 to play the most recent movie instead of the first movie in the sequence, although any subsequent movies in the sequence played correctly. The workaround is to specify the original movie at the beginning and end of the loop, and use GOTO1 instead:
<EMBED SRC="First.mov" HEIGHT="176" WIDTH="120"
QTNEXT1="<Second.mov> T<myself>"
QTNEXT2="<Third.mov> T<myself>"
QTNEXT3="<First.mov> T<myself>"
QTNEXT3="<GOTO1>"
This sequence plays correctly whether the bug is present or not.

Save It Right

The QuickTime Plug-in has a couple of options that control how viewers can save movies, or not save them: KIOSKMODE and DONTFLATTENWHENSAVING .

You can provide basic copy protection for your movie by setting KIOSKMODE to True . The plug-in disables its Save as Source and Save as QuickTime Movie commands, and doesn't allow drag-and-drop saving to the desktop.

Of course, this isn't foolproof protection, but it will stop honest people and discourage opportunists. You can get stronger protection using Plug-in Helper, as described in Copy-Protecting Movies with Plug-In Helper .

KIOSKMODE="True" | "False"

Example: <EMBED SRC="DontCopyMy.mov" HEIGHT="176" WIDTH="120" KIOSKMODE="True">

That's it for KIOSKMODE .

The DONTFLATTENWHENSAVING parameter is a little more complicated because you have to understand movie flattening. It's like this: movies can contain references that point to their media data; that data can be in an external file, or it can be data stored in the movie file itself. Movies can contain multiple references to a single chunk of data. When a movie is flattened, all the references are replaced with actual copies of the data. If the data is copied from external files into the movie file, this makes the movie self-contained. If the references are to data already inside the movie file, flattening replaces internal references with internal copies. In either case, it makes the movie file larger.

Unless you've copy-protected a movie, your viewers can save a copy of your movie using the QuickTime Plug-in. You can control whether or not the QuickTime Plug-in saves a flattened copy of the movie. By default, the Save As Source command saves without flattening, and the Save As QuickTime Movie command saves and flattens. The DONTFLATTENWHENSAVING parameter prevents flattening.

DONTFLATTENWHENSAVING

Example: <EMBED SRC="DontCopyMy.mov" HEIGHT="176" WIDTH="120"
DONTFLATTENWHENSAVING>

If the movie on your Web server isn't self-contained, you can prevent people from making a working copy of the movie by setting the DONTFLATTENWHENSAVING parameter. If the movie is saved with this parameter set, data in external files isn't copied. The saved movie won't play unless those files are present on the user's computer (which they won't be).

If you've created a movie with a lot of internal references, you should set the DONTFLATTENWHENSAVING parameter for a different reason. If it isn't set, all the references will turn into copies when the movie is saved, resulting in a huge file. For example, let's say you've made a movie using a 60 Kbyte audio sample that's referenced two hundred times. With internal references, the file is a little over 60 Kbytes in size; flattened, it swells to 12 megabytes. So tell the plug-in DONTFLATTENWHENSAVING .

Background Color

You allot space on your Web page for the QuickTime Plug-in using the HEIGHT and WIDTH parameters. If you allot exactly enough space for the movie, the background doesn't show through, so its color doesn't matter.

But if you're showing a movie that plays at different sizes for different speed connections, or you're playing a series of movies that are different sizes, you need to allot enough space for the biggest movie. When a smaller movie is playing, the plug-in's background shows. So set a background color that looks good on your Web page.

You should also set the background color if the movie has a transparent background or if it changes size as it plays.

BGCOLOR= "# rrggbb " (or one of the named colors listed in the next section)

Example: <EMBED SRC="MultiSize.mov" HEIGHT="336" WIDTH="240"
BGCOLOR="#0000FF">

The color is specified using a hexadecimal value made up of three 1-byte values: 1 byte each for red, green, and blue, with each value having a range of 00 to FF . This is identical to the way you specify the BGCOLOR parameter in the HTML <BODY> tag. Alternately, you can specify some colors by name, such as Black or Red . The named colors are listed in Summary of QuickTime Plug-in Parameters .

Combined Operations

You can combine plug-in features in an almost unlimited number of ways. For example, let's say you want a movie to play in QuickTime Player without requiring the viewer to click a poster movie, and you'd like to precede the movie with a little fanfare of trumpets. You can do this by combining the HIDDEN , CONTROLLER , AUTOPLAY , and QTNEXT parameters.

Example: <EMBED SRC="Fanfare.mov" HEIGHT="2" WIDTH="2"
HIDDEN="True" AUTOPLAY="True" CONTROLLER="False"
QTNEXT1="<Player.mov> T<quicktimeplayer>">

This causes Fanfare.mov to play automatically in the background when the HTML page loads in a browser. As soon as Fanfare.mov finishes, Player.mov loads in the QuickTime Player application, outside the browser.

Color name	RGB value
BLACK	#000000
GREEN	#008000
SILVER	#COCOCO
LIME	#00FF00
GRAY	#808080
OLIVE	#808000
WHITE	#FFFFFF
YELLOW	#FFFF00
MAROON	#800000
NAVY	#000080
RED	#FF0000
BLUE	#0000FF
PURPLE	#800080
TEAL	#008080
FUCHSIA	#FF00FF
AQUA	#00FFFF

Making a Poster Movie

Here's a practical example. Suppose you want to embed a still image in your Web page that loads and plays a movie when someone clicks the image. Suppose further that you want the movie to load and play right where the image is. You can do this, but you need Plug-in Helper to get it right. Here's how:

1. Make a QuickTime movie that contains just the still image. Let's call it Poster.mov . You can do this by opening an image in QuickTime Player and saving it as a self-contained movie.
2. Embed the poster movie in your Web page and set the HREF and TARGET parameters so the real movie loads when someone clicks the image:
   <EMBED SRC="Poster.mov" HEIGHT=176 WIDTH=120
   HREF="Other.mov" TARGET="myself">

The problem now is that you don't want the poster movie to have a controller; you want people to click it, not try to play it. But you do want the second movie to have a controller, and you want it to autoplay. So:

1. Pass the CONTROLLER="False" parameter in the <EMBED> tag for the poster movie:
   <EMBED SRC="Poster.mov" HEIGHT=176 WIDTH=120
   HREF="Other.mov" TARGET="myself" CONTROLLER="False">
2. Use Plug-in Helper to put the CONTROLLER="True" and AUTOPLAY="True" parameters inside the other movie, as shown in the following illustration:

Copy-Protecting Movies with Plug-In Helper

There are several things you can do to copy-protect your movies using Plug-in Helper. You can set a movie characteristic that prevents the movie from being edited or saved by any QuickTime application, you can conceal a movie's URL by embedding it inside a poster movie, or you can conceal a movie's URL by embedding it in a decoy movie. You can combine these methods by copy-protecting the poster or decoy movie as well.

Loading a URL from a Movie

You can embed links to various URLs inside a movie using Plug-in Helper. This makes the links independent of any HTML, so multiple movies specified by a single <EMBED> tag can each have their own links.

It also allows you to create links that work when a movie is playing in QuickTime Player. QuickTime Player can load the URL itself, without going through a browser, or it can open the URL in a browser window, launching the browser if necessary.

The URL can specify a movie, a Web page, or some other file. It can be targeted to load in a window or frame of the browser, to replace the current movie, or to load in QuickTime Player.

There are three areas in the Plug-in Helper window where you can add URLs: the Plugin Settings text box, the Movie URL text box, or the Track URL text box. Each has a different behavior.

What's in a Name?

On your computer, a file may be allowed to have blank spaces or characters other than numbers and letters in its name. But a movie intended for the Web must have a name that doesn't confuse the Web server's file system, the viewer's file system, or any browsers.

For example, a movie named My Movie cannot be used on most Web servers, and a link to <A HREF="My Movie"> will fail on a variety of browsers and operating systems. One problem is the blank space, another is the lack of a file extension. Use MyMovie.mov instead.

As another example, Macintosh computers are not case-sensitive--you can name a file MyMovie.Mov ,and link to it with <A HREF="mymovie.mov"> . This works fine locally, but the link will fail on a Windows CD or a UNIX Web server.

Here are some useful rules for naming movies:

• Use a short name and a three-letter file extension separated by a period; for example: MyMovie.mov .
• Use lowercase .mov for the file extension.
• Use only one period ( . ) in the filename, the one before the file extension.
• Use only letters ( a-z ) and numbers ( 0-9 ) in the actual name.
• Never begin a filename with a number; use Movie1.mov rather than 1Movie.mov .
• Never include a blank space, a colon ( : ), a vertical bar ( | ), a forward slash ( / ), or a backslash ( \ ) in a filename.
• If you capitalize any letters in the filename, be sure all links to the movie use exactly the same capitalization. MyMovie.mov is not equal to mymovie.mov .

Making Movies Self-Contained

Generally speaking, you want to make your movies self-contained for Web delivery.

Remember that a movie is made of tracks. Tracks contain references to media samples such as sound or video. When you make a movie self-contained, any references to data in external files are resolved, and copies of the data are stored inside the movie file itself. What's more, the data samples are interleaved for smooth delivery.

If you don't make a movie self-contained, it stores references to the external files (the filenames and the relative path to the files). It also stores the byte offset into the files for each media sample. For such a movie to work, the data files cannot be edited, moved relative to the movie file, or renamed. Any directory names in the relative path must also remain unchanged.

For such a movie to work over the Web, there are additional requirements: the external files and any directories in the relative path must also exist on the Web server, they must have exactly the same names they had on the original computer, and these must be legal file and directory names in the Web server's file system.

There are so many ways to screw this up that it isn't even funny. As a general rule, you should just make the movie self-contained and not worry about it.

Still, there are times when you don't want to make a movie self-contained, as we'll describe in the next section. If you don't make a movie self-contained, you improve your chances of survival by doing the following:

• Make sure that the data files have only lowercase letters in their filenames; don't mix uppercase and lowercase.
• Put all the data files in one directory, and save the movie to the same directory when you create it; that way there are no directory names in the path to the files.

Flattening

Making a movie self-contained is sometimes called "flattening" the movie. That's unfortunate, because flattening is really something more. Flattening a movie means that all references to media data are resolved and copies of the data are stored in the movie file. If the references are to data in external files, that does make the movie self-contained. But flattening also resolves internal references.

Remember, a track can contain multiple references to the same media data. What's more, the same data can be referenced by multiple tracks. If that data is already stored in the movie file, the movie is already self-contained. The references are to internal data.

When you flatten a movie, all references are resolved, and any referenced data is copied into the movie file. Internal references are resolved by making internal copies of the data. That makes the movie file larger, sometimes much larger, but it also optimizes the movie for smooth playback.

Note: Macintosh files can have both a data fork and a resource fork, but Windows and UNIX files don't have resource forks. In the ancient days of QuickTime 1.0, the header data for a movie was stored in the movie file's resource fork. Before you could put a movie on a UNIX Web server or a Windows CD, you had to move some things into the data fork. There was a utility program named FlattenMoov that did this, so using it was often called "flattening" a movie as well. QuickTime now stores the movie header in the data fork by default, so movies no longer need to be flattened in this old sense.

Currently, clicking the "Make movie self-contained" checkbox when you save a movie in QuickTime Player flattens the movie. Sometimes you want to make a movie self-contained without flattening it, which can be tricky.

Here's an example. Open any self-contained movie in QuickTime Player. Select All. Copy. Paste. Paste. Paste. Now when you play the movie, it repeats all the data three times. If you choose Save from the File menu, then look at the file size, you'll find that the movie file has grown by only a few bytes. That's because it makes three references to the same set of data. It's self-contained, but not flattened.

But if you choose Save As from the File menu to make a new copy of the movie, you'll see that making the file self-contained triples its original size, while saving normally (allowing dependencies) uses only 1K.

Settings You Can Save

Some of the user settings that you can choose in QuickTime Player's Movie menu are saved along with the movie. You can use these settings to control the way a movie is displayed when you target the QuickTime Player, much the same way you use Plug-in Helper to control the way a movie is displayed by the QuickTime Plug-in.

 

You might use this approach successfully for a page with a few small movies or in a controlled environment--two or three short audio loops, for example, or short movie clips on an intranet page for users with a known amount of RAM.

For pages with several large movies or MP3 files, delivered over the Internet, this is a recipe for trouble.

Fortunately, there are other solutions. You can use poster movies, target the movies to QuickTime Player, target the movies to a common frame or window, or you can use a little JavaScript.

Poster Movies

Poster movies are described in Making a Poster Movie and Click Here, Play There . To embed multiple poster movies on a page, try this:

<EMBED SRC="Poster1.mov" HREF="HugeMovie1.mov" TARGET="myself"
HEIGHT=136 WIDTH=160> <BR>
<EMBED SRC="Poster2.mov" HREF="HugeMovie2.mov" TARGET="myself"
HEIGHT=136 WIDTH=160> <BR>
<EMBED SRC="Poster3.mov" HREF="HugeMovie3.mov" TARGET="myself"
HEIGHT=136 WIDTH=160> <BR>

This still loads multiple copies of the plug-in, but each copy initially shows an image rather than a whole movie. This shortens the load time for your page and doesn't require a lot of RAM initially.

To see an example of this approach, load MultiMovie2.htm (in the SpecialDelivery folder on the CD). It's shown on the next page.

Targeting QuickTime Player

Alternately, you can have your poster movies target QuickTime Player. A user who runs short on RAM can simply close any open movies. The HTML looks like this:

<EMBED SRC="Poster1.mov" HREF="HugeMovie1.mov"
TARGET="quicktimeplayer" HEIGHT=136 WIDTH=160> <BR>
<EMBED SRC="Poster2.mov" HREF="HugeMovie2.mov"
TARGET="quicktimeplayer" HEIGHT=136 WIDTH=160> <BR>
<EMBED SRC="Poster3.mov" HREF="HugeMovie3.mov"
TARGET="quicktimeplayer" HEIGHT=136 WIDTH=160> <BR>

To see an example of this approach, load MultiMovie4.htm (in the SpecialDelivery folder on the CD).

Targeting a Frame or a Window

QuickTime Player has a distinctive visual interface, which may or may not be what you want. The plug-in has a more neutral interface, and you can customize the Web page around it (or hide the controller altogether). If you prefer to use the plug-in, you can target a frame or a window instead of targeting QuickTime Player. If each poster targets the same frame or window, only one movie loads into memory at any time.

You can either create a frameset with a designated frame for playing movies, or you can let the browser create a new window to play movies in.

In either case, write a small HTML page for each movie, with that movie embedded in it:

<HTML>
<HEAD>
<TITLE>Movie In Window</TITLE>
</HEAD>
<BODY>
<DIV ALIGN="Center">
<H1>Huge Movie 1</H1>
<EMBED SRC="HugeMovie1.mov" HEIGHT=136 WIDTH=160 AUTOPLAY="True">
</DIV>
</BODY>
</HTML>

Use the URL of the page you just wrote in the poster movie's HREF tag, and target a frame or a window. Specify the same target for all the movies:

<EMBED SRC="Poster1.mov" HREF="HugeMovie1.htm"
TARGET="MovieFrame" HEIGHT=136 WIDTH=160> <BR>
<EMBED SRC="Poster2.mov" HREF="HugeMovie2.htm"
TARGET="MovieFrame" HEIGHT=136 WIDTH=160> <BR>
<EMBED SRC="Poster3.mov" HREF="HugeMovie3.htm"
TARGET="MovieFrame" HEIGHT=136 WIDTH=160> <BR>

When the user clicks a poster, the HTML page with the corresponding movie loads and plays in the named frame. If there is no frame with that name, the browser creates a new window. When the user clicks a different poster, a new movie plays in the same place. The old movie and the old copy of the plug-in are dismissed from memory, so only the current movie uses any RAM.

To see an example of this approach, load MultiMovie5.htm (in the SpecialDelivery folder on the CD).

Creating a Window with JavaScript

The script that specifies the size and attributes of the target window goes in the head of your main HTML page. Here's an example page:

<html>
<head>
<title>JavaScript Movie Page</title>
<script language="JavaScript">
<!-- hide from old browsers
function openMovie(url) {
windOptions = "toolbar=0,location=0,directories=0,status=0," +

"menubar=0,scrollbars=0,resizable=0,width=320,height=240";
moviewin = window.open(url, "movie", windOptions);
moviewin.focus();
}
// -->
</script>
</head>
<body>
<a href="javascript:openMovie('HugeMovie1.htm')">Movie1</a><BR>
<a href="javascript:openMovie('HugeMovie2.htm')">Movie2</a><BR>
<a href="javascript:openMovie('HugeMovie2.htm')">Movie3</a>
</body>
</html>

The JavaScript function openMovie(url) opens a 320 x 240 window with no distracting bells and whistles: no Back or Home buttons, no What's Cool button, no scroll bars, no nothing; just a simple window. The window is named moviewin , and it's opened on top of any existing windows. The window is created only when someone clicks one of the movie links. It's filled with the specified HTML page, which should contain an embedded movie.

The movie links can be text, as shown in the example above, or GIF or JPEG images. To see an example of this approach, load MultiMovie8.htm .

What it Does

If viewers have QuickTime 4 or later, this page displays Letsgo.mov for half a second, then loads HasQT.htm in the current browser window.

If viewers don't have QuickTime, the browser should alert them and offer to take them to www.apple.com/quicktime/download/ .

If viewers have an old version of QuickTime, they should see UNeedQT4.qti for a few seconds, then be automatically redirected to the GetQT4.htm Web page.

If viewers get impatient waiting for the redirect, those with QuickTime 4 or later can click the Letsgo.mov movie and jump to the main content page; those who need to get QuickTime can click the text link to the GetQT4.htm page.

How it Works

If viewers have QuickTime 4 or later, the QuickTime Plug-in will correctly interpret the parameters
QTSRC="Letsgo.mov"
CONTROLLER="False" AUTOPLAY="True"
QTNEXT1="HasQT.htm"
to load Letsgo.mov , play it automatically without a controller, then load HasQT.htm in the default browser window.

Letsgo.mov is a one-frame movie only 1 kilobyte in size and a half-second in duration, so this should happen in the blink of an eye. If not, viewers can click the Letsgo.mov movie; the QuickTime Plug-in will interpret the
HREF="HasQT.htm"
parameter and load HasQT.htm in the default browser window immediately.

If viewers don't have QuickTime, the PLUGINSPAGE parameter should cause the browser to bring up an alert window offering to take them to
www.apple.com/quicktime/download/ .

If viewers have an older version of QuickTime, all the <EMBED> parameters will be ignored except SRC , HEIGHT , and WIDTH , so the plug-in should display GetQT4.qti instead of Letsgo.mov .

GetQT4.qti is an image that directs viewers to the QuickTime download site.

The <META HTTP-EQUIV="Refresh" CONTENT="8;URL=GetQT4.htm"> tag in the page header should automatically redirect viewers to the GetQT4.htm Web page after 8 seconds, whether they can see UNeedQT4.qti or not. This also acts as a fallback in case the browser ignores the PLUGINSPAGE parameter.

The 8-second delay before the refresh makes sure that viewers who do have QuickTime 4 have ample time for Letsgo.mov to load and play, even if there's congestion on the network.

The manual link at the bottom of the page gives impatient viewers a quick way to the download page if they don't have QuickTime, and it acts as a fallback in case the browser fails to execute the automatic refresh.

Despite being only 25 lines of HTML, this page provides belt-and-suspenders redundancy. I have yet to see it fail under any circumstances.

GetQT4.qti and Letsgo.mov can both be found in the SpecialDelivery folder of the CD. You're welcome to use them on your own website or CD.

Variations

The example page redirects viewers who have QuickTime 4 to a page named HasQT.htm . You should edit both instances of HasQT.htm to point to your main content page.

The example page redirects viewers who need QuickTime 4 to a page named GetQT4.htm . This is a short Web page which explains that the viewer needs QuickTime 4 or later to experience your website, explains that it's a free download, and includes a link to the Apple download site. It also has help for people who already have QuickTime 4 but were redirected because of a browser problem. GetQT4.htm is also in the SpecialDelivery folder of the CD. You're welcome to use it as-is or edit it to look better in your website.

Alternately, you can edit the example to point to your own version of a download page, or to an alternate version of your main page that doesn't use QuickTime content, or directly to Apple's QuickTime download page.

If you're redirecting viewers without QuickTime to a non-QuickTime page, delete the PLUGINSPAGE parameter from the <EMBED> tag.

It's also possible to use a combination of JavaScript and VBScript to detect QuickTime, but it's somewhat dependent on the user's browser, operating system, and QuickTime version. For details, see "Useful JavaScripts" (page 139).