Configure HTTP Dynamic Streaming and HTTP Live Streaming

Overview of HTTP Dynamic Streaming and HTTP Live Streaming

Streaming media over HTTP

Delivering content over HTTP is usually called “progressive download”. The content must transfer from the server to the client in a progression from the beginning to the end of a file. A client cannot seek to a forward location until that location and all the data before it has downloaded.

Delivering content over RTMP is called “streaming”. The client creates a socket connection to the server (such as Flash Media Server) over which the content is sent in a continuous stream. The client can seek to any point in the content instantly, regardless of how much data has been transferred.

Adobe HTTP Dynamic Streaming combines these approaches to introduce HTTP streaming to the Flash Platform. HTTP Dynamic Streaming packages media files into fragments that Flash Player clients can access instantly without downloading the entire file. Adobe HTTP Dynamic Streaming contains several components that work together to package media and stream it over HTTP to Flash Player and AIR. HTTP Dynamic Streaming supports multi-bitrate streaming, DVR, and Adobe® Flash® Access™ protection.

In Flash Media Server 4.5, Adobe HTTP Dynamic Streaming adds support for Apple HTTP Live Streaming. Use the same HTTP Dynamic Streaming workflow to package and stream live and on-demand content to all devices that support Apple HTTP Live Streaming. Apple HTTP Live Streaming includes live and on-demand media.

Note: Flash Media Server does not support adding Timed Metadata for HTTP Live Streaming.

HTTP Dynamic Streaming components

The Adobe HTTP Streaming solution contains the following components:

Live Packager
Live Packager is a Flash Media Server application installed to rootinstall/applications/livepkgr. The server ingests a live stream over RTMP and the Live Packager translates it into F4F files and MPEG-2 TS files in real-time.

F4F HTTP Module
An Apache HTTP Server module that serves files to Flash Player and AIR. The F4F module (also known as the HTTP Origin Module), serves live content. It also serves on-demand content that was packaged offline with the File Packager tool.

The F4F HTTP Module installs with Flash Media Server 4 and later to rootinstall/Apache2.2/modules/mod_f4fhttp.so. The module is also available from adobe.com as a stand-alone Apache module.

HLS HTTP Module
An Apache HTTP Server module that serves files to iOS devices and Mac OS.

The HTTP HLS Module installs with Flash Media Server 4.5 and later to rootinstall/Apache2.2/modules/mod_hlshttp.so. It is not available as a stand-alone Apache module.

JIT HTTP Module
An Apache HTTP Server module that packages on-demand files just-in-time and serves them to Flash Player and AIR. “Just-in-time” means that media files are packaged in real-time when clients request them.

The JIT HTTP Module installs with Flash Media Server 4.5 and later to rootinstall/Apache2.2/modules/mod_jithttp.so. It is not available as a stand-alone Apache module.

File Packager
A command-line, offline tool that translates on-demand media into F4F fragments. The File Packager is located in the rootinstall/tools/f4fpackager folder and is available from adobe.com.

OSMF media players
There are several media players built on the Open Source Media Framework (OSMF) that support HTTP Dynamic Streaming to Flash Player and AIR. See Pre-built media players.

F4F File Format Specification
The F4F file format describes how to divide media content into segments and fragments. The Live Packager, the File Packager, and the JIT HTTP module output content based on this specification. Each fragment has its own bootstrap information that provides cache management and fast seeking. For more information, see F4F File Format Specification.

F4M File Format Specification
The Flash Media Manifest file format contains information about a package of files that the HTTP Origin Module can serve. Manifest information includes codecs, resolutions, and the availability of files encoded at multiple bit rates. Manifest information also includes DRM data. The media player uses the F4M file to play a piece of media. For more information, see F4M File Format Specification.

Flash Access
Flash Access delivers protected media to Flash Player. To use HTTP Dynamic Streaming with Flash Access, use the File Packager and Flash Media Server to both package and encrypt content. For more information, see Protecting content with Flash Access.

Flash Media Server 4.5 adds support for Flash Access level protection without using a Flash Access server. See Configure protected HTTP Dynamic Streaming (PHDS) and Configure protected HTTP Live Streaming (PHLS).

Workflow for streaming live media over HTTP

The best way to experience the workflow for live HTTP streaming is to complete a tutorial. See Stream live media (HTTP).

The following is the workflow for all Adobe HTTP Dynamic Streaming and Apple HTTP Live Streaming use cases:

  1. Use the default live event or create a live event.

    The default live event is rootinstall/applications/livepkgr/events/_definst_/liveevent. Each live event contains configuration settings for one set of content. For more information, see Create and configure live events.

  2. (Optional) To configure multi-bitrate streaming, use the Set-level F4M/M3U8 File Generator tool to generate an set-level manifest file. The set-level manifest file contains information about each stream. See Publish and play live multi-bitrate streams over HTTP.

  3. (Optional) To configure DVR for Adobe HTTP Dynamic Streaming, create a set-level manifest file.

    To configure a Sliding Window for Apple HTTP Live Streaming, configure the httpd.conf, Application.xml, or Event.xml file.

    See Configure DVR (HDS) and Configure a sliding window (HLS).

  4. (Optional—Adobe HTTP Dynamic Streaming) To encrypt content for protected HDS, see Configure protected HTTP Dynamic Streaming (PHDS).

    To encrypt content for use with Flash Access, edit the Event.xml file. See Encrypt content for Flash Access protection.

  5. (Optional—Apple HTTP Live Streaming) To encrypt content for Apple HTTP Live Streaming, see Protect content for Apple HLS.

  6. Create a crossdomain.xml file and copy it to the rootinstall\webroot folder.

    A crossdomain.xml file allows Flash Player clients hosted on other domains to access data from this domain. For more information, see Website controls (policy files) in the ActionScript 3.0 Developer’s Guide.

  7. Publish a stream to the server.

  8. (Adobe HTTP Dynamic Streaming) Use Strobe Media Playback to play media. Strobe Media Playback is installed with Flash Media Server.

  9. (Apple HTTP Live Streaming) Play the content on iOS or MacOS.

    For supported devices, see Apple HTTP Live Streaming documentation.

Workflow for streaming on-demand media over HTTP

The best way to experience the workflow for on-demand HTTP streaming is to complete a tutorial. See Stream on-demand media (HTTP).

The following is the workflow for Adobe HTTP Dynamic Streaming and Apple HTTP Live Streaming use cases:

  1. Encode media files and copy them to the rootinstall/webroot/vod directory on Flash Media Server.

    To configure this location, see Configure the location of content (HDS and HLS).

  2. (Optional) To configure multi-bitrate streaming, use the Set-level F4M/M3U8 File Generator tool to generate a set-level manifest file. See Play on-demand multi-bitrate media files over HTTP.

  3. (Optional—Adobe HTTP Dynamic Streaming) To encrypt content for protected HDS (without Flash Access), see Configure protected HTTP Dynamic Streaming (PHDS).

    To encrypt content for use with Flash Access, edit the jit.conf file. See Encrypt content for Flash Access protection.

  4. (Optional—Apple HTTP Live Streaming) To encrypt content for Apple HTTP Live Streaming, configure the jit.conf file or the Apache httpd.conf file. See Protect content for Apple HLS.

  5. Create a crossdomain.xml file and copy it to the rootinstall\webroot folder.

    A crossdomain.xml file allows Flash Player clients hosted on other domains to access data from this domain. For more information, see Website controls (policy files) in the ActionScript 3.0 Developer’s Guide.

  6. (Adobe HTTP Dynamic Streaming) Use Strobe Media Playback to play media. Strobe Media Playback is installed with Flash Media Server.

  7. (Apple HTTP Live Streaming) Play the content on an iOS device or on MacOS.

    For supported devices, see Apple HTTP Live Streaming documentation.

Differences in HTTP Dynamic Streaming between Flash Media Server 4.0 and 4.5

The following are differences in HTTP Dynamic Streaming (HDS) between Flash Media Server 4.0 and 4.5:

Create and configure live events

You can use the livepkgr application to serve an unlimited number of live streaming events over HTTP (for example, a debate, a sporting event, and a town hall meeting). Each live streaming event requires its own configuration settings for multi-bitrate streaming, DVR, and content protection.

A live event is a configuration level within the livepkgr application. Like a Flash Media Server application, a live event is a folder on the server. The folder contains two configuration files: Manifest.xml and Event.xml. Use these configuration files to configure a set of streams.

Also like a Flash Media Server application, the name of the live event folder is the name of the live event. The Flash Media Server application that packages live content for HTTP streaming is called “livepkgr”. The livepkgr application contains a live event called “liveevent”:

rootinstall/applications/livepkgr/events/_definst_/liveevent

Note: You can configure the location of the “applications” folder. You can also configure virtual directory mappings for the “streams” folder. However, you cannot configure virtual directory mappings for the “events” folders.

Streams in a live event are packaged as fragments and written to disk. A live event (the stream content and the metadata) exists until you delete it. A media player can access the content after the source stream has stopped publishing.

Create a live event

For each live streaming event, create a live event folder.

  1. Create the following “events” folder structure in the livepkgr application folder:

    rootinstall/applications/livepkgr/events/applicationinstancename/liveeventname

    The following is a new live event called “liveevent2”:

    rootinstall/applications/livepkgr/events/_definst_/liveevent2

    You can also create a live event for a different instance of the livepkgr application, as in the following:

    rootinstall/applications/livepkgr/events/anotherappinstance/liveevent

  2. Copy the Events.xml file from the default liveevent folder to the new folder:

    rootinstall/applications/livepkgr/events/_definst_/liveevent2/Events.xml

  3. Copy the Manifest.xml file from the default liveevent folder to the new folder:

    rootinstall/applications/livepkgr/events/_definst_/liveevent2/Manifest.xml

  4. Open the Events.xml file in a text editor and change the event name:

    <Event> 
        <EventID>liveevent2</EventID> 
        <Recording> 
            <FragmentDuration>4000</FragmentDuration> 
            <SegmentDuration>400000</SegmentDuration> 
            <DiskManagementDuration>3</DiskManagementDuration> 
        <Recording> 
    </Event>

Configure a live event

For information about the features you can configure in the Event.xml file, see Configure live HTTP streaming at the event level (Event.xml).

Write server-side code to assign a stream to a live event

Important: You do not need to write server-side code for HTTP Dynamic Streaming. The livepkgr application has a Server-Side ActionScript file that assigns streams to a live event. To see the code, open rootinstall/applications/livepkgr/main.asc in a text editor. Read this section to understand the code.

The Live Packager processes streams that are prefixed with f4f:. Flash Media Live Encoder doesn’t support the f4f: prefix so you must add it to the stream name in a server-side script or in a Flash Media Server Authorization Plug-in.

An application can contain more than one live event. For that reason, a stream published to an application is not associated with a live event by default. Use a server-side script or the Flash Media Server Authorization Plug-in (not both) to associate a live stream with a live event. You can associate a live stream with only one live event.

Associate a stream during the publish event. When the stream is published and associated, the server creates a stream record file (.stream) for the stream in the event directory:

applications/appname/events/appinstancename/liveeventname/livestream.stream

The stream record file contains information about the location of the packaged stream files. The HTTP Origin Module uses this information to generate an .f4m manifest file. For more information, see Understanding the application flow for live HTTP Dynamic Streaming.

Use Server-Side ActionScript

To see an example of this code, open rootinstall/applications/livepkgr/main.asc in a text editor.

 In the Server-Side ActionScript code, use the application.onPublish event to do the following:
  • Use the Stream.liveEvent property to associate a live stream with a live event before the server starts recording.

  • Add the f4f: prefix to the stream name. This tells the server to package the stream.

  • Call Stream.record() to record the stream.

Use an Authorization Plug-in

To perform these tasks with an Authorization plug-in, you must write the plug-in code.

 In the Authorization Plug-in code, use the E_PUBLISH event to do the following:
  • Set the F_STREAM_TYPE field to "f4f".

  • Set the F_STREAM_LIVE_EVENT field to "liveeventname". This example uses “liveevent”.

  • Set the F_STREAM_PUBLISH_TYPE field to 0 which means "record".

The following is sample C++ code that handles the E_PUBLISH event:

case IFmsAuthEvent::E_PUBLISH: 
{ 
    // The name of the FMS app to which the live stream is published. 
    char* pLiveApp = "livepkgr"; 
    // The stream type used for HTTP Dynamic Streaming. 
    char* pStreamType = "f4f"; 
    // The name of the live event defined in the livepkgr app. 
    char* pLiveEvent = "liveevent"; 
    // The Auth Plug-in affects all apps on the server. 
    // We only want to process streams published to the livehttp app. 
    char* pAppName = getStringField(m_pAev, IFmsAuthEvent::F_APP_NAME); 
    if (pAppName && !strncmp(pAppName, pLiveApp, strlen(pLiveApp))) 
    { 
        // Set the stream type. 
        setStringField(m_pAev, IFmsAuthEvent::F_STREAM_TYPE, pStreamType); 
        // Set the publish type to record. 
        //0 record, 1 append, -1 live 
        setI32Field(m_pAev, IFmsAuthEvent::F_STREAM_PUBLISH_TYPE, 0); 
        // Associate the stream with a live event. 
        setStringField(m_pAev, IFmsAuthEvent::F_STREAM_LIVE_EVENT, pLiveEvent); 
    } 
} 

Content storage (HDS and HLS)

Configure the beginning of the request URL

When a media player requests content from the server, it passes the server a request URL. The section of the request URL following the server name (and optional port number) is defined in the Location directive path in the Apache httpd.conf file. For example, the following is the Location directive for HDS on-demand streaming:

<IfModule jithttp_module> 
<Location /hds-vod> 
    HttpStreamingJITPEnabled true 
    HttpStreamingContentPath "../webroot/vod" 
    JitFmsDirPath ".." 
    Options -Indexes FollowSymLinks 
</Location> 
</IfModule>

When Apache receives a request with the path /hds-vod, it uses the jithttp_module (just-in-time) to process the request. The jithttp_module uses the values of the directives nested within the Location directive.

To configure HTTP streaming for multiple tenants, or for multiple applications, add Location directives with different paths. The following table lists the syntax for request URLs, the Location directive paths are in bold:

Streaming type

Request URL syntax

Adobe HDS live

http://<fms-dns-or-ip>/hds-live/livepkgr/<appinstname>/<eventname>/<streamname>.f4m

Apple HLS live

http://<fms-dns-or-ip>/hls-live/livepkgr/<appinstname>/<eventname>/<streamname>.m3u8

Adobe HDS on-demand with just-in-time packaging

http://<fms-dns-or-ip>/hds-vod/<streamname>.<fileextension>.f4m

Apple HLS on-demand

http://<fms-dns-or-ip>/hls-vod/<streamname>.<fileextension>.m3u8

Add a Location directive
Note: This task uses HDS on demand, but the steps apply to all types of HTTP streaming.
  1. Open rootinstall/Apache2.2/conf/httpd.conf in a text editor.

  2. Location the Location directive for the streaming type you want to edit, copy it, and paste it.

  3. For example, to create a Location for HDS on-demand streaming, copy the /hds-vod section and paste it underneath the existing section.

    <IfModule jithttp_module> 
    <Location /hds-vod> 
        HttpStreamingJITPEnabled true 
        HttpStreamingContentPath "../webroot/vod" 
        JitFmsDirPath ".." 
        Options -Indexes FollowSymLinks 
     
    # Uncomment the following directives to enable encryption 
    # for this location. 
    #   EncryptionScope server 
    #   ProtectionScheme phds 
    </Location> 
    </IfModule>
  4. In the copied section, change the Location path to /flash-vod. You can also edit the HttpStreamingContentPath directive to change the location of the on-demand media on disk.

    <IfModule jithttp_module> 
    <Location /flash-vod> 
        HttpStreamingJITPEnabled true 
        HttpStreamingContentPath "../webroot/vod2" 
        JitFmsDirPath ".." 
        Options -Indexes FollowSymLinks 
     
    # Uncomment the following directives to enable encryption 
    # for this location. 
    #   EncryptionScope server 
    #   ProtectionScheme phds 
    </Location> 
    </IfModule>
    Note: To change the location of content for live streaming, see Configure the location of live HDS and HLS content.
  5. Create the rootinstall/webroot/vod2 folder and copy the sample1_1500kbps.f4v file to it from the /webroot/vod folder.

  6. Restart Apache HTTP Server. The service name is FMSHttpd.

  7. Double-click rootinstall/samples/videoPlayer/videoplayer.html to open the Flash Media Server sample video player.

  8. Enter the following in the Stream URL text box:

    http://localhost/flash-vod/sample1_1500kbps.f4v.f4m

    You can play any file from the /webroot/vod2 folder.

Configure the location of on-demand HDS and HLS content

To configure the location of on-demand content on disk, edit the Apache httpd.conf file. Use the following directives:

Directive

Description

HttpStreamingContentPath

The root location of the streams. This value can be absolute or relative to the Apache root folder.

By default, the location for on-demand HDS and HLS is "../webroot/vod".

  1. Open rootinstall/Apache2.2/conf/httpd.conf

  2. To change the location on the server where media is stored for on-demand streaming, edit the HttpStreamingContentPath directive. For example, the following changes the location to c:\hds_vod_content:

    <IfModule jithttp_module> 
    <Location /hds-vod> 
        HttpStreamingJITPEnabled true  
    #    HttpStreamingContentPath "../webroot/vod" 
        HttpStreamingContentPath "C:\hds_vod_content" 
        JitFmsDirPath ".." 
        Options -Indexes FollowSymLinks 
     
    # Uncomment the following directives to enable encryption 
    # for this location. 
    #   EncryptionScope server 
    #   ProtectionScheme phds 
    </Location> 
    </IfModule> 
     
    <Location /hls-vod> 
        HLSHttpStreamingEnabled true 
        HLSMediaFileDuration 8000 
    #    HttpStreamingContentPath "../webroot/vod" 
        HttpStreamingContentPath "C:\hds_vod_content" 
        HLSFmsDirPath ".." 
     
    # Uncomment the following directives to enable encryption 
    # for this location. 
    #    HLSEncryptionScope server 
    #    HLSEncryptCipherKeyFile "../phls/vodkey.bin" 
    #    HLSEncryptKeyURI        "https://<ServerName>/hls-key/vodkey.bin" 
     
        Options -Indexes FollowSymLinks</Location>
  3. Restart the Apache HTTP Server. The service name is FMSHttpd.

  4. Copy a sample file from /webroot/vod to c:\hds_vod_content. This task uses sample1_1500kbps.f4v.

  5. (HDS) Open rootinstall/samples/videoPlayer/videoplayer.html in a browser and in the Stream URL text box, enter:

    http://localhost/hds-vod/sample1_1500kbps.f4v.f4m

  6. (HLS) On a device running iOS, open Safari and enter the following:

    http://localhost/hls-vod/sample1_1500kbps.f4v.m3u8

The request URL is the same as it was before the Apache configuration change, but the content is in a different location on the disk. When Apache receives a request that start with /hds-vod, it resolves the rest of the path based on the value of HttpStreamingContentPath.

To verify that the Apache configuration took effect, try to stream a sample file that isn’t in the c:\hds_vod_content folder. For example, try to stream http://localhost/hds-vod/sample1_1000kbps.f4v.f4m. The sample video player displays an error, “We are unable to connect to the content you’ve requested. We apologize for the inconvenience.”

Configure the location of live HDS and HLS content

To configure the location of live HDS and HLS content on disk, edit the Apache httpd.conf file. Use the following directives:

Directive

Description

HttpStreamingContentPath

The root location of the streams on disk (livepkgr/streams, by default). By default, the location is "../applications". This location must be a subfolder of the livepkgr application.

This value can be absolute or relative to the Apache root folder.

HttpStreamingLiveEventPath

The root location of live events on disk (livepkgr/events, by default). The default value is "../applications". This location must be a subfolder of the livepkgr application.

This value can be absolute or relative to the Apache root folder.

For HLS, this value is dependant on the value of the HttpStreamingURLSandboxLevel directive.

HttpStreamingURLSandboxLevel

Defines the scope at which HttpStreamingLiveEventPath is configured. Possible values are "App", "Inst", and "Server". The default value is "Server".

If HttpStreamingLiveEventPath is configured to a particular application, use the value "App". In this case, the client request URL can omit the application name, as in the following:

HttpStreamingLiveEventPath "..application/livepkgr"

HttpStreamingURLSandboxLevel "App"

The request URL is:

http://<fms-dns-or-ip>/hls-live/<app-instance>/<event-name>/<stream-name>.m3u8

If HttpStreamingLiveEventPath is configured to an application instance, use the value "Inst". In this case, the client request URL can omit the application name and the application instance, as in the following:

HttpStreamingLiveEventPath "..application/livepkgr/events/_definst_"

HttpStreamingURLSandboxLevel "Inst"

The request URL is:

http://<fms-dns-or-ip>/hls-live/<event-name>/<stream-name>.m3u8

Configure the location of the live content on disk

  1. Open rootinstall/conf/fms.ini in a text editor. Set the VHOST.APPSDIR in parameter to one of the following:

    • (Windows) C:/applications

    • (Linux) /opt/applications

  2. Restart the server.

  3. Create a folder at the location in step 1 and copy the livepkgr application to it.

  4. Open rootinstall/Apache2.2/conf/httpd.conf in a text editor.

  5. To change the location of the HDS live content, edit the directives in bold:

    <Location /hds-live> 
        HttpStreamingEnabled true  
    #    HttpStreamingLiveEventPath "../applications"  
    #    HttpStreamingContentPath "../applications" 
        HttpStreamingLiveEventPath "C:\applications"HttpStreamingContentPath "C:\applications" 
        HttpStreamingF4MMaxAge 2 
        HttpStreamingBootstrapMaxAge 2 
        HttpStreamingFragMaxAge -1 
        HttpStreamingDrmmetaMaxAge 3600 
        Options -Indexes FollowSymLinks 
    </Location> 
    </IfModule>
    Note: On Linux, use "/opt/applications".
  6. To change the location of HLS live content, edit the directives in bold:

    <IfModule hlshttp_module> 
    <Location /hls-live> 
        HLSHttpStreamingEnabled true 
    #    HttpStreamingLiveEventPath "../applications"  
    #    HttpStreamingContentPath "../applications" 
        HttpStreamingLiveEventPath "C:\applications"HttpStreamingContentPath "C:\applications" 
        HLSMediaFileDuration 8000 
        HLSSlidingWindowLength 6 
        HLSFmsDirPath ".." 
        HLSM3U8MaxAge 2 
        HLSTSSegmentMaxAge -1 
     
    # Uncomment the following directives to enable encryption 
    # for this location. 
    #    HLSEncryptionScope server 
    #    HLSEncryptCipherKeyFile "../phls/liveeventkey.bin" 
    #    HLSEncryptKeyURI        "https://<ServerName>/hls-key/liveeventkey.bin" 
     
        Options -Indexes FollowSymLinks 
    </Location>
  7. Restart Apache HTTP Server. The service name is FMSHttpd.

  8. Open Flash Media Live Encoder and publish a stream with the following settings:

    • Video codec—H.264

    • Audio codec—AAC

    • Keyframe Frequency—4 seconds

    • FMS URL—rtmp://localhost/livepkgr

    • Stream—livestream?adbe-live-event=liveevent

  9. (HDS) Open rootinstall/samples/videoPlayer/videoplayer.html in a browser and in the Stream URL text box, enter:

    http://localhost/hds-live/livepkgr/_definst_/liveevent/livestream.f4m

  10. (HLS) On a device running iOS, open Safari and enter:

    http://localhost/hls-live/livepkgr/_definst_/liveevent/livestream.m3u8

    Note: To play content in Safari 4.0 on Mac OS, create an HTML document that uses the <video> tag.

Configure the scope of the request URL

  1. Open rootinstall/Apache2.2/conf/httpd.conf in a text editor.

  2. To change the scope of the request URL (also called the URL sandbox level) for HDS, edit the directives in bold:

    <Location /hds-live> 
        HttpStreamingEnabled true  
    #    HttpStreamingLiveEventPath "../applications"  
    #    HttpStreamingContentPath "../applications" 
        HttpStreamingLiveEventPath "c:\applications\livepkgr" 
        HttpStreamingContentPath "c:\applications" 
        HttpStreamingURLSandboxLevel "App" 
        HttpStreamingF4MMaxAge 2 
        HttpStreamingBootstrapMaxAge 2 
        HttpStreamingFragMaxAge -1 
        Options -Indexes FollowSymLinks 
    </Location></IfModule>

    To change the scope of the request URL for HLS, edit the directives in bold:

    <IfModule hlshttp_module> 
    <Location /hls-live> 
        HLSHttpStreamingEnabled true 
    #    HttpStreamingLiveEventPath "../applications"  
    #    HttpStreamingContentPath "../applications" 
        HttpStreamingLiveEventPath "C:\applications\livepkgr" 
        HttpStreamingContentPath "C:\applications" 
        HttpStreamingURLSandboxLevel "App" 
        HLSMediaFileDuration 8000 
        HLSSlidingWindowLength 6 
        HLSFmsDirPath ".." 
        HLSM3U8MaxAge 2 
        HLSTSSegmentMaxAge -1 
     
    # Uncomment the following directives to enable encryption 
    # for this location. 
    #    HLSEncryptionScope server 
    #    HLSEncryptCipherKeyFile "../phls/liveeventkey.bin" 
    #    HLSEncryptKeyURI        "https://<ServerName>/hls-key/liveeventkey.bin" 
     
        Options -Indexes FollowSymLinks 
    </Location>
  3. Restart the Apache HTTP Server. The service name is FMSHttpd.

  4. Open Flash Media Live Encoder and publish a stream with the following settings:

    • Video codec—H.264

    • Audio codec—AAC

    • Keyframe Frequency—4 seconds

    • FMS URL—rtmp://localhost/livepkgr

    • Stream—livestream?adbe-live-event=liveevent

  5. (HDS) Double-click rootinstall/samples/videoPlayer/videoplayer.html to open the Flash Media Server sample video player. Enter the following for Stream URL and click play:

    http://<host>/hds-live/_definst_/liveevent/livestream.f4m

  6. On a device running iOS, open Safari and enter:

    http://<host>/hls-live/_definst_/liveevent/livestream.m3u8

    Because the URL sandbox level is configured to “App” instead of the default “Server”, the URL does not include the application name (livepkgr).

Configure set-level F4M/M3U8 files for multi-bitrate streaming

Configuration information about multi-bitrate streams has been divided into multiple levels: set-level F4M and M3U8 files and stream-level F4M and M3U8 files. For HDS, the files are F4M manifest files. For HLS, the files are M3U8 variant playlists. (The documentation sometimes uses the generic term “manifest” to refer to both.)

Set-level F4M and M3U8 files
Contain the URL to the stream-level manifest file and the bit rate information for each stream in a multi-bitrate set. For HDS, the set-level F4M file can also contain information about a DVR rolling window. For HLS, the set-level M3U8 file can also contain codec information.

Flash Media Server 4.5 includes a Set-level F4M/M3U8 File Generator tool. This tool is installed to rootinstall/tools/f4mconfig/configurator/f4mconfig.html. Use the tool to generate set-level files. Copy the set-level files to a web server. The media player requests set-level files to play multi-bitrate content.

View full size graphic
Set-level F4M/M3U8 File Generator

The following is a set-level F4M file:

<manifest xmlns="http://ns.adobe.com/f4m/2.0"> 
    <baseURL>http://localhost/hds-live/livepkgr/_definst_/liveevent/</baseURL> 
    <media href="livestream1.f4m" bitrate="150"/> 
    <media href="livestream2.f4m" bitrate="500"/> 
    <media href="livestream3.f4m" bitrate="700"/> 
</manifest>

The following is a set-level M3U8 file:

#EXTM3U 
#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=150000 
http://10.0.1.11/hls-live/livepkgr/_definst_/liveevent/livestream1.m3u8 
#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=500000 
http://10.0.1.11/hls-live/livepkgr/_definst_/liveevent/livestream2.m3u8 
#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=700000 
http://10.0.1.11/hls-live/livepkgr/_definst_/liveevent/livestream3.m3u8

Stream-level F4M and M3U8 files
contain bootstrap information and DRM metadata. The live packager and the HTTP modules generate stream-level F4M and M3U8 files in real time when a media player requests the content.

Flash/AIR media players that support set-level files
To play set-level F4M files, use a media player that uses OSMF 1.6 or later. Strobe Media Playback that installs to rootinstall/samples/videoPlayer supports set-level F4M files.

Apple media players that support set-level files
To play set-level M3U8 files, use any device that supports Apple HTTP Live Streaming. See the Apple HTTP Live Streaming documentation.

F4M specification
For detailed information about the F4M file format, see the F4M File Format Specification.

M3U8 specification
For detailed information about the M3U8 file format, see HTTP Live Streaming Internet-Draft.

Tutorials that use set-level files
The following tutorials use set-level files for multi-bitrate streaming:

Configure absolute time on the server

Note: The livepkgr application is configured by default to use absolute time. Use this section to understand HTTP streaming and to duplicate the livepkgr application.

The livepkgr ingest application is configured by default to use absolute time. To see the configuration, open rootinstall/applications/livepkgr/Application.xml in a text editor.

To publish live, multi-bitrate streams, configure the live encoder to publish the streams using absolute time. See Stream live media (HTTP).

  1. Copy an Application.xml file to the application folder.

    For example, if you’re publishing streams to the application “livepkgr2”, copy an Application.xml file from the conf\_defaultRoot_\_defaultVHost_ folder to the applications/livepkgr2 folder.

  2. Open the Application.xml file in a text editor.

  3. Set the tag //Application/StreamManager/Live/AssumeAbsoluteTime to true:

    <Application> 
        ... 
        <StreamManager> 
            ... 
            <Live> 
                ... 
                <AssumeAbsoluteTime>true</AssumeAbsoluteTime>
  4. Save the file.

  5. Restart the server. See Starting and stopping the server.

Important: Set <AssumeAbsoluteTime> to true only when all streams published to the application use absolute time. If this value is set to true and the application ingests a stream that does not use absolute time, you may see warnings in the server logs about time going backwards when streams are stopped and re-published.

Configure F4F and TS fragment duration

The server records ingested (live) streams into fragments. It records on-demand files into fragments when a client requests the files.

Adobe HDS fragments are F4F files. Apple HLS fragments are TS files.

Specify the size of content fragments based on frames or based on time. The frame-based configuration overrides the time-based configuration.

Use frame-based configuration when the source media contains video encoded at a constant frame rate. Use frame-based configuration to match the fragment size to the video's keyframe interval. Use time-based configuration for media that contains audio or data but not video.

The server’s fragment duration must be a multiple of the encoder’s keyframe interval. The value of KeyframeIntervalsPerFragment defines the multiple.

Configure fragment size for live HDS and HLS

Server-level configurations for live HDS

Set the following directive in the Apache httpd.conf to configure fragment size for all live HDS events on the server:

Directive

Description

Default

HttpStreamingFragmentDuration

The default fragment duration, in milliseconds. This is the time-based configuration, and can be overridden by selecting frame-based values.

4000

HttpStreamingFrameRate

For frame-based fragment duration configuration, this is the frame rate of the source content.

None

HttpStreamingFramesPerKeyframeInterval

For frame-based fragment duration configuration, this is the number of frames in each keyframe interval (group of pictures).

None

HttpStreamingKeyframeIntervalsPerFragment

For frame-based fragment duration configuration, this is the number of keyframe intervals (GOPs) per fragment.

1

Server-level configurations for live HLS

Set the following directive in the Apache httpd.conf to configure a time-based fragment size for all live HLS events on the server:

Directive

Description

Default

HLSMediaFileDuration

The duration of TS files, in milliseconds. Use a value that is a multiple of the keyframe intervals for the media.

8000

Application-level and event-level configurations for live HDS

To configure fragment size at the application-level, use the Application.xml file in the directory of the Live Packager application (livepkgr, by default).

To configure fragment size at the event-level, use the Event.xml file in the live event directory (applications/livepkgr/events/_definst_/liveevent, by default).

Use the elements in the <Recording> container to configure how the server writes files to disk. In the Application.xml file, the elements are located at //Application/HDS. In the Event.xml file, the elements are located at //Event.

Element

Description

Default

/Recording

The section that configures how the file is written to disk.

None

/Recording/FragmentDuration

The length of each fragment, in milliseconds. Each segment can contain one or more fragments.

Time-based configuration.

4000

/Recording/FramePrecision

The rounding precision for the fragment run table, in frame units. Frame units are derived from the specified frame rate (1/rate).

Frame-based configuration.

1

/Recording/FrameRate

The frame rate of the original content, in frames per second (fps). The value is floating point; for NTSC, use the value 29.97.

Frame-based configuration

None

/Recording/FramesPerKeyframeInterval

The number of frames between each keyframe. For example, 30 fps video with a keyframe every 2 seconds contains 60 frames per keyframe interval.

Frame-based configuration.

None

/Recording/KeyframeIntervalsPerFragment

The number of keyframe intervals per fragment. The default value is 1, which means that the fragment size is the same as the keyframe interval.

Frame-based configuration.

1

/Recording/SegmentDuration

The length of each segment, in milliseconds. Each .f4f file contains one segment.

Time-based configuration. Frame-based configurations override time-based configurations

400000

Application-level and event-level configurations for live HLS

To configure fragment size at the application-level, use the Application.xml file in the directory of the Live Packager application (livepkgr, by default).

To configure fragment size at the event-level, use the Event.xml file in the live event directory (applications/livepkgr/events/_definst_/liveevent, by default).

Use the elements in the <Recording> and <HLS> containers to configure how the server writes files to disk. In the Application.xml file, the elements are located at //Application/HDS. In the Event.xml file, the elements are located at //Event/.

Element

Description

Default

/Recording/FrameRate

The frame rate of the original content, in frames per second (fps). The value is floating point; for NTSC, use the value 29.97.

Frame-based configuration.

None

/Recording/FramesPerKeyframeInterval

The number of frames between each keyframe. For example, 30 fps video with a keyframe every 2 seconds contains 60 frames per keyframe interval.

Frame-based configuration.

None

/HLS/KeyframeIntervalPerMediaFile

The number of keyframe intervals per media file (TS). The default value is 1, which means that the fragment size is the same as the keyframe interval.

Frame-based configuration.

1

/HLS/MediaFileDuration

The length of each media file (TS), in milliseconds.

Time-based configuration. Frame-based configurations override time-based configurations

8000

Specify fragment size for live HDS and HLS based on frames

Use the following elements for HDS: KeyframeIntervalsPerFragment, FrameRate, FramesPerKeyframeInterval, FramePrecision.

Use the following elements for HLS: FrameRate, FramesPerKeyframeInterval, and KeyframeIntervalPerMediaFile.

 <Event> 
    <EventID>liveevent</EventID> 
    <Recording> 
        <FrameRate>29.97</FrameRate> 
        <FramesPerKeyframeInterval>120</FramesPerKeyframeInterval>         
        <KeyframeIntervalsPerFragment>1</KeyframeIntervalsPerFragment> 
        <FramePrecision>1</FramePrecision>         
    </Recording> 
    <HLS> 
        <KeyframeIntervalPerMediaFile>3</KeyframeIntervalPerMediaFile> 
    </HLS> 
</Event> 

The server calculates the HLS media file duration according to the following formula:

MediaFileDurationInSeconds = FramesPerKeyframeInterval * KeyframeIntervalPerMediaFile / FrameRate

Specify fragment size for live HDS and HLS based on time

Use the following elements for HDS: FragmentDuration, SegmentDuration.

Use the following element for HLS: MediaFileDuration.

Use the following elements: FragmentDuration, MediaFileDuration.

<Event> 
    <EventID>liveevent</EventID> 
    <Recording> 
        <FragmentDuration>4000</FragmentDuration> 
        <SegmentDuration>400000</SegmentDuration> 
    </Recording> 
<HLS> 
    <MediaFileDuration>8000<MediaFileDuration> 
</HLS> 
</Event>

Configure fragment size for on-demand HDS and HLS

Server-level configurations for on-demand HDS

Set the following directive in the Apache httpd.conf to configure fragment size for all on-demand HDS on the server:

Directive

Description

Default

HttpStreamingFragmentDuration

The default fragment duration, in milliseconds.

This is the time-based configuration. Frame-based configurations override time-based configurations.

4000

HttpStreamingFrameRate

The frame rate of the source content.

Frame-based configuration.

None

HttpStreamingFramesPerKeyframeInterval

The number of frames in each keyframe interval (group of pictures.

Frame-based configuration.

None

HttpStreamingKeyframeIntervalsPerFragment

The number of keyframe intervals (GOPs) per fragment.

Frame-based configuration.

1

Server-level configurations for on-demand HLS

Set the following directive in the Apache httpd.conf to configure fragment size for all on-demand HLS on the server:

Directive

Description

Default

HLSMediaFileDuration

The duration of TS files, in milliseconds. Use a value that is a multiple of the keyframe intervals for the media.

8000

Stream-level configurations for on-demand HDS

To configure a set of on-demand media files (or a single file), copy a jit.conf file to the same directory as the media files. All media files in a directory use the same jit.conf file.

Use a jit.conf file with the following elements to configure fragment size for HDS at the stream-level:

Element

Description

Default

//manifest/hds:fragment-duration

The fragment duration for the set of content, in seconds. The value can be fractional (for example, to specify 2002 milliseconds, use the value 2.002).

Time-based configuration. Frame-based configurations override time-based configurations

None

//manifest/hds:frame-rate

The frame rate of the set of content. Units are frames/second, and can be fractional (i.e. 29.97 for NTSC) .

Frame-based configuration.

None

//manifest/hds:frames-per-keyframe-interval

The number of frames per keyframe interval (GOP). Units are frames, and should be a whole integer value.

Frame-based configuration.

None

//manifest/hds:keyframe-intervals-per-fragment

The number of keyframe intervals per fragment. Units are keyframe intervals per fragment, and should be a whole integer value.

Frame-based configuration.

1

Stream-level configurations for on-demand HLS

To configure a set of on-demand media files (or a single file), copy a jit.conf file to the same directory as the media files. All media files in a directory use the same jit.conf file.

Use a jit.conf file with the following elements to configure fragment size for HLS at the stream-level:

Element

Description

Default

//manifest/hds:frame-rate

The frame rate of the set of content. Units are frames/second, and can be fractional (i.e. 29.97 for NTSC) .

Frame-based configuration.

None

//manifest/hds:frames-per-keyframe-interval

The number of frames per keyframe interval (GOP). Units are frames, and should be a whole integer value.

Frame-based configuration.

None

//manifest/hds:hls

Container for Apple HTTP Live Streaming configurations.

None

//manifest/hds:hls/hds:keyframe-intervals-per-media-file

The number of keyframe intervals per TS file duration. The value must be a whole integer.

Frame-based configuration.

None

//manifest/hds:hls/hds:media-file-duration

The TS file duration, in milliseconds, for the set of content associated with this file. Use a value that is a multiple of the fragment duration.

Time-based configuration. Frame-based configurations override time-based configurations

None

Specify fragment size for on-demand HDS and HLS based on frames

Use the following elements for HDS: hds:frame-rate, hds:frames-per-keyframe-interval, and hds:keyframe-intervals-per-fragment.

Use the following elements for HLS: hds:frame-rate, hds:frames-per-keyframe-interval, and hds:keyframe-intervals-per-media-file.

<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns="http://ns.adobe.com/f4m/1.0" xmlns:hds="http://ns.adobe.com/hds-package/1.0"> 
    <hds:frame-rate>29.97</hds:frame-rate> 
    <hds:frames-per-keyframe-interval>60</hds:frames-per-keyframe-interval> 
    <hds:keyframe-intervals-per-fragment>2</hds:keyframe-intervals-per-fragment> 
    <hds:hls> 
        <hds:keyframe-intervals-per-media-file>2</hds:keyframe-intervals-per-media-file> 
    </hds:hls> 
</manifest> 

Specify fragment size for on-demand HDS and HLS based on time

Use the following element for HDS: hds:fragment-duration.

Use the following element for HLS: hds:media-file-duration.

<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns="http://ns.adobe.com/f4m/1.0" xmlns:hds="http://ns.adobe.com/hds-package/1.0"> 
    <hds:fragment-duration>8000</hds:fragment-duration> 
    <hds:hls> 
        <hds:media-file-duration>8000</hds:media-file-duration> 
    </hds:hls> 
</manifest> 

Configure the size of the IO buffer

The IO buffer improves the read and write performance of the Apache f4f module. The IO buffer loads the disk file into an in-memory buffer. It reads and writes to the in-memory buffer instead of making system calls.

Note: This feature impacts both HTTP Dynamic Streaming and HTTP Live Streaming.

When the buffer is full, or if the read/write head needs to move beyond the buffer boundaries, the server commits the contents of the buffer to the disk file and pre-loads new content into the buffer from the disk file.

The default value of the IO buffer is 4096 bytes. To increase or decrease the value, edit the Event.xml file. Use a multiple of 4096 bytes.

  1. Open the Event.xml file in a text editor.

    For live HTTP streaming, the Event.xml file is located in the live event folder. For example, rootinstall/applications/livepkgr/events/_definst_/liveevent/Event.xml.

  2. Set the IOBufferSize to a value that is a multiple of the cluster size of the underlying operating system. IOBufferSize is the size of the IO buffer in bytes.

    <Event> 
        <EventID>liveevent</EventID> 
            <Recording> 
                <FragmentDuration>4000</FragmentDuration> 
                <IOBufferSize>4096</IOBufferSize> 
            </Recording> 
    </Event>
  3. Save the file.

Disk management

Set the DiskManagementDuration configuration parameter in the Application.xml file or the Event.xml file to specify how much of the latest live content is on disk. The limit set at the application level cannot be overriden at the event level. If the limit has been set in the Application.xml file, the Event.xml file can set a duration that is equal to or lower than that limit.

All live HTTP streaming uses disk management to prevent the disk from filling. Disk management allows you to create 24/7 live streaming events. In addition, when using DVR, configure disk management in relation to the DVR settings. See Configure DVR (HDS).

By default, disk management keeps 3 hours of a live stream. The server constantly checks the content and if the content duration is above the value of DiskManagmentDuration, the server deletes the .f4f files and the .f4x files for segments beyond the limit.

If SegmentDuration or DiskManagmentDuration have values (both do by default), the following formula must be true for the server to start recording:

FragmentDuration < SegmentDuration < DiskManagementDuration

Also, the value of SegmentDuration must be greater than 0. (The value 0 creates 1 segment.) The value of SegmentDuration specifies how rapidly segments are removed. The smaller the value of SegmentDuration, the faster segments are deleted.

The server maintains the total duration of all the content available. After a segment is created, the server checks if the segment does not have any fragments that are in the disk management window. If so, the server removes the segment from the bootstrap entries, then removes the segment from disk.

Note: This behavior is a change from Flash Media Server 4.0 which allowed FragmentDuration to be greater than SegmentDuration.

Element

Default

Description

DiskManagementDuration

3

The maximum duration of the content on the server, in hours. The default value is 3. Use a fractional value to specify minutes.

DiskManagementWithGap

false

DiskManagementWithGap must be used along with the DiskManagementDuration element. The value of the DiskManagementWithGap element indicates whether the clock time (gaps) will be used for disk management.

If the value is set to true, any segment which has the timestamp older than the time specified by DiskManagmentDuration gets deleted. However, if there is a single segment, it will not get deleted.

If the value is set to false, comparison happens based on the actual content length (without considering the gaps). For instance, the sum of the duration of the segments on disk should be within the duration specified by the DiskManagementDuration element.

The value of DiskManagementDuration in the Application.xml file cannot be overridden by the value in the Event.xml file. If a value is not set in Application.xml, you can set a value in Event.xml.

The following sets disk management duration to 4 hours in the Application.xml file. This value impacts all live events running in this application.

<Application> 
    ... 
    <HDS> 
        <Recording>     
            <FragmentDuration>4000</FragmentDuration> 
            <SegmentDuration>16000</SegmentDuration> 
            <DiskManagementDuration>4</DiskManagementDuration> 
        </Recording> 
    </HDS> 
</Application>

The following sets the disk management duration to 1 hour in the Event.xml file. This value limits the content duration on the server for the event called “liveevent.”

<Event> 
    <EventID>liveevent</EventID> 
    <Recording>     
        ... 
        <DiskManagementDuration>1</DiskManagementDuration> 
    </Recording> 
</Events>

For more information, see Configure live HTTP streaming.

Configure content caching (HDS)

To improve the performance of live and on-demand HTTP Dynamic Streaming, enable Apache content caching on the origin server. When caching is enabled, the server caches content that it packages for HDS. When the server receives a request, it checks the cache before it serves content. Content caching is disabled by default.

  1. Run the htcacheclean tool.

    To limit the amount of storage the disk cache uses, run the Apache htcacheclean tool when content caching is enabled. The tool can run manually or as a daemon. The htcacheclean tool is located at rootinstall/Apache2.2/bin/. For information about how to run the tool, see the Apache documentation.

  2. In the Apache httpd.conf file, uncomment the caching configuration section.

    # Uncomment this to enable caching 
    LoadModule cache_module modules/mod_cache.so 
    <IfModule mod_cache.c> 
        LoadModule disk_cache_module modules/mod_disk_cache.so 
        IfModule mod_disk_cache.c> 
            CacheEnable disk /hds-vod 
            CacheEnable disk /hls-vod 
            CacheRoot cacheroot 
            CacheMaxFileSize 10000000 
            CacheLock On 
        </IfModule> 
    </IfModule>

    Verify that the directory specified by the CacheRoot directive exists. The default cacheroot directory is located at rootinstall/Apache2.2/cacheroot.

  3. Restart Apache.

For more information about content caching, see the Apache documentation.

Encrypt content for Flash Access protection

Important: Use the HTTP Dynamic Streaming packagers to both encrypt and fragment content. Do not use the Flash Access packaging tools to encrypt content. The HTTP Dynamic Streaming packagers cannot fragment content that has already been encrypted.
To deliver live or on-demand content with HTTP Dynamic Streaming and protect it with Flash Access, use Flash Access Server for Protected Streaming. This server is a Flash Access license server implementation optimized for use with HTTP Dynamic Streaming. See Adobe Flash Access Protecting Content.
Note: The Flash Access SDK and the Flash Access license server reference implementation can also issue licenses for HTTP Dynamic Streaming.

After you’ve deployed Flash Access Server for Protected Streaming, configure Flash Media Server to package and encrypt the content in real-time.

Configure Flash Media Server to encrypt live content

You can configure live content encryption with Flash Access at the application level and at the event level.

To configure Flash Access at the application level, use the Application.xml file located here:

rootinstall/applications/livepkgr/Application.xml

In the Application.xml file, the FlashAccessV2 container element is located here:

//Application/HDS/Recording/ContentProtection/FlashAccessV2

To configure Flash Access at the event level, use the Event.xml file located here:

rootinstall/applications/livepkgr/events/_definst_/liveevent/Event.xml

In the Event.xml file, the FlashAccessV2 container element is located here:

 //Event/Recording/ContentProtection/FlashAccessV2
  1. Open the file rootinstall/applications/livepkgr/events/_definst_/liveevent/Event.xml in a text editor.

  2. Add the XML tags required for encrypting the streams. The following is a sample Event.xml file:

    <Event> 
        <EventID>liveevent</EventID> 
        <Recording> 
            <FragmentDuration>4000</FragmentDuration> 
            <SegmentDuration>10000</SegmentDuration> 
             <ContentProtection enabled="true"> 
                <ProtectionScheme>FlashAccessV2</ProtectionScheme> 
                <FlashAccessV2> 
                    <ContentID>foo</ContentID> 
                    <CommonKeyFile>common-key.bin</CommonKeyFile> 
                    <LicenseServerURL>http://dill.corp.adobe.com:8090</LicenseServerURL> 
                    <TransportCertFile>production_transport.der</TransportCertFile> 
                    <LicenseServerCertFile>license_server.der</LicenseServerCertFile> 
                    <PackagerCredentialFile>production_packager.pfx</PackagerCredentialFile> 
                    <PackagerCredentialPassword>hbXX5omIhzI=</PackagerCredentialPassword> 
                    <PolicyFile>policy01.pol</PolicyFile> 
                </FlashAccessV2> 
            </ContentProtection> 
        </Recording> 
    </Event>
    Note: The certificates that you use with the Live Packager must match the license server.

Element

Description

Default value

FlashAccessV2

A container for settings used by Flash Access to protect content.

None

FlashAccessV2/CommonKeyFile

A path to a common key file used to generate a content encryption key. The path should be absolute or relative to the configuration file.

The base key used with the content ID to generate the content encryption key. This is a binary file containing a 16-byte/128-bit binary key.

For adaptive bitrate streaming, use the same common key and content ID for an entire set of content. Using the same key and id allows a single license to decrypt a set of content.

None

FlashAccessV2/ContentID

The content ID used with the common key to generate the content encryption key.

None

FlashAccessV2/LicenseServerCertFile

The DER encoded license server certificate file used for content protection.

None

FlashAccessV2/LicenseServerURL

The URL of the license server that handles license acquisition for this content.

None

FlashAccessV2/PackagerCredentialFile

The PFX file containing the packager's protection credentials.

None

FlashAccessV2/PackagerCredentialPassword

The password string used to secure the packager credentials.

None

FlashAccessV2/PolicyFile

The file containing the policy for this content. Currently only a single policy can be applied to content packaged with this tool.

None

FlashAccessV2/TransportCertFile

The DER encoded transport certificate file.

None

The Live Packager outputs the fragmented and protected files needed for HTTP Dynamic Streaming. Each fragment is persistently protected in both the CDN cache and the browser cache.

Configure Flash Media Server to encrypt on-demand content:

  1. Create a file called jit.conf and copy it to the same folder as the on-demand media files. The settings in the jit.conf file apply to all the files in the folder.

  2. Add the XML tags required for encrypting the streams. The following is a sample jit.conf file:

    <?xml version="1.0" encoding="utf-8"?> 
    <manifest xmlns="http://ns.adobe.com/f4m/1.0" xmlns:hds="http://ns.adobe.com/hds-package/1.0"> 
     
        <hds:frame-rate>29.97</hds:frame-rate> 
        <hds:frames-per-keyframe-interval>60</hds:frames-per-keyframe-interval> 
        <hds:content-protection enabled="true"> 
            <hds:protection-scheme>FlashAccessV2</hds:protection-scheme> 
            <hds:FlashAccessV2> 
                <hds:content-id>myfile.manifest</hds:content-id> 
                <hds:common-key-file>common.bin</hds:common-key-file> 
                <hds:license-server-url>http://mylicenseserver.myhost.com</hds:license-server-url> 
                <hds:transport-cert-file>transport.der</hds:transport-cert-file> 
                <hds:license-server-cert-file>server.der</hds:license-server-cert-file> 
                <hds:packager-credential-file>packager.pfx</hds:packager-credential-file> 
                <hds:packager-credential-password>??????</hds:packager-credential-password> 
                <hds:policy-file>policy.pol</hds:policy-file> 
            </hds:FlashAccessV2> 
        </hds:content-protection> 
    </manifest>

Element

Description

Default

//manifest/hds:content-protection/hds:flash-access/hds:common-key-file

The path to common key file. File contains 16-byte/128-bit random key.

The path must be absolute or relative to the jit.conf file.

None

//manifest/hds:content-protection/hds:flash-access/hds:content-id

The Content ID to be used for content protection. If not specified, the salt is the filename. If specified, the salt is shared with all content in the directory.

None

//manifest/hds:content-protection/hds:flash-access/hds:license-server-url

The License Server URL.

None

//manifest/hds:content-protection/hds:flash-access/hds:transport-cert-file

The path to transport cert file. The file is in DER format.

The path should be absolute or relative to the jit.conf file.

None

//manifest/hds:content-protection/hds:flash-access/hds:license-server-cert-file

The path to transport cert file. File is in DER format.

The path should be absolute or relative to the jit.conf file.

None

//manifest/hds:content-protection/hds:flash-access/hds:packager-credential-file

The path to packager credential cert file. File is in PFX format.

The path should be absolute or relative to the jit.conf file.

None

//manifest/hds:content-protection/hds:flash-access/hds:packager-credential-password

The packager credential password.

None

//manifest/hds:content-protection/hds:flash-access/hds:policy-file

The path to a policy file. File is in FAXS policy format.

The path should be absolute or relative to the jit.conf file.

None

Publish live streams

 Publish a live stream or multi-bitrate streams from a supported encoder to the livepkgr service. Flash Access doesn’t require any special settings.

Play encrypted streams

 OSMF media players do the following:
  1. Request the file fragments and play them back seamlessly.

  2. Obtain a content license from Flash Access Server for Protected Streaming. The content license contains the key required to play the content to legitimate clients.

  3. Decrypt the content in real-time.