The Revver Website widget’s default behavior is that when the user selects a thumbnail a virtual window opens ontop of the screen and presents the movie along with its pertinent meta-data. This is done using “lightbox”, a very common javascript function seen in many websites today.

However, you may wish to use “thickbox” or “slimbox” or even your own creation entirely. You may also wish to add visual effects or maybe even not use a lightbox at all, but rather render the results into a DIV of your choosing.

Using “onShowMovie”

In fact, the widget supports all of these options, by utilizing the “onShowMovie” parameter. When set, the “onShowMovie” parameter indicates a function or callback that will be called when the thumb is selected.

the entire video object is actually passed upon thumb selection, and optionally (if an affiliate is provided) the affiliateId.

As with any callbacks, you can either have an anonymous function in-line as part of the code, or create a separate named function that accepts the video object and the affiliateId as params.

Code Examples

Using the anonymous in-line callback:

// as part of the REVVER.widget.VideoCollection call:
"onShowMovie": function (video, affiliateId) {
        document.getElementbyId('rev-player').innerHTML = "";
	revverVideo.embed( {    mediaId : video.id,
                    affiliateId: affiliateId,
                    width: 480,
                    height: 392,
                    usePrivateDiv: true,
                    divId: 'rev-player' } );
}

Using the named function:

// as part of the REVVER.widget.VideoCollection call:
"onShowMovie": displayMovie

// defined elsewhere in the JS code
function displayMovie(video, affiliateId) {
        document.getElementbyId('rev-player').innerHTML = "";
	revverVideo.embed( {    mediaId : video.id,
                    affiliateId: affiliateId,
                    width: 480,
                    height: 392,
                    usePrivateDiv: true,
                    divId: 'rev-player' } );
}

Both of the above examples perform the same function. In this case, they clear the contents then place a player into a div with the id “rev-player”. Using this model, you can create just about any functionality you like.

Video Object

The video object being passed contains the following fields:

status,
description,
views,
author,
url,
duration,
ageRestriction,
quicktimeMediaUrl,
owner,
affiliateId,
publicationDate,
modifiedDate,
keywords,
title,
credits,
thumbnailUrl,
id

Additional Help

For more detail on any of these return fields, feel free to review the JSON open.video.find specification at: http://developer.revver.com/api/json/methods#openvideofind.

Note: the returnField for thumbnailUrl uses the advanced returnField functionality and returns a thumbnail that corresponds to the size you specify. If you do not specify a size for the thumbnail, then the default size of 120×90 pixels is used.

We hope this has been useful. Please feel free to post your examples and/or comments below.

In a given hour, 100 or so videos might get updated, and rather than constantly pull the same queries over and over, it’s helpful to have a “delta” of what has changed and much like rsync, just update the information you need. This can also be useful for tracking updates made by your users.

This can be done rather easily, using the modifiedWithin query key and the ‘final’ option key.

Example:

#!/usr/bin/python

import xmlrpclib, sys

s = xmlrpclib.Server(
    'https://api.revver.com/xml/1.0?login=username&passwd=passwd'
)

query = dict(
modifiedWithin=60*60*24,  # in the last 24 hours
statuses = ['all']
returnFields = ['id',
		'title',
		'owner',
		'modifiedDate',
		'status']

videos = []

done = False
offset = 0
while not done:
page = s.video.find(query, returnFields, dict(
orderBy=('modifiedDate', False),
final=True,
offset = offset
))
offset += len(page['result'])
videos.extend(page['result'])
done = page['final']

for video in videos:
print "%-10s %-30s %-10s %-20s %s" % (
        video['id'],
        video['owner'],
        video['modifiedDate'],
        video['status'],
        video['title'])
print
print "%s videos modified since last pull" % len(videos)

Note: Be sure when using loop constructs that accept boolean values that you give yourself a maximum loop count, so in cause you mistype something you don’t end up in an infinite loop.

Revver provides a comprehensive solution for video creators, publishers and distributors to create, edit and manage their videos across multiple platforms. Revver hosts all videos for free, and “packages” video streams with dynamic advertising solutions, so that creators and distributors can profit from the ever expanding business of internet video.

The process by which a user uploads and subsequently sees their video on Revver can be confusing to the new user especially if used to sites where uploading is either not available via an API, so we’ll start with a brief description of the video upload/transcode/review system. There are FOUR stages in the process: UPLOADING, TRANSCODING, REVIEW and GOING ONLINE. The entire process may take up to 2 hours, but depending on a number of factors it could be longer.

STAGE 1: UPLOAD

The first step is the actual upload. Using a standard HTTP POST request the video data is uploaded to a server. Upon a successful upload, a videoID is assigned to the video and it is passed to the transcoding system.

STAGE 2: TRANSCODING

All Revver media is offered in both Flash and Quicktime formats. The process by which it is encoded into these different formats is known as “transcoding” (wikipedia link). The transcoding queue is processed according to a set of simple rules, and then the resulting media file is passed thru a human review process.

STAGE 3: REVIEW

The goal of this process is to ensure that the Revver library is “clean” and free of stolen or pirated content as well as to ensure that there is no pornography or hate speech . In the case of copyright violations, the process that is usually taken is that the owner of the video is notified by the Revver Review team and given opportunity to defend the copyright, or provide additional materials as may be necessary. In this case, the video receives a special status (see below) “review_verify” until it is either approved or rejected.>

STAGE 4: GOING ONLINE

Once approved by the reviewers, the video then is distributed amongst a series of media servers to improve efficiency when delivering videos via API user sites. It usually takes about 10 or 15 minutes for this stage, but this too can vary. During this time, the video (see below) will be in the status “going_online”. Once the distribution is complete, the video is then accessible via the flash player, and can be viewed on API user sites and the www.revver.com site.

In order to track this process, various “statuses” are assigned to the video as is passes through each stage. These statuses are:

uploading

When the call to video.getUploadToken is made, a new upload token is created, and the status of the videoID associated to that token is set to “uploading”.

processing

When a POST request is made to the upload server along with the token in the URL, the system checks to see if video.create has been sucessfully been called for the associated videoID, and if so, changes the status to “processing”. If not, then the videoID remains in the state “uploading” until video.create is called.

failed

For various reasons, videos may fail during the TRANSCODING stage. When this happens, the status for the video is changed to “failed” and no further processing takes place. Note: videos that fail are usually re-transcoded within a few hours or days at most, so the main reason that a video would never end up in the Revver library is if the uploading process never completed.

review

When transcoding completes, the videos are passed into a system that queues videos for our review team, and during this time, until they either approve, reject or request verification, the status remains “review”. As Revver employs a 24/7 staff of reviewers, this is usually the fastest stage of the process.

review_verify

In cases where copyright or ownership of the video content is required to be verified, the reviewer will request additional information. This request will either go directly to the video uploader’s email (if provided), and/or will be visible in the same user’s dashboard on the www.revver.com site.

rejected

If reviewers determine that the video is not appropriate content, i.e. contains hate speech, blatant copyright violations, or pornography, it will be rejected, and the status set accordingly.

going_online

After a video has passed through review, and the reviewer has approved the video for going online, the status is updated and the video is then distributed across multiple video servers.

online

Videos in the “online” status are able to be downloaded in QT format, and played with the Revver Player, or Revver Player Component accordingly. All other statuses are invalid for playing videos.

offline

Videos can be taken ‘offline’ manually, and API developers can request that revver automatically set their videos to offline. This is useful when videos are being uploaded as part of a series, and the developer or content owner wishes to control the release of the videos accordingly.

video.getUploadTokens()

The very first step required in order to upload a video is for the user to request a video upload token. The video.getUploadTokens function can return multiple tokens at a time, so the first parameter is count. The second parameter is actually optional, and like all the “options” in the API, it takes a struct, even though it has only one key, “owner”. This parameter is used by the API to determine who the video is owned by, and when building video portals with child users, this becomes an important feature. An owner is assumed to be a child users of the API user, and an “invalid owner” error will be thrown if the API user does not have a child user with the given name.

A common mistake here is to put the owner name that is the same as the API user. The API will see this as the child user and not as the API user, so if you have an API user “myusername”, then the owner will be assumed to be the actual user “myusername@myusername” which will likely not have the expected results.

Also, the return from this function will always be an array. The first element is a string indicating the URL to which you must POST the actual file, and the second element is itself an array (even if you only requested 1 token) of tokens.

i.e.

video.create()

Once you’ve gotten your token, you can now create the meta-data for your video. Without meta-data, the video will never move past the “uploading” stage into processing, but you can run video.create() either before or after your file gets uploaded, so you could create a “bulk upload” tool if you wanted that processed multiple sets of video meta data then sent all the files to the server at once.

video.create takes 4 parameters, and an optional options struct. The first param is the token, the second the title, the third is an array of keywords and the fourth parameter is a RECOMMENDATION for age restriction that is passed to our review team. Additional meta-data is included in the options struct. Other than credits, url, description and author, there is also a “references” id which refers to another video id. This is useful for creating “video responses”.

Uploading Videos

Once you’ve got an upload token, you can upload your physical media. The return from the video.getUploadToken() function includes the URL of the upload server.

For each individual token returned, the URL for upload is the upload server and then the token and a “urlRedirect” querystring that is the absolute URL where the upload server will redirect after a successful upload. When redirecting the server will add a “success” variable to your URL. This variable is either true or false. No other data is sent.

i.e.:

HTML Forms vs. Flash Uploader

Once you have your URL and token, you can create an upload form.

i.e.

If you prefer, you can use the Revver flash uploader, which is documented at http://developer.revver.com/widget/upload.