Hello. My name is Eric Blaanpie. I'm a member of the QuickTime team, the interactivity group. I'm going to talk to you about what we've got going on in interactivity. First off, we'll go into what we're doing in interactivity. A little later on, we'll talk more about the really new stuff.

When we talk about interactivity in terms of QuickTime, we're talking about the ability to provide a much more active viewing experience than what you'd get in a TV or a linear video or a stream or something. Interactive movies tend to hold the user's attention in ways that some other things don't.

Interactivity is a great teaching tool. People get their hands on the samples and examples and whatnot. QuickTime interactive movies have a great advantage of playing the same on whichever platform you want. You've got a self-contained thing. You're not relying on the JavaScript interpretation in this or that browser on this or that platform or anything. It's a single movie.

Um, Interactivity provides a great way to customize the user experience, including branding and whatnot. In many cases, as you'll see as we go on in this talk, we're talking about QuickTime's great strengths for integrating various kinds of media. Many other companies do some of the kinds of media that we do, but nobody lets you throw it all together into really rich, well-combined, almost like little applications. Finally, Wired Actions are a big key to what goes on in QuickTime interactivity. The Wired Actions are the way that we let you hook up and manipulate the various properties of any kind of QuickTime media.

We talk about media integration. We have basically a few very interactive track types that you rely on for most interactive movies. The sprite track is for bitmap images that are used as sprites and they can be animated various ways and they also can have wired actions put on them to turn them into buttons or whatever. QuickTime VR is interactive in that you can, I mean, it's all about what the user does with it, panning it around and zooming it. Also, with the hotspots you can add more wiring.

And Macromedia Flash provides a really great way to bring interactive movie elements into your movie. Although QuickTime's got plenty of other tracks, a few of which I have listed here. All of these things can be thrown together and we have all sorts of ways to manipulate their various properties in the appropriate ways.

Getting to Wired Actions a bit, you can sort of think of it as QuickTime scripting access, although it is not a scripting method and the application that creates the Wired Actions can use whatever kind of scripting interface it chooses to and then compile to the Wired Actions. For the user, it's seen as the way to script a movie and make it do things.

Like I said, we provide access to many of the properties of QuickTime media, track properties for media that make sense like sprites, the individual sprites or whatever. And things like VR, you can set pan angles and all. We have actions to manipulate Flash media. And it's a comprehensive growing list. We have a lot of stuff.

It's been in here for a while and we keep adding to it. In fact, here's a partial list of what we've got. The blue ones are the new ones and there's a few more and still some more. If you'd like to be able to read that, you can go off to the developer documentation and find a readable version.

Now, what's new? Cubic VR shipped with QuickTime 5. We also have added Media Skins. Macromedia Flash 4 support, whereas we had three before. New Wired Actions to go with a lot of these things and also do stuff that we weren't doing at all before. Server Communication via QT lists.

Oh, we're going to Cubic VR. There's more on the other stuff. The big deal about Cubic VR, we've had QuickTime VR for a while, but the panoramas didn't let you look at the ceiling or the floor. And if you did a very high field of view, they were pretty inefficient.

Important thing to realize by Cubic VR is that they work just like cylinders. Your application doesn't need to know anything about the fact that it's playing a cubic pano instead of a cylindrical pano.

and turn that into Cubic VR movies. There's been some third party work and we have sample code called the VRMakePanel library for exporting Cubic VR movies from your application. So let's go over here and show some Cubic VR.

We've got a rather fresh topic here, the Apple Store shot in Cubic VR in a case where

These two were provided by Jeannie Fitzgerald of Axis Images. And you know, it's got beautiful high-speed performance. It's really slick and you're completely in the place. There's no blocking out there. That's it for that demo. Go back to slides.

So, third-party authoring. We've got RealViz has got a Stitcher, which they previously had on Windows. They've done an excellent port of it to the Mac. It's working very well on Mac OS X and 9. It's in beta right now and should be shipping quite soon. VRWorks has had a tool out for doing all sorts of VR authoring for a while now.

Their new version supports Cubic movies if they've been authored elsewhere to add various--put them into multi-node movies, add hot spots, do things like that. And the Squamish Media Group's tools for doing interesting wired things with QuickTime VR movies work just as well with Cubes and some of them have been upgraded to take advantage of Cubic things like tilt parameters. And, like I said, RealViz is working well on OS X as shown in the screenshot there. And then we'll go on to Ken Turkowski who's going to talk about our support for adding it to your apps.

Thank you, Eric. How many of you guys out there really love getting code from the developer CDs, trying to get it into your applications, and get it running and linking? I didn't think so. It tends to be a lot of work. First thing that happens is that you go into Code Warrior and it needs to convert the project to get it into a newer project. Then you're missing some headers. And then you have to go around finding them. Well, I hope to change that experience for you today.

Sometimes I like to pretend like I'm a mathematician. And one of the things that mathematicians tend to do is they'll do proofs. Proofs of one theorem. They'll say theorem 201 is true by virtue of theorem 200. Well, what I want to do for you guys today is to give you theorem 200 so that you can go on to 201 and continue on with your value added.

Eric Blazik, Professor of Mathematics, University of Michigan What I'll be talking about today is some sample code that makes cylindrical and cubic QuickTime VR panoramas very easily and something that you could easily add to your application even today. It takes us sources either G-Worlds, picture files, or movie files. The other thing I'm going to be talking about today is an application that's been built using this sample code. This will make Cubic QuickTime VR movies either from cube faces or from equirectangular spherical picked images.

Now the sample code, as I mentioned, makes either cylindrical or cubic QuickTime VR movies. It's library quality. By that, I mean that it has a rich interface with enough parameters in there so that you don't have to actually go in and modify that code. It's got one header that you have to interface to. You just drop the other file into your application, link, and run. It's designed to be usable as is.

Now here's what the sample code generally looks like. There's a lot of different kinds of interfaces, but they all take the same general form. You take a VR movie, picked, or G World, convert it into a QuickTime VR cylinder or G World. You can also make a cubic panorama. If you happen to be making a cylindrical panorama, you have the choice of either making the classical style rotated panorama or the more modern style non-rotated panorama.

There is a slight difference in the performance of the non-rotated panorama in our current rendering engine. But you can make it either way. There's also some code in there for creating 1.0 panoramas, but we don't encourage people to make those panoramas anymore. Now in this interface, there's basically five parameters. The first one is where most of the complexity is buried, and that's where you set the parameters, the pan, tilt, field of view for the initial view, the minimum, maximum, all sorts of things like that. The rest of the things are the same.

You're going to have the sources. You're going to have the source picture or tiles or something, the hotspots, the fast start tiles if you want to include them or not. If you don't have them, you set those to null. And then the final thing is where do you want to save the movie. So this is a particularly simple interface, very easy to use.

And the MakeCubic utility application was built on top of that. This uses that code and beyond what that has to offer, it's added a few additional features. It has the ability to convert from an equirectangular spherical pic. Some of you out here may not necessarily know what that is. It's sort of like a Mercator projection of the Earth, where Greenland is huge and the North Pole is extended to a whole line on the top instead of a point.

There are some stitchers that produce that as a native output. Helmut Dersch's Panorama Tools being one and RealVis's Stitcher being another. I think RealVis will also produce a Cubic VR movie directly, too. But regardless, if you have that equirectangular pic, you can convert that easily. The other thing that's been added to this application, beyond that which the sample code does, it will compute an optimum minimum and default field of view. Now, what do we mean by an optimum field of view? I consider some optimum to be when there's no pixel zooming.

So if you have one-to-one pixel zooming, that's sort of like one optimum. It's one place where you can get the maximum resolution and the maximum field of view, too. The next thing that's added in that application is that preview is generated to be independent of the resolution of the original panorama. So if you have an extremely high resolution panorama, such as that made by the Panoscan camera, you don't necessarily want to have a panorama that only has one quarter of the resolution for your preview. You want to have something much smaller.

So here you get to actually choose what the resolution is, totally independent of the resolution. Now, VRMakePano has some functions that we don't make available in MakeCubic. First of all, it won't make cylindrical panoramas. This is an application that's just made for making cubics, so we aren't including that.

The other thing is that it doesn't allow you to make URL hotspots, only undefined hotspots that you would then later have to define in your HTML code. But if you want to make your own application out of the VRMakePano sample code, you can do that, and you can have URL access to that. So now I'd like to go to demo machine number two and demonstrate the MakeCubic software.

This has been recently carbonized so it can run on OS X. As well as OS 9 and 8. Now, there's really just two menu selections here. One of them is the Convert menu, and that's the one where you'd be doing most of your work. There's two sections to it. There's the Source File Specification on top, and then there's the Movie Settings Specification on the bottom. So first, let's choose a panorama.

I'm going to choose a panorama right here, which was, this is an equirectangular spherical pic, which was made by Dennis Glickman in France. And we'll open that up, have that selected. You'll see it appears right there. We can change the compression settings. I usually like to set this to... I usually like to set it to 40%, but 39 is close enough.

We can choose to get grayscale for the preview or blur the preview. Now notice over here, this section here for generating the preview says pixels per degree. Some people with panoramas, they'll say, "Oh, I have a 10,000 pixels per inch panorama." Well, pixels per inch doesn't make any sense for a panorama. What really matters is the pixels per degree. And as it turns out, pixels per degree happens to be directly proportional to the focal length of the lens that you use.

So here we specify that. That can be either an integral number like 1 or a fractional number like .7 or whatever. I tend to like something between 1/2 and 1. So we'll generate this. Let's not blur it and make a grayscale version. I don't have a hotspot. File for this. So we won't select that. Down on the bottom, we can select our default pan and tilt. So this would be the default pan and tilt.

This is the pan angle. Here's a default tilt angle. And for the field of view, over here, this has been automatically computed based on the window size and the resolution of the panorama. That can be overridden by clicking off this optimal FOV for the window size. So if we change the window size to be, say, square, 480, you should see the field of view change. And what that's trying to do is to set the field of view so that your zooming is going to be exactly 1:1 on the pixels for the default field of view. And for the minimum field of view, that will be 2:1.

So, another feature that's over here is Tiling. Now, a lot of you are familiar with cylindrical panoramas where you can specify the tiling to be 24 by 1 or 48 by 4 or something. We can do a similar sort of thing with cubic panoramas, only this tiling specifies the number of tiles to be used on each face.

Here we can click the auto tile and in this case it likes it as a 1 by 1 tiling, so we'll just go with that. But we could change it to 2 by 1 or whatever. Anyway, without further ado, let me make this panorama. It automatically chooses a file name for me. I can override that if I like.

And here it's converting that equirectangular to each of the faces at the moment. Pretty soon it will flash by the print. So, we have the preview track and then the regular track and hopefully in this window we now have a panorama. This is tilted 50 degrees up, zoomed in. This is at the optimum resolution so that if we zoom in anymore we're going to see the pixels blow up. But it's limited to be 2 to 1.

Now, inside Make Cubic, The first thing you need to do is set your preferences. You can set your preferences for what you'd like your compression parameters to be. You can set what the optimal field of view would be. So if you don't like 2:1 for minimum, you can change that so it's automatically set that way. And there's a number of other parameters you can set as well. So let me show you a different kind of panorama, one that's made from faces. So here I have a number of faces, six faces of a panorama that was captured by Janie Fitzgerald.

and notice how that appears over here. The program has parsed this to determine what's similar between the file names so it doesn't take up a lot of space over here. I do happen to have a hotspot set of faces over here too, so we will select those as well. You can see the faces are selected.

And maybe I'll make this to be 640 by 480 instead. And leave that like that. So now, when this creates it, it will automatically suggest a file name for me. Reading all the picture files in, creating everything, there is the freshly made panorama. Very easy to use, very powerful, and it's free. So I'd like to go back to the slides now.

With a message, it's easy to make your application write QuickTime VR files, either cylindrical or cubic panoramas. You can download VRMakePano.c code this afternoon, link it in with your application tonight, and ship it tomorrow. So I'd like to return the presentation to Eric. Okay, Media Skins, an exciting new QuickTime 5 feature. The essential idea behind a Media Skin is it lets you have an arbitrarily shaped movie.

The big deal here is that we're skinning the media and not the player. We hear a lot of talk about skins in various applications, but by skinning the media and not the player, it means that your content is customized so that every time it plays, regardless of how the user has their QuickTime player set up, it's going to look the same way.

Your message, your branding, whatever, travels with the media. And if you make a change and next week you want it to be a little bit different, you just change the movie file and it's different Again, you don't have to get anybody to download a skin for the player.

It provides a great branding opportunity. Whatever goes with your media is always there. And beyond the arbitrary shape of the movie, you've got the full interactive tool set of QuickTime that we're talking about here to make really intricate and interesting movies. And we'll be seeing some examples. So we're going to go on to Demo 4.

Okay, let's see a basic skin movie. Here we've got a skin. Again, this has branding all over it. It's a sprite movie with a video track. They've built custom controls in it. and every time this movie plays in whatever version of QuickTime player, this is how it's going to look. It's a locked and pre-designed presentation. We get a little fancier than that, or in some ways.

We've got a... There's a skinned movie here where there's a separate navigation bar to allow you to Select what movie you want. We've got various wired actions going on. And then upon clicking on something, we open a related skinned player that obviously goes with it. to give you a little more ability to give your look to your content. We'll look at this movie a little more a little later on. So that's it for the demos on skins just now. Let's go back to slides.

The new wired actions, we've got all sorts of stuff going on. Text tracks have gained a lot of interactivity in QuickTime 5. We can take user input, we can have them be manipulated via scripts, we can enter text, we can trap the key entry much better than ever before, so you can do a combination of keyboard entry from the user as well as script-based stuff. We've got a lot of actions for setting the styles and the fonts and the colors and hypertext colors and whatnot. Text tracks are very interactive now in QuickTime 5.

We have some new application messages, which primarily are seeing use in QuickTime Player, but these are not specifically targeted just towards QuickTime Player. Basically, the wired action is a simple thing which says send the app message with a number to say which app message it is. The ones that make a big difference to the content authoring community, especially once we've got skins out, are the enter and exit full screen, which people wanted a lot, and the close window, that's the one that has lots to do with skins.

By the time you get rid of the OS's window controls, you've got to start adding some in your own interface that you're building as a content creator, so we've got that. As an application developer, you could easily take advantage of this. You could pass different numbers than what we've got and have your application catch them.

You could also have a user who's going to be in the middle of the screen, and you can just go ahead and add a number to the app, and it will automatically get a message that We've added things for doing a better job of making movies that work well on the web.

We've got network status and allowing you to check on whether the network's up or whether -- I forget exactly the number of steps, but you can find out before you make somebody's modem dial, you can find out whether or not they're online or not and ask them if they want to go online or things like that. And movie load state is very useful. We can get all of the different steps of loading an HTTP movie.

We can get information about that so you can know when the movie is ready to play all the way or when it's completely downloaded or whatever. With VR, we've added a number of new things which are pretty cool. We basically now have enough actions in there to reproduce the whole controller so when you create your skin movie or whatever, you don't need to worry about the fact that you don't have the VR controller around anymore.

You can create buttons for all of it. Or even if it's not skin, you want to just do your own artwork, we've got that in there. They also have the ability to enable and disable hotspots, which is neat. You can have any particular hotspot be turned on or off.

We've got a bunch of new math functions, sort of things that some people had created creative workarounds for before but now they're built into QuickTime. And just a whole lot of other things, like setting base and treble and it goes on. As you saw when I showed this slide earlier on with the zillions of actions, we added something like 100 new-- actions.

Mac Media Flash support has been upgraded in this release to 4. Combining Macromedia, Flash, and Video is a pretty interesting thing to do and QuickTime is really the best way to do it. You can layer it up in sophisticated ways and produce things that you couldn't do anywhere else. We've got the full MP3 audio support. Text input is another approach to having text input besides our text tracks. We've got loading movie and loading variable.

A QuickTime movie can have multiple flash tracks, so you can get involved in intricate things there that again are different from what you might be doing just in Macromedia Flash. And we have a number of new wired actions that are specifically in there for working with flash tracks. For instance, we can get and set the text in a flash text field. And another really interesting one is the ability to trigger a flash button via a wired action, enabling you to have very complicated and Eric Schultz are the developers of QuickTime 5.

The Flash action scripts, which you trigger from your wired content from elsewhere in QuickTime. Also, you can do pretty interesting things with Macromedia's Flash tool itself. With Flash 4 added export for QuickTime movies and that still works quite well on Flash 5 and there is no need for an upgrade there to handle the new QuickTime 5 support. So now we'll look at some Flash movies on Demo 2.

Okay, so these are the Swift files here, the actual exported movies from, um, The QuickTime icon is a feature that allows you to play the game directly in the Flash player. Drag and drop one of them onto QuickTime Player. The importer creates a new movie right away with the Flash track. This one's got a lot of Flash 4 sort of features like text input, and what else? It's got some ActionScript stuff that's doing calculations and all based on the input there.

Right out of the box, we're taking the Flash 4 content and making it work completely. Another example of that is duplicating movie clips. Movie clips are Flash's way of having a hierarchy with unslaved time bases. These things just work exactly the way they do in Flash. And Flash 4 added support for making it really easy to drag elements around, so that's working great too.

Server Communication. Well, we've added the QuickTime lists, QT lists to QuickTime 5. QuickTime lists are basically hierarchical data structures. You've got various elements and attributes which can have children and all. It resembles XML somewhat, but it is not XML. It's an internal thing. You can have multiple root levels and whatnot, which you cannot do in XML. There's one QT list per movie or track.

So you can have multiple QT lists in a movie. We are using XML as an exchange format to send these to and from servers. In order to make them work as XML, we do add a root element called QT list because a QT list structure in a QuickTime movie can have more than one root element.

It's important to note that QT lists are very useful for things that are not related to server communication. I'll show you some stuff about that in a little bit. We have a lot of wired actions in there to manipulate these to where the list can be internal to a movie when you load it.

You can go on to manipulate it via wired actions. You can load them. You can send them back to the server. You can walk through the hierarchy and find out things about them and do various stuff. Let's have some QT list demo. This will be demo 4 again.

QT List movie that's not doing too much in the way of, or any external communication. We've got this simple little kaleidoscope movie. Now this is just doing fun little sprite things in order to have something to build a list and keep track of. You'll see over here on the right hand side, I'm building a list. Each thing that gets dragged winds up adding an element to the list. As I change them, the appropriate elements in the list get modified.

If I reset what's on the screen, I can read the list and load it. The movie does not store everything in the list. It just stores the first ones that get dragged. The rest is generated from the list instead. You can delete them and have it delete the item from the list.

So this is sort of an example of where you might want to do some sort of record keeping within a QuickTime movie. It's a much simpler way than having a big long list of variables somewhere basically taking care of it for you. Oh, and this also, the text track over here on the right is taking the content of the QuickTime list and using some copied XML Create XML from the list and put it into this text here so that this is what it looks like in an XML format. And we can scroll the text field now. That's another new QuickTime 5 text action. This is a sprite track over here sending events over to tell the text track to scroll.

Let's go back to the list player again. I showed this very briefly when talking about skins, but this guy uses a QuickTime list. So there's something called Movie List. It's written in XML. Each movie in the entry has a name and has got a description, a bit of text, I call it a paragraph, it didn't wind up that way, a pointer to a thumbnail, and a pointer to the URL. The source files that are getting referenced are all down here.

When I open the Nav Unit It reads in the list and then goes and finds out what the thumbnails were and sticks them in. And when someone has read the list, it's got all that data that was in the XML file, now in a QT list format in the movie. And it can use that to find out what text to put in for the brief descriptions for the movies. It uses that to know what URL to call for when we open up the movie. And change it.

Similarly put together, which has the right name, that's what will get fetched locally. This is using a get list. And we have a different set of movies, something a little more up to date than what we had before. And again, just switching around these switches which ones they do.

So this enables you to-- This enables you to put effort into a fancy interface movie or set of movies, which might not be the sort of thing which is worth doing every week on a website or something, but you can easily change the content that this thing is using without having anything to do with the QuickTime movie. You upload new content, you edit the QuickTime list, and the movie suddenly behaves differently. Eric Blazik, Ken Turkowski This movie is loading a child movie into the window there to show whichever content.

There's that close action I was talking about. The other thing you can do is with that list, you can create another interface that... reads the same list and uses it in a different way. This is a flash track which has dumped the names of the movies or the descriptions into flash text fields.

The roll over on the right is the paragraph rather than the brief description. And the movies, rather than using the little thumbnails we've used, the actual rolling movie's in there, and it's all being masked nicely with the flash alpha channels. And we can click on those and we get another, a different player which is related to this one.

So this is a way to repurpose, in a way it's repurposing content or it's just providing people with different options for what look they want or anything like that. It's showing some versatility in the QT list here. Or the approach to making a movie which relies on lists to figure out how it drives.

I've just come across something that I didn't talk about before. We were talking about new messages. We've got the thing for going full screen and exiting that's in here. We've also got the close message. Let me show you another Flash movie. We've got a Flash track and we've got some sprite stuff down here that's made to look like it goes together. We've got editable text in here. I'm reading that URL and using it to load a video.

We're going to load a movie into a child movie track here. And in fact, that can be local or not. We can use a relative URL.

and Eric Levy are the developers who created the new feature called the "Scrub" button. The "Scrub" bar is used to set the length of the movie. Let's get into another pretty interesting demo. Back to QT List, sorry about that.

Let's go over to Michael Schaff's small hand site where we have a movie that's up right now.

When I enter something, it is sending it off to a server that's at Totally Hip's place. Totally Hip, the publisher of LiveStage, this is built in LiveStage, and it will in fact be... The source to this will be on an upcoming LiveStage tutorial. We can scrub with the movable text track here. Over here you see the syntax that's being used to send messages back and forth. You see the actual QT list.

You can change the slider here for how quickly it goes and talks to the server to find out what new messages there are. One could imagine going a lot further with this. You could easily build a chat kind of movie where your video stream is on one side and then that's there. So that's, I mean this is the first in a server communication demo we have here. I mean this one gets into some pretty interesting options. So let's go back to slides for a little while.

Integration of media, as I said earlier, is a really, really big deal with the... I must have been somebody out there, okay. Like I said before, QuickTime does a lot of interesting individual things and we even have competition on some of those things, but nobody lets you put it all together to make these really complicated, or not so complicated demos, but nobody lets you add it together the same way.

These complex movies have such a power to hold the user's attention. You can build quizzes, you can build games, you can do all sorts of things. You can wind up with self-contained interactive experiences that play anywhere. You can play them in the player, you can play them in your, in a browser, you can play them in your own application and you can be pretty sure that they're going to look the same all over the place in different places. The platform and browser issues are much less of a deal than other ways of doing this sort of thing. So now we'll go back into demos and look at some highly integrated movies. This will be on demo 4.

Uh, okay. We've got another demo involving Janie Fitzgerald's work. This is also, uh, collaborators on this were Robert West and Michael Schaff. Um, it's Robert's interface, Janie's VR, and Michael's, uh, wiring. We've got rollover buttons here, a nice skin. We've even got some help text on your hotspots at times. This is another movie which will be put together as a tutorial for the new version of LiveStage. It will be available on their CD eventually and for LiveStage 3 as well as probably on their site.

We've got a sprite-based compass up here, which is reading pan angles from the movie and updating. We've got the sprite layers, got these buttons which are... In some cases, communicating to the VR and telling it to move around. We can go full screen. The mask that overlays the panorama is done with a nice alpha channel, so it's really smooth and rounded.

And again, it's customized the user experience to this content completely. It's a very appropriate way to be using this stuff. Oh, and there's directional audio. Paying attention to the pan angle for how the audio is doing. A very nice, well integrated, highly interactive experience. We do a lot of things, people do a lot of really fascinating things in, um, In the browser, this is a Greenpeace.org site done by EC Media up in Vancouver. It's popping different QuickTime movies into different places to all work together. We can, we've got a QuickTime VR movie here that's unwrapped and flat. It winds up with a panable, zoomable map. And we can look at the map here and find out where the different hotspots are.

That sends a message to the QuickTime movie up here. The top half of the browser window is one movie. The bottom half of the control bar and all is another movie. The movie up here is the panorama. There's also a picture track there, which is making these other things show up on the side, the images. Let's find another one. We click on it. We get yet another movie. This is all one QuickTime movie. You know, HTML here. There's a slideshow. We can leave it on autoplay or we can choose which slide we want to look at.

We can speed up, slow it down. The text is drawn with a text track. We've got to close here. That actually is doing it via JavaScript so that we can tell the browser to close the window. And we've got things like the zoom in and out. Oh, and they've got the ever popular compass down there.

In this case, the panning movie is communicating with a different movie for the place where that's going on. So you're seeing intermovie communication between a lot of different movies here, which is pretty cool. I believe we can jump to new nodes either via--

Another EC Media demo.

This is sort of a distance learning example. We've got a gentleman here from Electronic Arts talking about the ways that they get their, they use academic research to figure out what to put into their games and all to get new ideas. And he's talking about a topic in a very general sort of way and he'll occasionally talk about topics which are interesting without going into greater detail, but we can go and click on those to get more information about the topic he's going on about. It's got illustrations and text and all. And the background movie has paused.

When we say back, the background movie picks up right away. This is done with... With QuickTime movie tracks. These are movies which are embedded inside of other movies, which makes for a lot of flexibility in saying, figuring out the point that this movie is playing at doesn't change the point that this movie is playing at here. There are not two tracks in the same movie.

The, uh, and another one from EC Media. These guys are very creative, doing a lot. This is an interface built just about entirely out of Flash. The, um, they've got a lot of rollover stuff here. They've got draggable embedded movie clips and, um, the sort of stuff that you can do with a lot of Flash scripting.

Uh, and they've got a movie that's built inside it. Um, this movie, I believe this thing is built mostly in Flash with very little, uh, work from elsewhere. And this is obviously linear video, but you can go and set it to play slow motion, which is extremely difficult to do in Flash, which is a frame-based format rather than a time-based one.

There's no way of saying play at whatever speed, but in QuickTime all you've got to do is say play at, set the rate to .5 or whatever. Um, and, uh, Meanwhile, their slick rollover behaviors work fine and are uncoupled to the time base because that is taking advantage of some of the really useful Flash aspects. And let's look back to talk even more about the good old list player.

Just to talk about it in terms of integration of media, this movie here has got A sprite layer in the background which contains the artwork and this basic button here. It's got a text track down here in this opening which we use information from the rollovers to put the information into.

And each one of these is a small child movie which has loaded from the direction of the QT list. When we click on these, We first open up the second movie with a get URL action and then send a message and do a little inter-movie communication, send a message to the movie once it's open after paying attention to make sure it opened up all the way and tell it what movie it needs to load.

We also have used a new QuickTime 5 action which lets you check on whether a movie is active or not to dim or highlight the background movies. We've got, again, a wired sprite layer in the background to set up the buttons and whatnot and a movie track that's in the foreground here. We've also got another hidden movie track which... is being used as a sprite override.

Any QuickTime sprite can use any track that's available in a movie to override its image. In this case, it would be hard to have the perspective of the shadow and all this stuff be a draggable sprite. So what we've done is we've got a... A little linear movie of a thumb moving, which is loaded in a child movie and hidden and then used to override that sprite. The beauty of that is that it becomes time independent of everything else.

The length of this track does not have to sync at all with the length of this track, which it's not going to because we can change that so often. So, yeah, one of the great things about the movie track is to have unslaved time bases, which don't happen elsewhere.

That's unfortunately sort of winding it up. Thank you very much.

I guess there's a couple of slides left. Right, the feedback forum will be tomorrow afternoon at 3:30. We'll be there to hear everything you've got to say. Please do attend. We want that input. And in the fall, don't forget QuickTime Live. Anyone who's really interested in QuickTime needs to be there. It's got separate tracks for those interested in API level development, content development, and the marketing sort of issues. And it's a really fun event. So thanks a lot.