Recording streaming video from abc.com

[slammer120]

I'm trying to record streaming video from abc.com and am having an unusual problem. I saw WM Recorder 11.3 was rated pretty high and tried the demo version that allows up to 5 minutes of recording. However, after I was done, I noticed that only the lead in commercial (an .flv file) was recorded and the show which immediately follows did not record. The video opens up in a separate window so I have no idea what the URL for the actual video is. Has anyone out there had any success recording the abc.com videos?

[oldfart13]

No sweat using:

http://www.applian.com/replay-media-catcher/index.php

Just did the Traveller promo. Too bad this program can't do it

http://nuclear-coffee.com/php/products.php

as it is a nice proggie. Perhaps if you suggested it to them they can add the site with their next update....

[slammer120]

No joy: replay-media-catcher shows the URL of the lead-in ad but never records beyond the few seconds of the ad. Even though the show runs in the same window, none of the actual show ever records. I also tried this app on Quick Time and it never showed the URL of the movie trailer as it played. Is there anything that will simply record a video stream without caring about the URL since I cannot find the appropriate URL?

[Baldrick]

They are doing everything to make it difficult to record the video...so no you will probably not find a very easy method to record it.

You could use a desktop stream recording tool like snagit or see our tools section under desktop/screen capture . You might have to disable hardware acceleration to be able to capture.

[dnix71]

Desktop screen capture is probably the only way. I'm on a Mac and had no trouble watching after downloading a java applet. But- there is no cache of the vid, even if I manually change the settings.

[Seeker47]

No sweat using:

http://www.applian.com/replay-media-catcher/index.php.

Asked this in another thread, never got an answer: what is the relation between this program and the earlier program ScreenCast AV . . . other than Applian ?

[oldfart13]

No joy: replay-media-catcher shows the URL of the lead-in ad but never records beyond the few seconds of the ad. Even though the show runs in the same window, none of the actual show ever records. I also tried this app on Quick Time and it never showed the URL of the movie trailer as it played. Is there anything that will simply record a video stream without caring about the URL since I cannot find the appropriate URL?

What exactly are you trying to record? Maybe I can check from here....

[slammer120]

I am trying to record selections from abc.com - "According to Jim" episodes and the like. I did have success with the CamStudio application but I need to work on Audio/Video sync and I must use my 3GHZ box or the video is quite jerky. Any of the applications that are looking for a URL cannot see the URL used for the video or only record the ad at the beginning of the file.

[Squash]

@slammer120:

I just downloaded one episode of "According to Jim" from ABC. This episode is split into 16 separate flv files running from about 3MB to 6MB each (about 1.5 to 3 minutes). Total file size is 66.8MB. If you copy the files out of the browser cache, sort them by the time they arrived, and rename them sequentially, then you could make a playlist and watch them one after another. This would probably be the easiest way. Alternatively you could join them. I've never done this with FLV4/VP6 files (that's how GSpot identified it) but a quick search turned up a couple of posts on Videohelp that might help if you want to go that way.

Here's a sample URL for the opening segment of the episode if you want to download it:
http://a.media.abc.com/video/icf/ATJ_612_AnyManOfMine_Sneak_Peek_HD_1322088_16x9.flv

I first tried using the VideoDownloader extension for Firefox. No dice ("Not a valid URL" or somesuch). The Unplug extension gave me a list of URLs for the segments, but they were wrong (if you downloaded one you got a 3.2KB file of garbage). Replay AV 8 also bombed out, so I got the files from Firefox's cache. (I didn't think the first three methods would work but I tried them anyway just to confirm it). The URLs for the various segments are there in the cache as well, in a different section, but you don't really need them since the video files will already be there.

As Baldrick said above, they ain't making it easy. And it's about to get harder. ABC is moving away from Adobe and has introduced a new player on their site from Move Networks based on On2's VP7. It will allow for good quality playback at fullscreen and can use hardware graphics acceleration. See here if you're interested:
http://www.broadcastingcable.com/article/CA6429850.html
http://crave.cnet.com/8301-1_105-9704105-1.html

I downloaded an episode using the new player. Rather than using Firefox's cache, it cached the episode in one of its own folders as 549 files of 142KB each, with extensions of .qss. I don't know if it would be possible to reconstruct a playable file from these.

For the present, they allow you to use the old flash player if you want. That's how I was able to download the above file. It's probably more trouble than it's worth, though, unless it's something you really want to have. Maybe someone else will have an easier way.

If you're need to know how to locate the files in your cache, PM me or just search around this site. This post is long enough as it is.

Good luck.

[oldfart13]

Sorry, can't help you further. I get this message:

"Only viewers within the United States can watch these full-length episodes"

[snafubaby]

They are doing everything to make it difficult to record the video...so no you will probably not find a very easy method to record it.

You could use a desktop stream recording tool like snagit or see our tools section under desktop/screen capture . You might have to disable hardware acceleration to be able to capture.

I have been trying to download from abc.com as well. i never used snagit with hardware acceleration off. Can you explain what disabling hardware acceleration does?

[Baldrick]

snafubaby: http://en.wikipedia.org/wiki/Hardware_overlay

[djbigperm]

Does anyone have an update on this? Anything come out that can capture Move Networks Streamlettes?

[olyteddy]

Plug your video card into a VCR...I actually have plgged my Laptop vid out into my Hauppauge PVR USB2 and recorded ABC streams.

[ronmiracle]

Plug your video card into a VCR...I actually have plgged my Laptop vid out into my Hauppauge PVR USB2 and recorded ABC streams.

Its mostly the protocol that the problem qith the Quantum Streaming they use thw xml catalog to "get" (the form command) the program sequence the the .js scripts kick in with xlontech and move media,w88,on2 vp7 decoder,and then the .qmx which probably uses the decoder to read the code that tells the key url which .OGM clip to play.To my thinking the .qss
may hold the .OGM ,OGG CLIP as when some were played in the kmplayer
came up with the 555580612_684512704.ogm code streaming as a banner.Heres the .qmx file output as played by the Kmplayer.Clearly its asking for the .ogm file as well as the vp71 decoder.This is the binary out put.--------------------
BINARY INFO
--------------------
FileName : url_key.qmx
Data :
0D 0A 51 4D 03 00 4D 44 8A B2 36 83 DC 41 88 0D QM MD 6 A
0A A8 8B D2 94 4E B8 00 00 00 00 15 BC 0F 47 FF N  G
FF FF FF 01 00 00 00 0D 0A 05 00 00 D0 20 02 00
0C 0C 30 37 30 39 32 37 30 31 D0 20 00 00 00 0C 07092701
00 C7 0D 0A 34 00 4F 67 00 00 02 44 AC 44 00 56 4 Og D D V
50 37 31 F0 00 88 00 10 77 00 EC 2F 01 09 00 37 P71 w / 7
0E 3C 00 4F 67 00 00 02 44 AC 44 00 56 50 37 31 < Og D D VP71
40 01 B4 00 10 9E 00 EC 2F 02 09 00 82 15 53 00 @ / S
4F 67 00 00 02 44 AC 44 00 56 50 37 31 E0 01 0E Og D D VP71
01 10 11 01 EC 2F 03 09 00 8D 1B 64 00 4F 67 00 / d Og
00 02 44 AC 44 00 56 50 37 31 E0 01 0E 01 10 70 D D VP71 p
01 EC 2F 04 09 00 6F 23 73 00 4F 67 00 00 02 44 / o#s Og D
AC 64 00 56 50 37 31 E0 01 0E 01 10 CD 01 EC 2F d VP71 /
05 09 00 1A 2F 7C 00 4F 67 00 00 02 44 AC 84 00 /| Og D
56 50 37 31 C0 02 8C 01 10 65 02 EC 2F 06 09 00 VP71 e /
96 37 87 00 4F 67 00 00 02 44 AC 84 00 56 50 37 7 Og D VP7
31 C0 02 8C 01 10 EB 02 EC 2F 20 09 00 7D 45 BB 1 / }E
00 4F 67 00 00 02 44 AC 84 00 56 50 37 31 C0 02 Og D VP71
8C 01 10 C6 03 EC 2F 08 09 00 0C 56 BC 00 4F 67 / V Og
00 00 02 44 AC 84 00 56 50 37 31 C0 03 1C 02 10 D VP71 
CC 04 EC 2F 09 09 00 42 62 10 01 4F 67 00 00 02 / Bb Og
44 AC 84 00 56 50 37 31 C0 03 1C 02 10 8D 05 EC D VP71 
2F 0D 0A 09 00 90 6E 0D 0A 01 4F 67 00 00 02 44 / n Og D
AC 84 00 56 50 37 31 00 05 D0 02 10 51 06 EC 2F VP71 Q /
0D 0A 09 00 FA 7A 9C 01 4F 67 00 00 02 44 AC 84 z Og D
00 56 50 37 31 00 05 D0 02 10 16 20 EC 2F 48 83 VP71  /H
01 00 02 0C 8C BF 00 00 EB E6 00 00 29 58 01 00 )X
E0 B7 01 00 B3 36 02 00 56 EC 02 00 2B 74 03 00 6 V +t
88 59 04 00 2A 5C 05 00 2A 18 06 00 A1 D8 06 00 Y *\ *
03 A8 20 00 84 BD 00 00 4C E4 00 00 D6 59 01 00 L Y
A7 BB 01 00 EF 3A 02 00 0D 0A F6 02 00 A2 7D 03 : }
00 A1 5B 04 00 46 66 05 00 B1 26 06 00 36 EC 06 [ Ff & 6
00 54 B1 20 00 78 BF 00 00 06 E6 00 00 48 5A 01 T x HZ
00 D4 B9 01 00 94 39 02 00 B1 ED 02 00 BD 7B 03 9 {
00 4F 61 04 00 A4 5F 05 00 B0 25 06 00 A4 F1 06 Oa _ %
00 49 AC 20 00 6A C5 00 00 FD ED 00 00 49 6B 01 I j Ik
00 45 C6 01 00 24 3C 02 00 2E F6 02 00 C7 7C 03 E $< . |
00 99 5D 04 00 44 97 05 00 BC 45 06 00 84 EE 06 ] D E
00 35 C5 20 00 76 20 00 00 A6 20 00 00 21 08 00 5 v !
00 21 08 00 00 21 08 00 00 2C 09 00 00 2C 09 00 ! ! , ,
00 2C 09 00 00 D6 0D 0A 00 00 D6 0D 0A 00 00 9A ,
0D 0A 00 00 9A 0D 0A 00 00 D6 12 00 00 D8 19 00 
00 A2 23 00 00 BE 30 00 00 08 40 00 00 5F 44 00 # 0 @ _D
00 4C 52 00 00 66 6A 00 00 86 7E 00 00 9E 94 00 LR fj ~
00 13 AE 00 00 0F C0 00 00 70 0F 00 00 12 12 00 p
00 9B 18 00 00 5A 1D 00 00 AB 1F 00 00 3E 29 00  Z  >)
00 13 2E 00 00 F6 33 00 00 CD 3F 00 00 A4 45 00 . 3 ? E
00 3B 4F 00 00 FF 54 00 00 CE 17 00 00 8D 1E 00 ;O T  
00 39 30 00 00 A4 3A 00 00 91 3F 00 00 B2 5B 00 90 : ? [
00 37 64 00 00 14 6C 00 00 C4 94 00 00 43 A2 00 7d l C
00 D0 A7 00 00 27 C6 00 00 02 32 00 00 01 0E 5F ' 2 _
5F 6B 65 79 73 65 72 76 65 72 75 72 6C 68 74 74 _keyserverurlhtt
70 73 3A 2F 2F 67 6B 73 72 76 2E 78 6C 6F 6E 74 ps://gksrv.xlont
65 63 68 2E 6E 65 74 2F 61 62 63 6B 72 00 00 00 ech.net/abckr
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

[ronmiracle]

Yahoo! Search
Help - Help for Webmasters
« back to results for "how to play .qmx"
Below is a cache of http://www.movenetworks.com/wp-content/uploads/movemediaplayersdk_20071214_01.pdf. It's a snapshot of the page taken as our search engine crawled the Web. We've highlighted the words: play playing qmx
The web site itself may have changed. You can check the current page (without highlighting) or check for previous versions at the Internet Archive.
Yahoo! is not affiliated with the authors of this page or responsible for its content.
Move Media Player
SDK Documentation
December 14, 2007
Confidential
Page
|
2
Address
796 East Utah Valley Drive
American Fork, UT 84003
General Information
Phone: 801.216.8861
Fax: 801.756.5806
info@movenetworks.com
Sales Information
Phone: 801.216.8828
Fax: 801.756.5806
salesoffice@movenetworks.com
Table of Contents
Table of Contents .................................................. .................................................. ................................................ 2
1 Overview .................................................. .................................................. .................................................. ......... 4
2 Player Object Creation and Exposure.......................................... .................................................. ................ 4
2.1 Code to Create Player............................................ .................................................. ...............4
2.2 Code to Play a QVT or QMX............................................... .................................................5
3 Player Installation and Version Upgrade .................................................. .................................................. . 6
3.1 QMP Install Library........................................... .................................................. ..................6
3.2 Supported Platforms .................................................. .................................................. ...........7
3.3 QMP Install APIs .................................................. .................................................. ............ 10
4 Player Communication, Manipulation, and Control .................................................. ..............................10
4.1 Player APIs .................................................. .................................................. ....................... 10
4.2 Player Events .................................................. .................................................. .................... 13
4.3 Play States .................................................. .................................................. ......................... 16
4.4 Player Settings.......................................... .................................................. .......................... 17
5 Player Related Web Page Enrichment .................................................. .................................................. .....18
5.1 My First Player Page Tutorial.......................................... ................................................. 18
6 Quantum Virtual Timelines (QVT)............................................. .................................................. .................21
6.1 Introduction to QVT............................................... .................................................. ........... 21
6.2 Shows versus Clips versus Gap Clips .................................................. .......................... 22
6.3 QVT Objects........................................... .................................................. ............................. 22
6.4 Open-ended Timelines .................................................. .................................................. .... 25
6.5 QVT JSON File Format............................................ .................................................. .......... 25
6.6 Timestamps and Anchors........................................... .................................................. ....... 28
6.7 External Metadata.......................................... .................................................. ..................... 30
December 14, 2007
Confidential
Page
|
3
6.8 Miscellaneous .................................................. .................................................. ................... 32
7 Helper Objects, Methods and Functions, and Debugging......................................... ............................32
7.1 Importing/Loading Libraries .................................................. .......................................... 32
7.2 String Functions......................................... .................................................. ........................ 33
7.3 Utility Functions .................................................. .................................................. ............. 33
7.4 URL Functions......................................... .................................................. .......................... 35
7.5 Logging Functionality .................................................. .................................................. ... 36
December 14, 2007
Confidential
Page
|
4
1 Overview
The Move Networks Video Player SDK is a Javascript-based library containing several
different types of functionality, all accessible remotely from a Web server via a Web page.
2 Player Object Creation and Exposure
HTML pages exposing the Move Networks Media Player (QMP) use QVT and related services
to access and manage the player, hiding complexity and increasing the cross platform
compatibility of the page.
In order to a get a player, the page must load the QVT library (
qvt.js
) with the help of the
Move Networks library (
movenetworks.js
).
Include the QVT library by way of
movenetworks.js
with an import of
qvt
:
<script type="text/javascript" charset="utf-8" src="
http://mvnet.xlontech.net/qm/move/stable/movenetworks.js
" import="qvt"></script>
Once loaded, your Web page will have access to the
MN.QVT
and
MN.QVT.QVT
objects, and
thus the player object. Use one of the following APIs to create and expose the player.
2.1 Code to Create Player
Two API options exist for creating a player:
CreatePlayer()
and
EmitObj()
. The only
difference between the two is that
CreatePlayer()
is essentially a wrapper around
EmitObj()
that also attempts to install or upgrade a player prior to calling
EmitObj()
. It is
recommended that
CreatePlayer()
be used in “production” player Web pages, since
CreatePlayer()
attempts to ensure that the player software is available before calling
EmitObj()
.

MN.QVT.CreatePlayer(parentID, callbackFunction, width, height)
This API first attempts to install or upgrade a player. When the installation or upgrade is
complete,
EmitObj()
is called. For example:
<div id="playerParent">The player will go here</div>
...
qmp = MN.QVT.CreatePlayer("playerParent", CallMeBack, 480,
360);
// now use qmp to control the player
qmp.Play("http://www.foo.com/biff/baz.qvt");
MN.Event.Observe( qmp, "PlayStateChanged",
MyPlayStateChangedFunc );
parentID
: Can be either the parent ID or the parent object.
December 14, 2007
Confidential
Page
|
5
callbackFunction
: Function to be called after the player has been created. The
parameter that will be passed to the
callbackFunction
depends on whether the
player was successfully created or not. If successful, the player object will be passed.
If not successful, a value of
False
will be passed.
width
: (optional) Width of the player in pixels. Defaults to 480.
height
: (optional) Height of the player in pixels. Defaults to 360.
MN.QVT.EmitObj(parentID, width, height)
The
EmitObj()
API is used to create a player instance in the
parentID
element without
checking to see if the player software has been installed. This newly-created player object is
then returned to the code. Caution should be taken when using the
EmitObj()
API because
errors will occur if the player software has not been installed for use with the user’s browser.
For example:
<div id="playerParent">The player will go here</div>
...
qmp = MN.QVT.EmitObj("playerParent", 480, 360);
// now use qmp to control the player
qmp.Play("http://www.foo.com/biff/baz.qmx");
MN.Event.Observe( qmp, "PlayStateChanged",
MyPlayStateChangedFunc );
Note: In the two examples above, either a normal QVT or a QMX URL can be used in the call
to
Play
; internally, the player converts QMX URLs to a virtual timeline with just a single
piece of content. See the “QVT Objects” section below for more information.
parentID
: Can be either the parent ID or the parent object.
width
: (optional) Width of the player in pixels. Defaults to 480.
height
: (optional) Height of the player in pixels. Defaults to 360.
2.2 Code to Play a QVT or QMX
Play(URL, start=-1, stop=0)
Once a player object is available, you can play content using the
Play()
API.
Play
can be
told to play a .qmx URL, a .qvt URL, a QVT object instance, or a QVT instance as a string. If
null is passed in instead of a URL, the player’s current QVT object is used rather than loading
a new one.
Play()
can also take an optional start and stop position. If -1 is passed as the starting
position, an attempt is made to begin play at the most appropriate location. Omitting the stop
position in a call to
Play
results in playing to the end.
<div id="playerParent">The player will go here</div>
...
qmp = MN.QVT.CreatePlayer("playerParent", CallMeBack, 480,
360);
// now use qmp to control the player
qmp.Play("http://www.foo.com/biff/baz.qvt", -1);
December 14, 2007
Confidential
Page
|
6
MN.Event.Observe( qmp, "PlayStateChanged",
MyPlayStateChangedFunc );
URL
: Can be a .qmx URL, a .qvt URL, a QVT object instance, or a QVT instance as a
string. If null is passed instead of a URL, the player’s current QVT object is used.
Start
: (optional) Position within the QVT where play should begin. If -1 is
passed, an attempt is made to begin play at the most appropriate location. Defaults to
-1.
Stop
: (optional) Position within the QVT where play should end. Defaults to the
end of the QVT.
Also see the “Creating a Page” tutorial for additional code examples.
3 Player Installation and Version Upgrade
Player installation and upgrade is handled automatically when the
CreatePlayer()
API is
used to instantiate a player. This API uses the QMPInstall library
(
qmpinstall.js
)
to
attempt to install or upgrade the player software from across the Internet. Other methods of
installing or upgrading a player are not available at this time.
3.1 QMP Install Library
The QMPInstall library (
qmpinstall.js
) handles all the work around installing and
upgrading the media player in a user’s browser. This includes the initial installation,
subsequent upgrades, and ongoing status notifications, such as alerting the user of errors
during the installation.
Once a call to create a player has been made using the
CreatePlayer()
API, the page will
go through the four steps listed below.
1.
A platform check will occur, and the user will be informed if the operating system or
browser is not supported.
2.
If the platform is supported but the user has not installed the player, the user will be
guided through the installation process.
3.
If the platform is supported and the player is installed but out of date, the user will be
guided through an upgrade process. If, after the upgrade, a restart of the browser is
needed to load the new player object, the user will be notified.
4.
After initialization, the optional player-loaded
callbackFunction
(see
MN.QVT.CreatePlayer()
above) will be called.
Note: Customization of these steps is not currently supported. For example, the ability to skip
step #3 is not allowed.
The
callbackFunction
must expect a single parameter. That parameter will be set to either
the player object or to a false value. If the callback function is passed a false value, this means
December 14, 2007
Confidential
Page
|
7
that the player was not created successfully. If a non-false value is passed to the callback
function, the player was created successfully and is ready to play content.
In the
callbackFunction
, you might do a check at the beginning of the function like this:
function OnPlayerLoaded(player)
{
if(!player)
// There was a problem creating the player object
return;
// You could put other code here as well
// Otherwise you are good to go
player.Play(someURL);
}
3.2 Supported Platforms
Currently, Move Networks Media Player supports the following platforms and browsers:
Platforms
•
Microsoft Windows 2000/XP/Vista
•
Apple Macintosh OS X or later (both PPC and Intel)
Browsers
•
Microsoft Internet Explorer 5.5 or later
•
Mozilla Firefox 1.5 or later (Windows and Mac)
•
Safari 1.3.2 (build 321.5) or later
The following settings allow the player to determine which platforms and browsers are
allowed to access any media player experience. Simply set each variable to true or false before
the call to create the player.
MN.QMPInstall.allowMozilla
MN.QMPInstall.allowMacPPC
MN.QMPInstall.allowMacIntel
MN.QMPInstall.allowMacSafari
For Example,
MN.QMPInstall.allowMacPPC = false;
would not allow users with a
PowerPC Macintosh to install the player.
Install Messages
The QMPInstall library has a number of messages that it uses during the installation process
to notify the user of the current status of the installation. These messages are displayed in the
container which was passed into the
CreatePlayer()
function. General styling of these
messages can be achieved by styling via CSS. The SDK comes with a default set of styles in
qmpinstall.css
that pages can include if needed.
The installation messages have default values but can be customized to fit a page’s need.
(Please see below for a list of install messages.) To overwrite the values of these messages, set
MN.QMPInstall.MSG_*
. The message values should be overwritten after the page has
December 14, 2007
Confidential
Page
|
8
loaded but before the call to create a player. These values can be set to HTML as well as
JavaScript strings. For example:
<body>
<!—Style the messages that appear during the install
process -->
<div id=”playerContainer” style=”font:bold 12px Tahoma;
color:#4D7CB2;”></div>
………
</body>

function OnPageLoaded()
{
MN.QMPInstall.MSG_CANINSTALL = ‘

You do not have the free
player. Click the download button to install it!.</p> \


<a href=”#~” onclick=”MN.QMPInstall.StartInstall();”>
<img src=”install_button.jpg” border=”0”> </a></p>’
……..
// Call to create player
}
This code would display the following if the
QMPInstall
library detected that the user
needed to install the player:
The following table includes the installation messages and when they will appear to the user:
Message
Meaning / When Presented
MSG_BADOS
The user is running an unsupported operating system. If
the string
%s
is present in the message, it is replaced with
a list of supported operating systems.
MSG_BADBROWSER
The operating system is supported but the current
browser is not. If the string
%s
is present in the message,
it is replaced with a list of supported browsers for the
operating system.
MSG_NEEDREINSTALL
Used when it is necessary to force the end user to start all
over with the installation process. This will happen
when the client already on the machine doesn't support
the kind of upgrade needed, or the attempted upgrade
didn't work for some reason. This is commonly known as
the "forced upgrade."
December 14, 2007
Confidential
Page
|
9
MSG_NEEDUPGRADE
The user has an old version of the player that must be
upgraded, and the upgrade will be performed
automatically. The message should include an HTML
span with the ID
_qmpUpgradeProgress
to hold the
progress messages. This is used when a new client is
needed before playback can occur. This is commonly
known as the "foreground upgrade."
Note: There is also a “background upgrade” which has
no message associated with it by nature of not bothering
the end user.
MSG_UPGRADING
Displayed repeatedly throughout the upgrade progress.
If the string
%s
is present in the message it is replaced
with the current progress.
MSG_UPGRADEFAILED
An automatic upgrade could not be completed. If the
string
%s
is present in the message, it is replaced with a
reason for the failure if known.
MSG_CANINSTALL
The user does not have the player at all and must install
it. To initiate the installation, the message should
include a link that calls
MN.QMPInstall.StartInstall()
.
MSG_INSTALLING
Displayed once
StartInstall
has been called. If the
string
%s
is present in the message it is replaced with
one of the installation messages below to provide
additional platform-specific instructions.
MSG_INSTALL_java
A Java-based installation is being used; user should be
instructed to trust or allow the Java applet.
MSG_INSTALL_win_ie
The user is on Windows running Internet Explorer and
will be prompted to download and run an executable file
to install the player.
MSG_INSTALL_win_mozilla
The user is on Windows running Firefox and will be
instructed to download and run an executable file to
install the player.
MSG_NEEDRESTART
An upgrade completed, but the new version could not be
loaded. The user needs to restart the browser in order to
complete the upgrade.
December 14, 2007
Confidential
Page
|
10
3.3 QMP Install APIs
CanPlay()
Returns true if the player is installed and up to date. Use this to determine if the user is able to
view content.
InstallRequired()
Returns true if an installation of the player is needed to play content.
UpgradeRequired()
Returns true if an old version of the player is installed but requires an upgrade.
4 Player Communication, Manipulation, and Control
4.1 Player APIs
CurrentBitRate()
Returns the bit rate of the most recently played streamlets, in Kbps.
CurrentClip()
Returns the index in the timeline of the currently playing clip.
CurrentPlayState()
Returns the current state of playback as an integer. Please refer to the “PlayState” section for
more information.
CurrentPosition(position)
Sets the current position in playback. The position can be given in either seconds or a
timestamp string. If called with no arguments, the current position in playback is returned. A
start value of -1 instructs the player to determine where playback should begin. If position
exceeds the duration, playback starts at or near the current end of the timeline. If the position is
less than 0 and not -1, playback starts at the beginning of the timeline.
CurrentQVT()
Returns the current QVT object being played. Call this when the QVT object is needed
temporarily; do not save a reference to the returned object. See section 6.3 for more
information.
Duration()
Returns the duration of the timeline in seconds.
Encrypted()
Returns
true
if any of the content’s sub-streams are encrypted and require a key for playback.
FillColor(color)
Sets the background fill color of the player. Use HTML color strings (for example, #FFFFFF).
GetCurrentURL()
Returns the URL currently being played. If nothing is playing, an empty string is returned.
December 14, 2007
Confidential
Page
|
11
GetSetting(name)
Retrieves a player setting from the operating system’s registry. Returns an empty string if no
value has been set with given name.
HasAudio()
Returns
true
if the content currently playing has an audio stream.
HasVideo()
Returns
true
if the content currently playing has a video stream.
Height(height)
Sets the player’s height. If called with no arguments, the current height of the player is
returned.
InGap()
Returns
true
if the current position is inside a gap. See section 6.2 about gap clips.
Live()
Returns
true
if the current stream is live. A live stream is an open-ended timeline.
Load(URL)
Like
Play
, this method loads the given URL and causes a
TimelineLoaded
event to fire
when loaded. Unlike
Play
, however, playback does not start automatically.
MetadataByIndex(index)
Retrieves the value of the metadata at the given index. Use
MetadataCount
to find the
number of pieces of metadata attached to the current content.
MetadataByName(name)
Retrieves the metadata value associated with the given name. Returns an empty string if there
are no metadata by that name.
MetadataCount()
Returns the number of pieces of public metadata attached to the current content.
MetadataName(index)
Retrieves the name of the metadata at the given index point. Use
MetadataCount
to find the
number of pieces of metadata attached to the current content.
Muted(true or false)
When value is set to
true
, sound is muted during playback. If called with no arguments, the
player’s current muted state is returned.
Paused(true or false)
When value is set to
true
, playback is paused. If called with no arguments, the player’s
current paused state is returned.
Play(URL, start=-1, stop=0)
Start playback of the given URL. URLs should end in a .
qvt
or .
qmx
extension. The start and
stop parameters can be given in either seconds or a timestamp string (for example,
December 14, 2007
Confidential
Page
|
12
05:12:25.123
). The start parameter is optional and defaults to
-1
. A start value of
-1
instructs the player to determine where playback should begin. For live content this is as
close to “live” as possible. For non-live content, this is at the beginning of the content. Any
non-zero start value seeks to that position before playback starts. If a stop value is given,
playback stops at that point.
Note: This method for setting the start time (URL with included start value) is more efficient
than calling
Play
and then setting the
CurrentPosition
.
PlayClip(qmxURL, title=””, start=-1, stop=-1, playStartPos=-1)
Plays a portion of a clip, restricting playback to the specified range. The
title
,
start
,
stop
and
playStartPos
parameters are optional. The
start
and
stop
parameters can be
given in either seconds or a timestamp string.
PutSetting(name, value)
Saves a player setting to the operating system’s registry. Unknown settings are ignored.
Please refer to the
PlayerSettings
section for more information on valid settings.
RealAspectRatio()
Returns the actual video windows aspect ratio of the current content as a number (width
divided by height).
RegistryVersion()
Returns the version of the player currently installed, according to the registry.
Set(variable, value)
Assigns the given value to the given variable. For example:
var myfunc = "qmp.Set('SelectStreams', '0, -1, -1, -1, -1,
-1,-1,-1,-1,-1,-1,-1');";
// assure that the amount of flags is equivalent to the
// profile set in use
myfunc += "qmp.Set('Commit', '1');";
flash.external.ExternalInterface.call("eval", myfunc);
SetAutoPlayNext(value)
When set to true, playback will advance to the next QVT when the current timeline is finished
playing. If not set to false, will default to true and playback of the next QVT will occur
automatically unless a playback stop position was given.
SingleStep()
When video playback is paused, calling this function will advance playback by one video
frame, if possible.
StartTimestamp()
Returns the starting time of the current content in seconds since the epoch (January 1, 1970
GMT). Use this to map content time to actual time. This function can be especially useful for
getting the actual time for live content.
Note: In JavaScript the
Date
object is in milliseconds.
December 14, 2007
Confidential
Page
|
13
Stop()
Stops playback. If nothing is playing, calling this has no effect.
StopScrubbing()
Stops scrubbing.
UserAspectRatio(ratio)
Sets the user-specified aspect ratio. This function is used to force the display to use a different
aspect ratio. Calling with a ratio of 0 tells the player to use the real aspect ratio. If called with
no arguments, the current user-specified aspect ratio is returned.
Version()
Returns the version of the player currently loaded in the browser.
Note: The version and registry version values can be different.
VideoHeight()
Returns the video window height, in pixels, of the content currently playing. Returns zero if
nothing is playing.
VideoWidth()
Returns the video window width, in pixels, of the content currently playing. Returns zero if
nothing is playing.
Volume(level)
Sets the current volume level of the player, from 0 to 100 inclusive. If called with no
arguments, the player’s current volume level is returned.
Width(width)
Sets the player’s width. If called with no arguments, the current width of the player is
returned.
4.2 Player Events
AudioControl(muted, volume)
Fired when the UI needs to be updated to reflect a change in the state of the audio controls. For
example, after setting the Muted or Volume properties, this event will fire with the new values.
The reason this is handled separately is that changes to the audio controls' state may occur
outside the scope of the application (for example, the user clicks the Mute checkbox in the
Wave column of the Windows Volume Control applet).
BitmapReady(status, url)
Fired when
SendBitmapAsync
or
SendBitmap
completes. The resulting status value is 0
on failure and 1 on success with the URL parameter containing the URL of the uploaded file.

BitRateChanged(newRate)
Fired when the playback bit rate changes. The
newRate
parameter is the number of Kbps.
Error(msg)
Fired to pass an error message to the Web page (for example, a bad URL). The parameter is a
human-readable string.
December 14, 2007
Confidential
Page
|
14
MutedChanged(newMuted)
Fired when the player’s muted state changes. The
newMuted
parameter is
true
if the player is
muted.
NextClip(clipNumber)
Fired when the player transitions from one clip to the next in the timeline.
NextTimeline(url)
Fired when the player has finished playing the current timeline and is automatically moving to
the next linked timeline.
NotSustainable(reason)
Fired for the lowest priority stream when any playing stream encounters too many frame drops.
The player cancels the most recent not sustainable event when all streams go a period without
a further frame drop. A reason code is returned.
PausedChanged(newPaused)
Fired when the player’s paused state changes. The
newPaused
parameter is
true
if playback
is paused.
PlayStateChanged(oldPlayState, newPlayState)
Fired when the player transitions to a new play state. Please refer to the “P lay State Values”
section for more information.
Script(key, value)
Fired when the player encounters an embedded script event. The key and value data are
publisher-defined strings.
ScrubBumper(atStart)
Fired when a scrubbing operation has reached the beginning or end of the scrub range. Since
scrubbing is currently only supported within the clip, and not across clips, the scrub range is
the play range of the clip the user was in when they chose to begin scrubbing.

ShowChanged(showNumber, showTitle)
Fired when playback has moved to another item in the playlist.
TimelineLoaded(qvt)
Fired when the playlist for a timeline has finished loading.
VolumeChanged(newVolume)
Fired when the player’s volume has changed. The
newVol
parameter is the current value of the
player’s volume from 0 to 100 inclusive.
Event Handling
The Move Networks SDK includes an event handling library. The event library extends the
browser’s
Event
object to include functions for cross-browser event handling and player
event handling.
To add an event handler to an object, use the following:
December 14, 2007
Confidential
Page
|
15
MN.Event.Observe(object, eventName, listenerFunction)
For example, the following would set up a function to be called every time the player’s bit rate
changed:
function OnBitRateChanged(newRate)
{ // Function names can be anything of course
log(‘The bit rate changed to ‘ + newRate + ‘ Kbps);
}
MN.Event.Observe(playerObject or ID, ‘BitRateChanged’,
OnBitRateChanged);

Note: When using the event library, event names should not include the
On
prefix. (for
example,
onclick
would be passed in as
click
).
To remove an event handler, use
MN.Event.StopObserving(object, eventName,
listenerFunction)
.
For example, the following would stop observing the event that we started observing in the
above example:
MN.Event.StopObserving(playerObject, ‘BitRateChanged’,
OnBitRateChanged)
Note: In order to stop observing an event correctly, the exact same values must be passed into
the
StopObserving
function that were passed into the
Observe
function. If the arguments
don’t match, the event will continue to be observed, and observation of a different event may
be stopped by accident.
In addition to hiding browser-specific details, these event functions also make it possible to
“ stack” multiple listeners for a single event. Stacking allows multiple functions to listen for
the same event being fired by an object. When the object fires the event, all the functions
listening for that object’s event are called.
For example, the following would allow you to have two functions listening for the player’s
PlayStateChanged
event:
MN.Event.Observe(playerObject,‘PlayStateChanged’, UpdateUI)
MN.Event.Observe(playerObject,‘PlayStateChanged’,
OnPlayStateChanged)
When the player fires the
PlayStateChanged
event, both the
UpdateUI
and
OnPlayStateChanged
functions are called.
Note: When stacking event handlers, there is no guarantee as to which order the listening
functions are called.
To ensure that event handlers aren’t accidentally overwritten, it’s generally preferable to use
the above functions for any event handling where multiple handlers might be used. For
December 14, 2007
Confidential
Page
|
16
example, instead of specifying the page load/unload event handlers in the BODY HTML tag
(for example,
<body onload=”…”
), they can be handled by observing the
load
event on the
window object:
MN.Event.Observe(window, “load”, MyLoadFunc)
Please refer to the “Creating My First Page” tutorial to learn more.
MN.Event.Observe(object, eventName, listenerFunction)
Add an event handler to the given object. The object parameter may either be the object or the
object’s ID. The
listenerFunction
is called when the object fires the event.
MN.Event.StopObserving(object, eventName, listenerFunction)
Remove an event handler for the given object. The object parameter may either be the object or
the object’s ID. If no match for the event handler is found for the given object, the call is
ignored.
MN.Event.RemoveAllObservers()
Removes all event handlers registered through
MN.Event.Observe
.
4.3 Play States
The current state of playback can be retrieved by calling the player’s
CurrentPlayState
function. The player’s
PlayStateChanged
event is fired whenever this state changes.
Functions listening for this event will be passed both the old and new play states. The SDK
library provides a play state helper to display the play state as a text string rather than as a
numerical value. This object is referenced using
MN.QMP.PS
. For example:
var state = player.CurrentPlayState();
if (state = = MN.QMP.PS.ERROR)
// do something with the error
$(“playState”).innerHTML = “Current PlayState is “ +
MN.QMP.PS[state];
The strings returned by the play state helper are the names of the states (see table below). It is
important to note that the play states returned by the player and SDK libraries are numbers
and not text strings. The play state helper converts these values into descriptive text strings
that can be displayed to the end user.
When the player is first created, its state is
Init (0)
. Once the player receives the command
to play content, the state switches to
Opening (1).
The progression of the play states
during playback is usually something like:
Opening > Authorizing > Loading > Playing > Media Ended.
The
Waiting
state (255) does not normally need to be handled. If the player is in this state, it
usually means that the publisher is not keeping up with the pace of playback. This happens
when the publisher is late publishing additional content to an open-ended timeline.
Play State
Number
Name
Description
December 14, 2007
Confidential
Page
|
17
0
Init
Initializing and creating player interface
1
Opening
Opening video content
2
Loading
Loading the first streamlets of the content
3 Playing
Playing
content
4
Stopped
Playback of content has stopped as a result of calling
the player Stop function
5
MediaEnded
The end of the current content has been reached
6
Error
An error has occurred with the player
7
Stalled
Playback of content has stalled
8
Authorizing
The player is requesting the server for authorization to
play content
255 Waiting
Content is late being published for open-ended
timelines

4.4 Player Settings
Note: These settings work in the majority of cases. They are present primarily for
testing purposes and should not be changed without prior consultation.
The player has a few user-selectable settings that modify its behavior. See the “P layer APIs”
section for more information on retrieving and modifying setting values.
To change a setting simply call
player.PutSetting(name, value)
. For example:
Player.PutSetting(“Renderer”, “dx”).
To retrieve a setting call
player.GetSetting(name)
.
To change the setting to its default call
PutSetting
with an empty string value, for example
PutSetting(“Renderer”, “”).
Calling
GetSetting()
or any setting other than
RendererDesc
returns that value last
requested, not the one in use. Use the value of
RendererDesc
for information about the
renderer currently in use.
Name
Value
Comments
December 14, 2007
Confidential
Page
|
18
RendererUseOverlays
yes,no
This tells the renderer whether or not to attempt
to use video overlays, if available. This setting is
used only by DirectX renderer.
RendererDesc
(read-only)
Retrieves a text description of the renderer in use.
Renderer
vfw dx
Selects which renderer to attempt to use for
video: dx (DirectX, the default), vfw selects the
older Video For Windows renderer.
AudioRenderer ds
waveout
Selects which audio renderer to attempt to use
for audio:
ds
(DirectSound),
waveout
selects
the WaveOut audio renderer.
5 Player Related Web Page Enrichment
The Move Networks Video Player SDK supports the development of feature-rich player Web
pages. The Web page enrichment features are found in the following files:
autoplayer.js
minimal.js
playerui.js
shinyred.js
validate.js
widget.js
5.1 My First Player Page Tutorial
In order to have enriched pages, one must first have a basic page. This tutorial shows how to
create such a page.
This tutorial covers the basics of putting the Move Play Client into a Web page. The 40 lines
of code for this tutorial can be found below, at the end of section 5.1. This tutorial will
reference that code, giving examples with the corresponding line number(s). If you run into
any problems, see the “Troubleshooting” section below.
First you need to include the URL to the
movenetworks.js
file and import the
qvt.js
library (line 8). This
<script>
tag should go into the body of your page.
<script language=”javascript”
src=”http://www.foo.com/url/to/movenetworks.js”
import=”qvt”></script>
The QVT library aids in embedding the player into your Web page.
December 14, 2007
Confidential
Page
|
19
Next add a script section to the body of your page to put the functionality to create and use the
player (line 12).
<script language=”javascript”>
// Code will go here
</script>
Define a function to be called when the window
load
event is fired, and include a call to
show the logging pane and log a message to it (lines 15–18) Then observe the window load
event passing in this function (line 37).
function OnPageLoaded()
{
MN.Log.ShowPane(500);
log(‘Page
loaded’);
}
MN.Event.Observe(window, ‘load’, OnPageLoaded);
Open the page in a browser. If you see the logging page with your log message in it, you have
successfully loaded the Move Networks Client SDK. Showing the logging pane (line 17) is
not necessary but is a good idea to always have visible during development of a page.
When creating a player, two things are needed to pass in to the
CreatePlayer()
API:
1. An HTML container to put the player object in.
2. A function to be called once the player has been created.
Create a container to hold the player in the body of the page, and give it an ID (line 10).
<div id=”myplayer”></div>
Now define a function to be called once the player has been created (lines 22–35). This
function should check to make sure the value passed to it is not false. If the value is false, this
means that there was an error creating the player. You should also add a global variable to
hold the player object so that it can be referenced when calling other functions (line 13).
var qmp = null; // will hold the reference to the player
object
function OnPlayerLoaded(playerObject)
{
if(!playerObject)
{
logError(‘Failed to create the player’);
return;
}
else
{
// the player was successfully created and you
are good to go
December 14, 2007
Confidential
Page
|
20
qmp
=
playerObject;
qmp.Play(‘http://qmedia.xlontech.net/100170/streamlets/ \
themagicofflight_on2/output.qmx’); // Play some content
}
}
You are now ready to create the player. To create the player, call
MN.QVT.CreatePlayer(playerID, callbackFunction, width, height)
(line
19). Place this call in the
OnPageLoaded
function that you already set up. The
MN.QVT.CreatePlayer
function takes optional width and height parameters to set the
player’s initial width and height.
MN.QVT.CreatePlayer(“myplayer”, OnPlayerLoaded, 480, 360);
That is it! When you open the page in a browser, you should see video playing. If you don ’t
see video or are having problems, refer to the “Troubleshooting” section below.
Note: Pages that use the Move Networks Client SDK should typically specify a
DOCTYPE
like this (see line 1):
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0
Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-
transitional.dtd">
An example code listing:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-
1">
<title>Creating a player</title>
</head>
<body>
<script type="text/javascript" charset="utf-8"
src="http://qmedia.xlontech.net/100348/qm/latest/movenetworks.js"
import="qvt"></script>
<div id="mplayer"></div>
<script language="javascript">
var qmp = null;
function OnPageLoaded()
{
MN.Log.ShowPane(500);
log('Page Loaded');
MN.QVT.CreatePlayer("myplayer", OnPlayerLoaded, 480, 360);
}
function OnPlayerLoaded(player)
{
if(!player)
{
logError('Failed to create the player');
return;
}
else
{
// You are good to go
December 14, 2007
Confidential
Page
|
21
qmp = player;

qmp.Play('http://qmedia.xlontech.net/100170/streamlets/themagiccofflight_o
n2/output.qmx');
}
}
MN.Event.Observe(window, 'load', OnPageLoaded);
</script>
</body>
</html>
6 Quantum Virtual Timelines (QVT)
QVT provides services which allow one or more content segments to be sequenced as a single
virtual content timeline within a single QVT (stored in a file with the extension .
qvt
). Like
many elements of Web-based software, they are stored on the Web server but consumed by the
Web client.
6.1 Introduction to QVT
When playing a QVT, the player tries to treat the entire timeline as a single piece of content.
This means that when one clip in the timeline finishes, playback moves to the next clip in the
timeline. Only when playback of all clips has finished does the player enter the
MEDIAENDED
playstate.
QVT files are simply text files stored in Javascript Object Notation (JSON) format
(
http://www.json.org/
), which makes them interoperate with different languages as well as
XML, but without the downsides of XML (such as bloat and the relative difficulty of reading
and writing XML).
A JSON string is white-space agnostic and basically has the form of the following line:
{ property1:value1 ... , propertyN:valueN }
where property has the form of a double-quoted string and value can be either a double-quoted
string, a JSON string, or a list of JSON strings enclosed in brackets ( “[ ]”). Only double-
quoted strings are legal in JSON. See
http://ww w.json.org/
for a more formal syntax
specification.
QMP now ships with a built-in JSON verifier to ensure that no harmful code is included in the
QVT. The raw JSON text is evaluated to create a JavaScript object.
QVT files can have links to next and previous timelines. If a QVT has a next-QVT link, when
playback of the current timeline ends, the player can automatically move to the next timeline
(controlled using the
SetAutoPlayNext(true/false)
API). When playback moves to
the new timeline, internally a call to
Play(newQVT, 0)
is made. Note that if playback does
not reach the end of the timeline (because a stop position was requested), then playback will
not automatically move to the next timeline, regardless of whether or not Set
AutoPlayNext
is enabled.
December 14, 2007
Confidential
Page
|
22
6.2 Shows versus Clips versus Gap Clips
A QVT file is made up of a list of URLs that represent the various media clips to play as part of
the timeline. Each clip, however, may be made up of several shows.
For example, the clip itself could cover an entire day's worth of TV programming. Even though
it is a single clip, many shows were played throughout the day, and each show needs its own
metadata.
If a clip covers multiple shows, the per-show metadata can be specified using the
.shows
property in a QVT file (see “QVT File Format” below for more info). Otherwise, the clip
metadata will be treated as if it were show metadata and will be accessible accordingly.
If a clip does not have a URL specified, it is considered a gap or filler space between clips. A
Web page using QVT could choose to skip the gap or allow it to "play" (the video window is
not updated while a gap is playing, so a Web page could display an alternate image during
that time, for example). A gap clip should not have a list of shows, but it can have arbitrary
metadata.
Instead of having shows tied to clips, a top-level show list can be given instead. This list has
the same format as clip-level show lists, but the shows map directly to timeline times
regardless of where clips begin and end. This can be useful in situations where multiple clips
correspond to a single show list (for example, if the Atomizer is set to record all day but is
restarted halfway through).
If a show list is longer than the timeline at the time the QVT is loaded, it is truncated to make it
match the actual timeline duration. Shows that begin beyond the end of the timeline are
ignored, and if a show lasts longer than the timeline it is shortened. If you are using live
content (such that the timeline continues to grow), simply mark your QVT file as reloadable
and over time the list of shows that is included will grow automatically.
6.3 QVT Objects
QVT Javascript objects are created from the contents of a .
qvt
file, a JavaScript string that
mirrors the contents of a .
qvt
file, or from another QVT object. They are separate from player
objects.
A QVT object contains all the information about the contents of a timeline. You can create a
QVT object by either telling the player to play a URL (and then calling
player.CurrentQVT()
) or with
MN.QVT.AcquireQVT(url or str)
.
Because QVT objects may automatically reload themselves, an internal cache of current QVT
objects is maintained to prevent multiple copies of the same QVT from overrunning the server
with update requests. If you obtain direct access to a QVT object via
MN.QVT.AcquireQVT
,
you need to call
MN.QVT.ReleaseQVT(qvt)
when done with it to ensure the cache stays
up to date. Failure to do this won't necessarily cause errors, but if a user views many QVT
objects in a single session, not calling this function could leave a lot of them lying around
even when you're no longer using them.
QVT objects have the following APIs:
ClipToTimeline(clipNum, clipPos)
December 14, 2007
Confidential
Page
|
23
Given a clip number and position, returns an overall timeline time.
DecRef()
Decrements the reference count for this object. This should be called once for each call to
IncRef
.
Duration(showNum)
Returns the duration of the specified show. If
showNum
is omitted, returns current duration of
the entire timeline.
GetSource()
Returns the URL (or other input) passed to the object constructor.
GetTimelineNow()
For anchored timelines, returns a value in timeline time (in seconds) that corresponds to right
now. For unanchored timelines, returns 0.
GetSummary()
Makes a "snapshot" of the current QVT and returns it; useful for generating a graphical version
of the timeline for presentation to the user. Returns an object with the following properties:
.duration
- the total duration of the timeline
.live
- the value of
qvt.HaveAnyLive()
.shows
- an array of show objects. Each show has the following properties:
.startTime
- when the show starts, in timeline time
.stopTime
- when the show ends, in timeline time
.duration
- the duration of this show, in seconds
.title
- the title of this show, if any
.showNum
- the show number (0-based)
.isGap
- true if this show is a gap instead of a clip of content
HaveAnyLive()
Returns true if any clips are marked as live.
IncRef()
Increments the reference count for this object. Use this when you need to save a reference to a
QVT object, for example:
theQVT = qmp.CurrentQVT().IncRef();
InitialLoadDone()
Returns true if the first-time load of this QVT has finished.
IsAnchored()
Returns true if this timeline is anchored; see the “Timestamps and Anchors” section for more
info.
IsGap(showNum)
Returns true if the given show is a gap.
December 14, 2007
Confidential
Page
|
24
IsLoading()
Returns true if an asynchronous load or reload of this QVT is underway.
IsOpenEnded()
Returns true if this QVT is open-ended; see the “Open-ended Timelines” section below for
more information.
IsValid()
Returns true once the QVT is fully loaded and has valid clips.
Metadata(name, showNum)
Returns the metadata for the given name, if any. If
showNum
is omitted, returns the metadata
value for the QVT itself. Both QVT objects and individual shows can have arbitrary metadata.
NextURL()
If this QVT has a reference to a "next" timeline, returns its URL. This is used for linking
timelines together.
PosToDatetime(pos)
Returns a datetime object representing the given position in the timeline converted to
broadcast time. The returned object has the following members: year, month, day, hour, minute,
second, dow (for “day of week,” Sunday=0). For example, if the timeline starts at Feb 1, 2005 at
9:00AM PST, then calling
PosToDatetime(3602
) would return an object with members
giving the time of 10:00:02 on Feb 1, 2005, regardless of the user's local timezone. If the
timeline does not have a timezone set (for example,
Timezone()
returns null), the returned
time will be in UTC. The month value is 1-based (Jan.=1, Feb.=2, etc.).
PrevURL()
If this QVT has a reference to a "previous" timeline, returns its URL.
PrimaryURL()
If the QVT object has a
primaryQVTURL
member, returns it. If not, returns the QVT URL used
to create the object. If no URL was used (for example, if a JavaScript object was passed in to
the constructor), returns a false value. This function exists to aid pages that need a more
permanent URL when a temporary URL was used to initiate playback (for example, if the
Atomizer produced a
today.qvt
file and the viewer uses the Send to a Friend feature. On the
next day,
today.qvt
would point to the wrong day, so instead the Atomizer would include
a primary URL, and the Web page would call this API to include the correct URL in the Send
to a Friend email).
ShowCount()
Returns the number of shows in this timeline.
StartDatetime()
Returns a datetime object (see
PosToDatetime
, below) representing the date and time when
this timeline starts, in broadcast time. If the timeline does not have a timezone set (for example,
Timezone()
returns null), the returned time will be in UTC.
StartTime(showNum)
Returns the start time of the specified show (show numbers are 0-based).
December 14, 2007
Confidential
Page
|
25
StartTimestamp()
Returns the timestamp value for the timeline, if it has one.
StopTime(showNum)
Returns the stop time of the specified show.
TimelineToClip(pos)
Given a time in the timeline, returns a position object.
TimelineToShow(pos)
Given a time in the timeline, returns a show number.
Timezone()
Returns the timezone value for this timeline, if one is specified; null otherwise.
Title(showNum)
Returns the title of the specified show, if any. If
showNum
is omitted, returns the title of the
entire timeline.
Note that
MN.QVT.ReleaseQVT(x)
and
x.DecRef()
are functionally equivalent, but for
clarity you should use
ReleaseQVT
if you obtained the QVT via
AcquireQVT
and
DecRef
if you obtained it via
IncRef
.
6.4 Open-ended Timelines
QVT files with a
.reload
property are said to be open-ended, which means that the timeline
is considered to be incomplete and will be edited additionally over time. Open-ended
timelines allow publishers to modify the future sequence of clips, even if some users are always
viewing the timeline.
If you create an open-ended timeline, be sure to remove the
.reload
property once the
timeline is finalized (once you intend to make no further changes) so that the timeline is no
longer open-ended.
If a user plays an open-ended timeline and reaches its end before additional clips have been
added (or before the QVT file is edited to no longer be open-ended), playback will pause at the
end of the timeline and the player will enter the
WAITING
playstate (255). Later, when an
edited version of the timeline is published, playback will move to the next clip if new clips
were added. If the timeline was edited to no longer be open-ended, the behavior will be the
same as if the timeline wasn't open-ended to begin with.
Note that editing the range of a clip in an open-ended timeline will not have any effect if the
user is already playing that clip (that is, if a clip has the range 10–20, and you edit the range
to 10–100 after someone has already started playing that clip, that user will still have
playback stop at 20, even if the new version of the timeline is loaded before playback of the
clip ends).
6.5 QVT JSON File Format
The raw JSON text is evaluated to create a JavaScript object. QVT objects can have the
following properties; all of them are optional except for
.clips
:
December 14, 2007
Confidential
Page
|
26
.title
- A title for the entire timeline.
.prev
- A QVT URL pertaining to a timeline that precedes the current one sequentially.
.next
- A QVT URL pertaining to a timeline that immediately follows this one. If this member
is present, the player will automatically begin playing the next QVT when it reaches the end of
the current QVT.
.reload
- The number of seconds to wait before automatically reloading the QVT to see if it
has been updated. Do not specify this parameter unless you actually intend to edit the timeline
at some point. Because each reload puts additional load on the remote servers, avoid using too
low an interval except in testing. Typically, you should not use an interval of less than 300 (5
minutes). When the interval is reached, the QVT is asynchronously reloaded and a
TimelineLoaded
event is fired so that the application or Web page can recreate any visual
representation of the timeline (since new shows may have been added). See also the “Open-
ended Timelines” section above for more information.
.metadata
- A URL to a QVT file containing any metadata for this timeline. See the
“ External Metadata” section below for more information.
.timestamp
- A timestamp value as a string. Typically consists of the type (UTC or day), a
number representing the UTC time in seconds, or the offset relative to the start of the day.
Optionally can include anchor and wrap flags. See “Timestamps and Anchors” for more
information. If this member is not specified, a timestamp will be calculated based on the
timestamps of the clips.
.showsTimestamp
- Like timestamp, except that its time specifies the point in time
that corresponds to the beginning of the show list. If
showsTimestamp
is present, the
QVT library will perform whatever work is necessary to ensure that the show line properly
maps to the timeline. See “Timestamps and Anchors” for more information. At this time,
only UTC timestamps are supported, so a valid use might look like
showsTimestamp:utc,1144951329
.
.timezone
- The number of hours (as a floating point number) to add to a UTC time to derive
broadcast time for this timeline. For example, for Mountain Daylight Time a QVT could include
timezone:-6.0
. If the timezone is set, then the QVT
Timezone
,
StartDatetime
, and
PosToDatetime
APIs work as expected.
.shows
- A list of shows and show metadata (see information on clip-based shows below or
the section “Shows versus Clips versus Gap Clips” above) for more information. A QVT
should not have both a top-level show list and clip-level show lists. If both are present,
however, the top-level list is used.
.clips
- An array of sub-objects, with each one corresponding to a media clip to play. Clip
objects have the following properties:
.url
- A valid QMX URL to play. If not specified, this clip is considered a gap clip.
.range
(optional) - The portion of the media to play (for example:
range:10,25
would play from time index 10 to time index 25, and then the player would move on
December 14, 2007
Confidential
Page
|
27
to the next clip). Partially specified ranges are allowed too (for example, "100," but
they take longer to load because the QVT library will download and inspect the
QMX file to discover its duration. Ranges without an end time are not allowed for
gap clips; a gap clip without an end time is removed from the QVT.
.
shows
(optional) - A list of show metadata objects. Each object should have a
.start
property, that tells the start time, in seconds, of the show relative to the
clip. Other properties can be added as custom metadata, although QVT will use the
.title
property if present. Gap clips should not have a show list.
.timestamp
- A timestamp value in seconds UTC. Used to explicitly set the
timestamp value for a clip. If no QVT timestamp is present, or if it does not specify an
offset value, this clip's timestamp will be used to calculate an overall timestamp. A
live clip is automatically given a timestamp based on the QMX start timestamp after
adjusting for the clip's range. If multiple clips have a timestamp specified, the first is
used. Note that the timestamp value given maps to the start of the selected range.
Other arbitrary properties are allowed as additional metadata; if a
.title
property is present
it is accessible via the
QVT.Title(i)
API.
Below is a sample QVT file:
{
"title":"My first QVT file",
"clips":
[
{"url":"qsp://Cool/Travel/Hawaii/output.qmx",
"range":"100,300",
"shows":
[
{ "title": "Intro" },
{
"start":50,
"title":"History
and
Heritage" },
{
"start":100,
"title":"Activities
and
Attractions" },
{ "start":180, "title":"Outro" }
]
},
{"range":"0,10", "title":"A ten second gap"},
{"url":"http://whatever/pepsi/output.qmx",
"biff":"freep",
"title":"Thousand Hand Slap", "range":"9,"},
"url":"qsp://junk/stuff/zackandcody/output.qmx",
"title":"Ugh"}
],
"next":"http://127.0.0.1/qvt/second.qvt",
"timezone":-7.0,
"author":"Dave"
}
December 14, 2007
Confidential
Page
|
28
Note in the above example that both clips and the entire QVT can have arbitrary metadata, and
that the range on a clip is completely optional. The first clip actually covers multiple distinct
segments, so it provides
.shows
to list per-show metadata. Note that the show times are
relative to the start of the clip, and that
.start
is optional for the first show (actually, even if
you specify a start value, QVT will always set the first show's start time to 0). Note that in the
last clip, the end is not specified; QVT will load the QMX file to determine its length, and then
set the clip end time automatically. In the third clip, no range is specified, so the entire content
will be played. Between the two clips is a 10-second gap.
General purpose content management and QVT creation tools will soon be available. Until
then, it can be helpful to use JavaScript's
eval
function to verify that a QVT is syntactically
correct. For example, if you have the QVT string data in a variable called raw, you can verify
that the QVT is valid with:
var obj;
eval("obj=" + raw);
alert(obj.clips.length); // and/or inspect the result in
other ways
The most common mistake when creating a QVT by hand is using single quotes around keys
and values. While valid JavaScript, it is not valid JSON—always use double quotes!
6.6 Timestamps and Anchors
A timeline can have an overall timestamp (reported by
qvt.StartTimestamp()
in seconds,
UTC) that reflects when the timeline started in actual (real-world) time. This timestamp can be
displayed to the user or used to sync to a non-QVT metadata source if needed, but note that a
timeline is not required to have a timestamp at all. If a QVT-wide timestamp is specified, it is
used. Otherwise, each clip is inspected for a timestamp property. The first one found will be
used as the timestamp, after adjusting for the duration of the previous clips (in other words, if
the timeline has clips A,B,C, and D, and C has a timestamp, then the timeline timestamp will be
C.timestamp - (A.duration + B.duration)
). Note that live clips are automatically
given timestamp properties because the QMX always gets loaded.
Currently, two types of timestamps exist: explicit time-based and day-relative. Time-based
timestamps are in seconds UTC and specified like
utc,1137687669
(meaning Jan 19, 2006
9:21:09 MST). Day-relative timestamps make the timeline appear to start relative to the start of
the day in the user's local timezone. Day-relative timestamps can also have an offset value
telling how many seconds past the start of the day the timeline starts. For example,
day,3600
means the timeline should appear to start 3600 seconds after midnight, or 1 AM in the user's
local time. If an offset is omitted, it is assumed to be 0. Day-relative timestamps are most useful
with anchors (see below).
Timelines can also be anchored to their timestamps. When a timeline is anchored, then the
timeline has a notion of "now" in timeline time, such that playback can be more or less
synchronized for all users. For example, if a timeline is anchored to 3:00 MST and a user begins
watching the timeline at 3:05 MST, starting playback with
Play(-1)
will result in playback
starting at 5 minutes into the timeline. If another user begins watching at 3:10 MST, then
Play(-1)
will result in playback starting at 10 minutes into the timeline, and both users
will be watching more or less the same point in the timeline.
December 14, 2007
Confidential
Page
|
29
If a timeline is anchored using a day-relative timestamp, then playback happens more or less at
the same local time for all users, regardless of where they are in the world. For example, a user
in Los Angeles who views the timeline at 9 AM Pacific time will see the same content as a
user in Washington D.C. who watches the timeline at 9 AM Eastern time.
Playback of anchored timelines is similar to playback of truly live content—the duration
grows over time and a user can seek to a "live" or "now" position that is not at time index 0.
Likewise, if a user tries to seek beyond "now," the requested seek position will be moved
backwards to the timeline's current "now" position. Note that this restriction should not be
used to protect content that cannot legally be played until a certain time—a malicious user
could modify the computer's local time into the future to circumvent this.
Time-based, anchored timelines should be edited to remove the anchor property once it no
longer makes sense. For example, if a timeline is anchored to Jan 1, 2005 and is only 24 hours
long, it wouldn't make sense to have the timeline still anchored when Februrary 1st arrives (or
January 2nd, for that matter). If a timeline is anchored using a fixed, time-based timestamp and a
user tries to seek to the "live" position (via
Play(-1)
), then playback begins at the very end
of the timeline (so that either a
MEDIAENDED
playstate change will happen, or playback will
move to the next timeline if a
nextURL
exists).
The following illustrates a simple, day-relative (with a 30-second offset), anchored timeline:
{
"clips":[{"url":"http://some/url/foo.qmx"}],
"timestamp":"day,30,anchor"
}
Anchored timelines can also have the wrap flag in the timestamp, which means that the start
timestamp is adjusted if the initial point of playback is beyond the end of the anchored
timeline. The net result is that it appears that the timeline looped (or wrapped around) over
and over again up until now. Take, for example, a 3-hour timeline anchored to the start of the
day. If a user tries to view the timeline at 8 AM, the timeline would already be "done" so there
would be nothing to play. With wrapping turned on, however, the QVT library would notice
this and behave as if the timeline repeated itself every 3 hours (the duration of the timeline), for
example from midnight to 3AM, from 3AM to 6AM, and from 6AM to 9AM. Because 8AM falls
into the 6–9AM timespan, the timeline would be anchored to 6AM and
Play(-1)
would
result in playback starting 2 hours into the timeline (because the current time is 8AM and the
timeline "started" at 6AM, or two hours ago).
Wrapping results in the timeline anchor shifting as needed; it does not actually cause the
timeline to play itself over and over. If the above timeline has a
nextURL
specified, then at
9AM the next QVT would be loaded and playback would go from there. If you do want the
timeline to actually play over and over again, then simply list its own URL as the next URL.
For example, the following QVT effectively creates a virtual broadcast channel that does
nothing but repeat an infomercial every hour (assume this timeline's URL is
http://ww w.biff.com/foo.qvt):
{
December 14, 2007
Confidential
Page
|
30
"clips":[{"url":"http://foo.com/hairloss.qmx",
"range":"0,3600"}],
"timestamp":"day,anchor,wrap",
"next":"foo.qvt"
}
If wrap is specified but anchor is not, the wrap flag is ignored. Note that it is valid to specify a
timestamp in an external metadata file. Also, it is valid to specify a QVT-wide timestamp with
just, for example,
anchor,wrap
—in this case the actual timestamp is assumed to be of type
UTC and will be calculated based on one of the clips.
The library makes many attempts to come up with a timeline timestamp. If no QVT-wide
timestamp is specified, and no clips have an explicit timestamp set, and no clips are live, and
no clips' QMX files are loaded for inspection, then the last clip's QMX is loaded and inspected
in order to compute a timestamp of some sort. The only case in which a timeline may end up not
having a timestamp is if all of the above are true and the last clip QMX cannot be loaded (bad
URL, for example).
If multiple clips in the timeline show up as live, all will be marked as non-live except for the
last one. In this case, it is assumed that multiple live clips exist because earlier ones are from a
crashed Atomizer or for some other reason a correct, final QMX was not published.
MN.QVT
attempts to use the clock times reported by Web servers (making the assumption that
servers generally have more accurate clocks than end-user machines). It accomplishes this by
inspecting the Date HTTP header when downloading QVT files. By using the server clock,
MN.QVT
has a better chance of making anchored timelines play back

[Seeker47]

ronmiracle,
I think you may have just claimed the prize for longest single post in VH history !

[Ethlred]

Orbit worked for me. Multiple segments so you may have let it run to get all of them as the second may not show up otherwise. Not interested enough to run the whole episode.

http://www.orbitdownloader.com/index.htm

You have to start Orbit first and then fireup the Grab++ tool. Otherwise it was surprisingly straight forward.