The nice thing about this is that every visitor will be able to stream individual videos, as opposed to the version 1 viewer that could only set a QuickTime Progressive Download url for all residents in a Second Life location.

Here’s a sample prim textured with a player and  some navigation prims that would make sense in a 3D environment.

In the screen shot above, you can see the metadata text transcription window on the right of the video loaded into Premiere.

The metadata can be incorporated into the video file as cue points, or can be exported to an XML file.

The latter gives us some interesting possibilities for playback and navigation within a Brightcove Player.

You can extract the cue point information from an F4V or FLV created with Premiere by using SoundBooth or your own extraction tool based on the Flash media API.

If you use SoundBooth, the extracted XML format looks something like this:

Once we know this, it is easy to build a simple search and index plugin for BEML

Sample code:

The easiest way for a user to install a Brightcove plugin is through the player property window in Brightcove studio in stead of having to create a BEML template that loads the external swf.

By default, this plugin interface is intended for invisible add-ons, such as an analytics connector. However, it is possible to surface plugins added in this way by getting a reference to the player’s Stage.

This article provides a sample player with a visible plugin added in this way as well as some sample code.

This player receives the plugin that is configured in the screen shot above

There are some considerations for the developer: adding visible plugins in this way will not give you the automatic positioning offered through BEML, but getting the player’s dimensions from the Stage reference should give you enough leverage to work around that.

Here is the full code for the plugin:

This screen shot shows a slow-motion control incorporated into a Brightcove Player using BEML.

The full code is listed below.

In some cases, you may need to display subtitles in more than one language, or in different notations – but not necessarily for the entire video. The music video above illustrates this case: it sometimes has three subtitle text channels: Japanese Kanji, Romaji Transcription, and an English translation, but some of the song’s lines are only in English. In such situations, I believe it’s more efficient to use time codes and external subtitle text files than cue points, and to “compose” a joint subtitle text file server-side.

This BEML player uses a plugin that checks for external .srt file(s) for a video being loaded. As the .srt is a format that can be extracted from DVDs easily, it requires very little configuration other than a base URL and a file naming convention for the subtitles to be pulled in.

To show the per-video dynamic subtitle loading, I’ve also provided subtitles for the “Puffy – Dareka Ga” listed in related videos for this player.

There are two parts to making this work: first, we need to create a BEML plugin, I’ve done this in Flex, and provided the framework for you to integrate any business logic you may want to trigger the JavaScript call by getting the references to the Brightcove Player.

The main things to include to call external JavaScript are:

and the bridge to the external JavaScript:

Second, we need to add a JavaScript function for the plugin to call to the embedding HTML page, something like:

The full code contains a skeleton for handling loading and setting up the plugin correctly in a Brightcove player:

Introduction

Flash Player 10 and Adobe AIR 1.5 introduce a new communications protocol called the Real-Time Media Flow Protocol (RTMFP). The most important features of RTMFP include low latency, end-to-end peering capability, security and scalability. These properties make RTMFP especially well suited for developing real-time collaboration applications by not only providing superior user experience but also reducing cost for operators.

In order to use RTMFP, Flash Player endpoints must connect to an RTMFP-capable server, such as the Adobe Stratus service. Stratus is a beta, hosted rendezvous service that aids establishing communications between Flash Player endpoints. Unlike Flash Media Server, Stratus does not support media relay, shared objects, scripting, etc. So by using Stratus, you can only develop applications where Flash Player endpoints are directly communicating with each other.

Connecting to the Stratus service and creating end-to-end media streams are analogous to working with Flash Media Server. Please note that you must use ActionScript 3.0 with either Flash Professional CS4 or Flex Builder 3 targeting Flash Player 10 or AIR 1.5.

For details, check these resources:

• Adobe Labs Stratus Home Page

• Stratus service for developing end-to-end applications using RTMFP in Flash Player

• Stratus Sample Application

Please read these carefully as I’m not going to repeat what’s described there.

The Callback Script

The python callback script (reg.cgi) included with the sample source is a bit cryptic:

So let’s see if we can make a better documented PHP/MySQL equivalent of this.

The Database

I’ve created a database in MySQL using the following script:

The appid field is not really required, I plan to use it to distinghuish between connects from various apps.

Callback Scenarios

So far I’ve found three callback scenarios:

• The user connects
• The user disconnects
• The user calls another user (by passing the username)

The user connects

The REST-based call Stratus will make to your callback URL looks like this:

http://your.domain/reg.php?username=foo&identity=1234

Stratus expects you to return a simple XML document:

where updated is true or false depending on whether the database was updated.

The user disconnects

Exactly the same REST call as for a connect, except that the identity value will be ZERO.

The user calls another user

The REST-based call Stratus will make to your callback URL looks like this:

http://your.domain/reg.php?friends=foo

Stratus expects you to return a simple XML document:

PHP Code

I’m using a fairly straightforward Database abstraction class here. There’s also a simple LogFile() function in the code that dumps the entire callback request to a text file. Zipped code with my database class and XML templates is here.

• This article is NOT a review of the effectiveness of SWF Protection tools, there are plenty of (endless) discussions on that topic on specialized forums.
• This approach is NOT my recommended one for creating User Generated Content upload widgets. I still believe using a secured mid-tier upload server is a better model. Event with a protected SWF, a proxy tool like Charles or WireShark will give a hacker all the information he needs to get your token if you do not protect your sensitive Widget/Server communications.

Why would you do this?

The short answer is that the SWF format is a pseudo-compiled, documented file format. This implies that it is relatively easy to reverse engineer a SWF file. Just Google “swf decompilers” and look at the results. There are literally dozens of tools that allow anyone to retrieve the complete source code of a SWF. Regarding BEML Widgets, this may pose some security threats if for example you want to:

• Create a video upload widget that uploads straight into your Brightcove account. Again, SWF protection by itself is NOT the approach I would recommend, as this requires including/sending a Write Token to use the Media API in your SWF.
• Create a widget that interfaces with your backend and that contains configuration information you want to give some level of protection
• Create a widget that represents a considerable investment or effort, and by consequence you want to protect from being duplicated

to name but a few.

How does it work?

There are mainly two kinds of SWF protection mechanisms: encryption and obfuscation. The better protection tools apply both mechanisms.

Encryption makes code completely unreadable, but requires to keep the decryption-key with the encrypted data. So, an automated tool could be created to decrypt the code, leaving the fully unencrypted, unobfuscated code in plain view.

Obfuscation is the concealment of the code’s meaning, making it confusing and harder to understand. It’s not encryption, but in the context of code, it might be better.

Note that not even the combo of encrypt+obfuscate is 100 percent waterproof. The goal is to make the process of reverse engineering extremely time consuming and painful so that it is not worth the effort.

The Widget Code

The widget we’ll use in this example is a simple Flex AS3 application:

The BEML Code

The BEML with the widget plugged in looks is as simple as it gets:

Building a Secured SWF from your AS3 code

To make a secured version of your BEML widget, you will need a protection tool. For this article, I’ve used KindiSoft’s SecureSWF, as it has an evaluation version that is not limited in time or number of uses and allowed for easy highlighting of the minor tweakings you will need to do to get a protected SWF working as a BEML widget.

Download and install a demo version of this tool. Run it, and add your SWF file to the empty Project:

If you like, click “Protect SWF Files” and try running this BEML player with a protected version of your SWF, but it won’t work. You will see your browser making the load request, but the widget will not manifest. What’s going on here?

This tool uses the encrypt+obfuscate tandem mentioned earlier. This means that the original variable, component and function names no longer exists in the obfuscated ActionScript. The Brightcove Player you are pluggin this widget into tries to call the setInterface() function, but it has been obfuscated. So your secured widget is loaded, but it is not passed a reference to the player correctly.

Defining Identifier Renaming Exceptions

What we need to do is exclude the functions that the Brightcove Player needs from being obfuscated. To do this, select the Identifiers Renaming tab in the tool, and select your SWF in the treeview displayed on this page. Then uncheck the setInterface() and streamStart() functions. Now protect your SWF file again and try loading it into a player. It should work now.

I’ve deliberately taken an example where the widget is adding some listeners, in this case for the VideoPlayer.streamStart event. As you can see, this implies that the exceptions you need to define will vary from widget to widget. Basically, everything that adds a listener function must have the same name as the one you specify in the the event listener registration.

I’ve also found that in most cases you will need to disable the Additional renaming options (rename protected namespaces, remove function parameters) for a Widget to be manifested properly with a reference to the player.

Had a little fun with this over the weekend. In another life I used my Amiga to superimpose Pong on MTV. Well, no need for that anymore in the 21st Century. This is the way Pong should be played. Gratz to anyone who can beat the computer while the Stakker video is playing!
WARNING: This WILL fry your brain…do not play this if you have epilepsy.