微软云平台媒体服务实践系列 1- 使用静态封装为iOS, Android 设备实现点播（VoD）方案

Artikel
02/09/2015

微软的云平台媒体服务为流媒体服务提供了多种选择，在使用流媒体服务为企业做流媒体方案时，首先需要确认要流媒体接收目标，如针对广大iOS, Android移动设备，由于它们都支持HLS 格式的流媒体，基于该认知，比较推荐的是使用动态封装，但是必须额外添加流式处理单元，方法是在Azure 门户，点击媒体服务，然后点击所使用的媒体服务，选择流式处理端点标签页，选择需要编辑的流媒体端点，然后再缩放标签页下设置，如下截图所示

使用流式处理单元需要支付一定的费用，且最小单元就是200mbps，根据文档Windows Azure Media Services Pricing Details内容引用如下，我们可以计算出：在使用1个流式处理单元，使用H264 Adaptive Bitrate MP4 Set 720p（范围从 3400 kbps 到 400 kbps）编码方式的情况下，同时可以观看流媒体的客户端个数约为47 个（160/3.4）。

“Question: How do I estimate # of on-demand streaming reserved unit I need?

Answer: For the most conservative estimate you can go directly with SLA limitations - i.e. total bandwidth is 160 Mbps * # of RU’s. To obtain an initial estimate you can take the # of concurrent customers * top bitrate that you are encoding video at. For most video business, I think it is always better to be conservative first and if you end up over provisioning, you could always reduce # of reserved unit.

”

那么如果仅针对少数客户端，可能总数达不到47个，那么出于节省开支的目的，我们还有其他方法吗？答案是肯定的，本文将详细介绍该方案。

针对iOS, Android 客户端，同时观看的客户端数比较少的点播情况下，我们可以使用静态封装方法将编码后的文件包装成HLS即可，这样就可以不使用流式处理单元，需要注意的是，由于Microsoft Azure Media Packager 和 Microsoft Azure Media Encryptor 将在 2015 年 11 月 1 日终结使用，所以本文方案在此日期之后不推荐使用。

在封装为HLS格式之前，必须先将媒体文件转码成smooth streaming 格式，再使用“Windows Azure Media Packager”将其封装为HLS，然后再在iOS 设备和Android 设备上使用自带的浏览器测试HLS 格式的流媒体URL。所以整个流程为：

原始媒体文件——>转码为MP4文件——>将MP4编码为SmoothStreaming 格式——>将SmoothStreaming格式输出封装为HLS格式——>获取静态HLS流媒体URL——>设备测试

需要使用到2个配置文件：

1. MP4转为smooth streaming 格式的配置文件：MediaPackager_MP4ToSmooth.xml，内容如下：

<?xml version="1.0" encoding="utf-8"?>

<name>MP4 to Smooth Streams</name>

</properties>

<type>Microsoft.Web.Media.TransformManager.MP4toSmooth.MP4toSmooth_Task, Microsoft.Web.Media.TransformManager.MP4toSmooth, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35</type>

</taskCode>

</taskDefinition>

2. packager 配置文件MediaPackager_MP4ToSmooth.xml，内容如下：

<?xml version="1.0" encoding="utf-8" ?>

<name>Smooth Streams to Apple HTTP Live Streams</name>

<description xml:lang="en">Converts on-demand Smooth Streams encoded with H.264 (AVC) video and AAC-LC audio codecs to Apple HTTP Live Streams (MPEG-2 TS) and creates an Apple HTTP Live Streaming playlist (.m3u8) file for the converted presentation.</description>

</properties>

<type>Microsoft.Web.Media.TransformManager.SmoothToHLS.SmoothToHLSTask, Microsoft.Web.Media.TransformManager.SmoothToHLS, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35</type>

</taskCode>

</taskDefinition>

代码可以参考如下：（使用流媒体服务.Net SDK，注意指定媒体服务的账号名字及key）

class Program

{

private static string accName = "[MediaService accountName]";

private static string accKey = "[MediaService accountKey]";

private static readonly string _supportFiles =

Path.GetFullPath(@"../..\..\..\..\");

// Paths to support files (within the above base path). You can use

// the provided sample media files from the "supportFiles" folder, or

// provide paths to your own media files below to run these samples.

private static readonly string singleInputFilePath =

Path.GetFullPath(_supportFiles + @"\azure.wmv");

private static readonly string outputPath = _supportFiles;

private static CloudMediaContext context;

static void Main(string[] args)

{

context = new CloudMediaContext(accName, accKey);

string inputAssetId = CreateAssetAndUploadFile(context);

//encode to MP4

IJob job = EncodeToMp4(context, inputAssetId);

IAsset mp4Output = job.OutputMediaAssets.FirstOrDefault();

//convert MP4 to smooth streaming

IJob jobSS = ConvertMP4toSmooth(context, mp4Output, mp4Output.Id);

IAsset ssAsset = jobSS.OutputMediaAssets.FirstOrDefault();

string SSStreamingUrlStatic = GetStaticSS(context, ssAsset.Id, LocatorType.OnDemandOrigin);

//package ss to HLS-Static Packaging

IJob jobHLS = SmoothToHLS(context, ssAsset.Id, ssAsset);

var hlsAsset = jobHLS.OutputMediaAssets.FirstOrDefault();

string hlsStreamingUrlStatic = GetStaticHLS(context, hlsAsset.Id, LocatorType.OnDemandOrigin);

string content = "\n Static Packaging Smooth Streaming Url: \n" + SSStreamingUrlStatic +

"\n Static Packaging HLS Url: \n" + hlsStreamingUrlStatic +

"\n Mp4 Url: \n" + mp4StreamingUrl;

Console.WriteLine("\n Static Packaging Smooth Streaming Url: \n" + SSStreamingUrlStatic);

Console.WriteLine("\n Static Packaging HLS Url: \n" + hlsStreamingUrlStatic);

Console.WriteLine("\n Mp4 Url: \n" + mp4StreamingUrl);

Console.WriteLine("\n Smooth Url: \n" + smoothStreamingUrl);

string outFilePath = Path.GetFullPath(outputPath + @"\" + "StreamingUrl.txt");

WriteToFile(outFilePath, content);

Console.ReadKey();

}

private static string CreateAssetAndUploadFile(CloudMediaContext context)

{

var assetName = Path.GetFileNameWithoutExtension(singleInputFilePath);

var inputAsset = context.Assets.Create(assetName, AssetCreationOptions.None);

var assetFile = inputAsset.AssetFiles.Create(Path.GetFileName(singleInputFilePath));

assetFile.UploadProgressChanged += new EventHandler<UploadProgressChangedEventArgs>(assetFile_UploadProgressChanged);

assetFile.Upload(singleInputFilePath);

return inputAsset.Id;

}

static void assetFile_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)

{

Console.WriteLine(string.Format("{0} Progress: {1:0} Time: {2}", ((IAssetFile)sender).Name, e.Progress, DateTime.UtcNow.ToString(@"yyyy_M_d__hh_mm_ss")));

}

private static IJob EncodeToMp4(CloudMediaContext context, string inputAssetId)

{

var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();

if (inputAsset == null)

throw new ArgumentException("Could not find assetId: " + inputAssetId);

var encodingPreset = "H264 Adaptive Bitrate MP4 Set 720p";

//var encodingPreset = "H264 Broadband 720p";

IJob job = context.Jobs.Create(".Net Encoding " + inputAsset.Name + " to MP4 job");

IMediaProcessor latestWameMediaProcessor = (from p in context.MediaProcessors where p.Name == "Windows Azure Media Encoder" select p).ToList()

.OrderBy(wame => new Version(wame.Version)).LastOrDefault();

ITask encodeTask = job.Tasks.AddNew(".Net Encoding to Mp4 Task ", latestWameMediaProcessor, encodingPreset, TaskOptions.None);

encodeTask.InputAssets.Add(inputAsset);

encodeTask.OutputAssets.AddNew(inputAsset.Name + " as " + " mp4 output asset", AssetCreationOptions.None);

job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);

job.Submit();

job.GetExecutionProgressTask(CancellationToken.None).Wait();

return job;

}

private static IJob ConvertMP4toSmooth(CloudMediaContext context, IAsset assetToConvert, string inputAssetId)

{

var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();

if (inputAsset == null)

throw new ArgumentException("Could not find assetId: " + inputAssetId);

IJob job = context.Jobs.Create("Conversion " + inputAsset.Name + " to Smooth Streaming job");

string smoothconfig = Path.GetFullPath(_supportFiles + @"\MediaPackager_MP4ToSmooth.xml");

string configMp4ToSmooth = File.ReadAllText(Path.GetFullPath(smoothconfig));

IMediaProcessor LatestPackager = (from p in context.MediaProcessors where p.Name == "Windows Azure Media Packager" select p).ToList()

.OrderBy(wame => new Version(wame.Version)).LastOrDefault();

ITask convertTask = job.Tasks.AddNew(".Net Conversion MP4 to Smooth Streaming Task for " + inputAsset.Name,

LatestPackager, configMp4ToSmooth, TaskOptions.None);

convertTask.InputAssets.Add(assetToConvert);

convertTask.OutputAssets.AddNew(".Net output-MP4 converted Smooth Streaming-" + inputAsset.Name, AssetCreationOptions.None);

job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);

job.Submit();

job.GetExecutionProgressTask(CancellationToken.None).Wait();

return job;

}

private static IJob SmoothToHLS(CloudMediaContext context, string inputAssetId, IAsset asset)

{

var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();

if (inputAsset == null)

throw new ArgumentException("Could not find assetId: " + inputAssetId);

var conversionPreset = "HLS";

IJob job = context.Jobs.Create("Conversion " + inputAsset.Name + " to " + conversionPreset);

//var ssOutput = encodeTask.OutputAssets.AddNew("output-Silverlight-" + inputAsset.Name,

// AssetCreationOptions.None);

string smooth2HLSFilePath = Path.GetFullPath(_supportFiles + @"\MediaPackager_SmoothToHLS.xml");

var packager = context.MediaProcessors.Where(m => m.Name == "Windows Azure Media Packager").First();

var conversionTask = job.Tasks.AddNew("Conversion Task for " + inputAsset.Name, packager,

File.ReadAllText(smooth2HLSFilePath), TaskOptions.None);

conversionTask.InputAssets.Add(asset);

conversionTask.OutputAssets.AddNew(

"output-HLS-" + inputAsset.Name, AssetCreationOptions.None);

job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);

job.Submit();

job.GetExecutionProgressTask(CancellationToken.None).Wait();

return job;

}

static void JobStateChanged(object sender, JobStateChangedEventArgs e)

{

Console.WriteLine(string.Format("{0}\n State: {1}\n Time: {2}\n\n",

((IJob)sender).Name, e.CurrentState, DateTime.UtcNow.ToString(@"yyyy_M_d__hh_mm_ss")));

}

static void WriteToFile(string outFilePath, string fileContent)

{

StreamWriter sr = File.CreateText(outFilePath);

sr.Write(fileContent);

sr.Close();

}

private static string GetStaticSS(CloudMediaContext context, string outputAssetId, LocatorType type)

{

var daysForWhichStreamingUrlIsActive = 365;

var outputAsset = context.Assets.Where(a => a.Id == outputAssetId).FirstOrDefault();

var accessPolicy = context.AccessPolicies.Create(outputAsset.Name,

TimeSpan.FromDays(daysForWhichStreamingUrlIsActive),

AccessPermissions.Read | AccessPermissions.List);

var assetFiles = outputAsset.AssetFiles.ToList();

if (type == LocatorType.OnDemandOrigin)

{

var assetFile = assetFiles.Where(f => f.Name.ToLower().EndsWith(".ism")).FirstOrDefault();

if (assetFile != null)

{

var locator = context.Locators.CreateLocator(LocatorType.OnDemandOrigin, outputAsset, accessPolicy);

Uri smoothUri = new Uri(locator.Path + assetFile.Name + "/manifest");

return smoothUri.ToString();

}

if (type == LocatorType.Sas)

{

var mp4Files = assetFiles.Where(f => f.Name.ToLower().EndsWith(".mp4")).ToList();

var assetFile = mp4Files.OrderBy(f => f.ContentFileSize).LastOrDefault(); //Get Largest File

if (assetFile != null)

{

var locator = context.Locators.CreateLocator(LocatorType.Sas, outputAsset, accessPolicy);

var mp4Uri = new UriBuilder(locator.Path);

mp4Uri.Path += "/" + assetFile.Name;

return mp4Uri.ToString();

}

return string.Empty;

}

private static string GetStaticHLS(CloudMediaContext context, string outputAssetId, LocatorType type)

{

var daysForWhichStreamingUrlIsActive = 365;

var outputAsset = context.Assets.Where(a => a.Id == outputAssetId).FirstOrDefault();

var accessPolicy = context.AccessPolicies.Create(outputAsset.Name,

TimeSpan.FromDays(daysForWhichStreamingUrlIsActive),

AccessPermissions.Read | AccessPermissions.List);

var assetFiles = outputAsset.AssetFiles.ToList();

foreach (var f in assetFiles.Where(x => x.Name.EndsWith(".ism")))

{

if (f.Name.Contains("m3u8"))

{

#region publish HLS to a WAMS origin

Console.WriteLine("will create a new locator for HLS");

var originLocator = context.Locators.CreateLocator(LocatorType.OnDemandOrigin, outputAsset, accessPolicy);

string urlForClientStreaming = originLocator.Path + f.Name

+ "/manifest(format=m3u8-aapl)";

return urlForClientStreaming.ToString();

#endregion

}

return string.Empty;

}

最终输出如：https://test20140404.origin.mediaservices.windows.net/1dcaef59-56b1-4bf9-9dd2-8502d62d5095/azure-m3u8-aapl.ism/manifest(format=m3u8-aapl)

更多关于微软云平台的媒体服务的使用实践内容，将在后续文章中介绍，敬请期待！

Freigeben über

微软云平台媒体服务实践系列 1- 使用静态封装为iOS, Android 设备实现点播（VoD）方案

Zusätzliche Ressourcen