F4MElement Specification

F4MElement Specification
View All Specifications
F4MElement Specification
Revision History
Date Author Notes
12/18/09 oconnell Created.
Summary of Feature
The F4MLoader (Manifest Loader) is the implementation of the Flash Media Manifest (F4M) file format.
The F4MLoader will take a manifest file and load it, and create the proper resource for the media element, allowing DRM and MBR
information to be specified by a single manifest file.
This feature introduces the LoadableProxyElement class, which can be used when the actual MediaElement to play is unknown until the
loading of something (like an external manifest file) is complete.
User Stories
User Story: As an OSMF developer, I'd like my OSMF application to be able to load and play media using the new Flash Media Manifest
format. I expect the loading and playback to be consistent with OSMF design metaphors. The loaded media type is unknown until the
manifest loads, meaning that video or audio could be created from the F4M file.
Detailed Description
This feature will include a new Loader, the F4MLoader. It will work with the newly introduced LoadableProxyElement. The
LoadableProxyElement will use the F4MLoader to create a media element. The LoadableProxyElement will then attempt to load the
MediaElement created by the F4MLoader. This flexible design allows the F4MLoader to create any type of element (video, audio etc.), and
use any type of loader (NetLoader or DynamicStreamingNetLoader). The F4MLoader will use a MediaFactory to make these decisions, such
as which loader to use. The specific resource that the F4MLoader will use is a vanilla URLResource that points to the manifest file via HTTP.
The F4MLoader will implement canHandleResource() to detect the .f4m file extension as well as the MIME type for the manifest format.
The developer will need to have a valid manifest file written, which is required to use the F4MLoader. Any other media sent to the F4MLoader
will fail to load, and raise an error.
The F4MLoader accepts subclip metadata on its resource. The resource pointing to an f4m file can contain a start and end time, specified by
a keyvalue facet, using the Subclip namespace. The API for subclips is the same as the one used on VideoElement. See the subclip spec for
more info. Here is an example of subclip for an f4m file:
var res:URLResource = new URLResource(new URL("http://myserver.com/f4mFiles/shuttle-mbr.f4m"));
var kvFacet:KeyValueFacet = new KeyValueFacet(MetadataNamespaces.SUBCLIP_METADATA);
kvFacet.addValue(MetadataNamespaces.SUBCLIP_START_ID, 10);
kvFacet.addValue(MetadataNamespaces.SUBCLIP_END_ID, 30);
res.metadata.addFacet(kvFacet);
API Description

package org.osmf.manifest
{
/**
* The F4MLoader will load the Flash Media Manifest format
* files, generate a NetLoaded context corresponding to the resources
* specified in the f4m file.
*/
public class F4MLoader extends MediaElementLoader
{
// MimeType
public static const F4M_MIME_TYPE: String = "application/f4m+xml" ;
/**
* Generate a new F4MLoader.
* @param factory The factory that is used to create MediaElements based on the
* media specified in the manifest file. A default factory is created for the base OSMF media
* types, Video, Audio, Image, and SWF.
*/
public function F4MLoader(factory:MediaFactory = null);
}
}
package org.osmf.proxies
{
/**
* The LoadableProxyElement will use a custom Loader to load and create a media element.
* The MediaElement will them be used as the proxies wrapped element. The Loader needs
* to return a MediaElementLoadedContext.
*/
public class LoadableProxyElement extends ProxyElement
{
/**
* Creates a new LoadableProxyElement. The Loader needs to return a MediaElementLoadedContext.
*/
public function LoadableProxyElement(loader:MediaElementLoader);
}
/**
* This context carries over the reference to MediaElements created
* by loaders.
*/
public class MediaElementLoadedContext implements ILoadedContext
{
/**
* Creates a new element context.
*/
public function MediaElementLoadedContext(element:MediaElement);
/**
* The Associated MediaElement
*/
public function get element():MediaElement;
}
/**
* The Base class for Chained loaders that are used by the
* LoadableProxyElement.
*/
public class MediaElementLoader extends LoaderBase
{
/**
* Creates a new MediaElementLoader
*/
public function MediaElementLoader();
}
}
Example Usage

private var factory:MediaFactory = new DefaultMediaFactory();
public function init():void
{
factory.addMediaInfo( new MediaInfo( "org.osmf.f4m" , new F4MLoader(factory), createProxyElement));
var urlResource:URLResource = new URLResource( new URL('http: //example.com/manifest.f4m'));
mediaPlayer.element = factory.createMediaElement(urlResource);
}
public function createProxyElement():MediaElement
{
return new LoadableProxyElement( new F4MLoader(factory));
}
Plugin Considerations
Plugins may use the F4MLoader like any other loader in the MediaFramework. It should work out of the box.
Standards Considerations
N/A
Backwards Compatibility
New Feature, N/A
Syntax Changes
N/A
Behavior Changes
N/A
Deprecations
N/A
Future Version Proofing
Most code is kept internal to the org.osmf.manifest package. The parser and object model are marked as internal. The only new public API is
the constructor for F4MLoader and the LoadableProxyElement and related classes.
Implementation Details
The F4MLoader is implemented using a supporting ManifestParser, and Manifest object model. Once the parse takes place, the object model
is converted into a StreamingURLResource or DynamicStreamingResource, which is passed to a new NetLoader. Once the new NetLoader
is complete, the load is finished for the F4MLoader.
The LoadableProxyElement is implemented using the ProxyElement as a super class. The setupOverriddenTraits() method adds the
LoadTrait, which will kick off the manifest load. Once the manifest is loaded the MediaElement is assigned as the proxy's wrapped element.
The Load then is kicked off for the MediaElement (if loadable).
Testing Impact
The testing should consist of sending all variations of the F4M files to the manifest parser. The errors that occur will need to surface as Load
Errors, this includes parse errors. Once the Manifest is successfully parsed the NetLoader should properly load the correct media stream,
which should be tested. Many parser tests will be covered in Unit Testing. Conversion from the Manifest Object Model to a
StreamingURLResource will also need to be unit tested by the dev, as well as black box tested by QE.
Testing should also cover the ability to use the DynamicStreamingNetLoader, and other custom Loaders. Sound should also be able to
appear in a manifest file, and work (as long as the MediaFactory is setup to handle this).
Accessibility

N/A
Performance
Manifest file parsing shouldn't introduce performance issues. Loading may appear slightly longer since there are two required round trips to
the server if a manifest file is introduced.
Internationalization/Localization
No locale specific information in this feature.
Security
This feature doesn't touch any security features, other than DRM, which is interfaced at a high level, on top of already existing DRM APIs.
Legal Issues
N/A
Impacts to Other Products
N/A
Internal Products
N/A
External Partners
N/A
Documentation
The F4M file format will need to be documented. The F4MLoader has simple self documenting ASDoc.
Sample Apps
Examples will be added to ExamplePlayer.
Open Issues
None
Closed Issues
None
References
N/A
Copyright
Copyright © 2006-2009 Adobe Systems Incorporated. All rights reserved. This material may not be copied, photocopied, reproduced,
translated, or converted to any electronic or machine-readable form in whole or in part without written approval from Adobe Systems
Incorporated. Notwithstanding the foregoing, a person obtaining an electronic version of this material from Adobe may print out one copy
provided that no part may be printed out, reproduced, distributed, resold, or transmitted for any other purposes, including, without limitation,
commercial purposes, such as selling copies of this documentation or providing paid-for support services.
Trademarks
Adobe, ActionScript, Flash, Flash Media Server, Flash Player, PostScript, and XMP are either registered trademarks or trademarks of Adobe
Systems Incorporated and may be registered in the United States or in other jurisdictions including internationally. Other product names,

logos, designs, titles, words, or phrases mentioned within this publication may be trademarks, service marks, or trade names of Adobe
Systems Incorporated or other entities and may be registered in certain jurisdictions including internationally. No right or license is granted to
any Adobe trademark.
Third-Party Information
This specification may contain links to third-party websites that are not under the control of Adobe Systems Incorporated, and Adobe
Systems Incorporated is not responsible for the content on any linked site. If you access a third-party website mentioned in this guide, then
you do so at your own risk. Adobe Systems Incorporated provides these links only as a convenience, and the inclusion of the link does not
imply that Adobe Systems Incorporated endorses or accepts any responsibility for the content on those third party sites. No right, license or
interest is granted in any third party technology referenced in this guide.
NOTICE: THIS PUBLICATION AND THE INFORMATION HEREIN IS FURNISHED "AS IS", IS SUBJECT TO CHANGE WITHOUT
NOTICE, AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY ADOBE SYSTEMS INCORPORATED. ADOBE SYSTEMS
INCORPORATED ASSUMES NO RESPONSIBILITY OR LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO WARRANTY
OF ANY KIND (EXPRESS, IMPLIED, OR STATUTORY) WITH RESPECT TO THIS PUBLICATION, AND EXPRESSLY DISCLAIMS ANY
AND ALL WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSES, AND NONINFRINGEMENT OF THIRD
PARTY RIGHTS.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, CA 95110, USA
Published July 2009