static void Main(string[] args)
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the cached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
bool tokenRestriction = false;
string tokenTemplateString = null;
IAsset asset = UploadFileAndCreateAsset(_singleMP4File);
Console.WriteLine("Uploaded asset: {0}", asset.Id);
IAsset encodedAsset = EncodeToAdaptiveBitrateMP4Set(asset);
Console.WriteLine("Encoded asset: {0}", encodedAsset.Id);
IContentKey key = CreateCommonTypeContentKey(encodedAsset);
Console.WriteLine("Created key {0} for the asset {1} ", key.Id, encodedAsset.Id);
Console.WriteLine("PlayReady License Key delivery URL: {0}", key.GetKeyDeliveryUrl(ContentKeyDeliveryType.PlayReadyLicense));
Console.WriteLine();
if (tokenRestriction)
tokenTemplateString = AddTokenRestrictedAuthorizationPolicy(key);
else
AddOpenAuthorizationPolicy(key);
Console.WriteLine("Added authorization policy: {0}", key.AuthorizationPolicyId);
Console.WriteLine();
CreateAssetDeliveryPolicy(encodedAsset, key);
Console.WriteLine("Created asset delivery policy. \n");
Console.WriteLine();
if (tokenRestriction && !String.IsNullOrEmpty(tokenTemplateString))
{
// Deserializes a string containing an Xml representation of a TokenRestrictionTemplate
// back into a TokenRestrictionTemplate class instance.
TokenRestrictionTemplate tokenTemplate =
TokenRestrictionTemplateSerializer.Deserialize(tokenTemplateString);
// Generate a test token based on the the data in the given TokenRestrictionTemplate.
// Note, you need to pass the key id Guid because we specified
// TokenClaim.ContentKeyIdentifierClaim in during the creation of TokenRestrictionTemplate.
Guid rawkey = EncryptionUtils.GetKeyIdAsGuid(key.Id);
string testToken = TokenRestrictionTemplateSerializer.GenerateTestToken(tokenTemplate, null, rawkey, DateTime.UtcNow.AddDays(365));
Console.WriteLine("The authorization token is:\nBearer {0}", testToken);
Console.WriteLine();
}
// You can use the http://smf.cloudapp.net/healthmonitor player
// to test the smoothStreamURL URL.
//
string url = GetStreamingOriginLocator(encodedAsset);
Console.WriteLine("Encrypted Smooth Streaming URL: {0}/manifest", url);
Console.ReadLine();
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="apiServer">A <see cref="Uri"/> representing the API endpoint.</param>
/// <param name="credentials">Microsoft WindowsAzure Media Services credentials.</param>
public CloudMediaContext(Uri apiServer, MediaServicesCredentials credentials)
{
this.apiServer = apiServer;
this.ParallelTransferThreadCount = 10;
this.NumberOfConcurrentTransfers = 2;
this.Credentials = credentials;
}
static void Main(string[] args)
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(_mediaServicesAccountName, _mediaServicesAccountKey);
// Use the cached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
// Encoding and encrypting assets //////////////////////
// Load a single MP4 file.
IAsset asset = IngestSingleMP4File(_singleMP4File, AssetCreationOptions.None);
// Encode an MP4 file to a set of multibitrate MP4s.
// Then, package a set of MP4s to clear Smooth Streaming.
IAsset clearSmoothStreamAsset = ConvertMP4ToMultibitrateMP4sToSmoothStreaming(asset);
// Encrypt your clear Smooth Streaming to Smooth Streaming with PlayReady.
IAsset outputAsset = CreateSmoothStreamEncryptedWithPlayReady(clearSmoothStreamAsset);
// You can use the http://smf.cloudapp.net/healthmonitor player
// to test the smoothStreamURL URL.
string smoothStreamURL = outputAsset.GetSmoothStreamingUri().ToString();
Console.WriteLine("Smooth Streaming URL:");
Console.WriteLine(smoothStreamURL);
// You can use the http://dashif.org/reference/players/javascript/ player
// to test the dashURL URL.
string dashURL = outputAsset.GetMpegDashUri().ToString();
Console.WriteLine("MPEG DASH URL:");
Console.WriteLine(dashURL);
}
static void Main(string[] args)
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the cached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
IChannel channel = CreateAndStartChannel();
//IChannel channel = _context.Channels.Where(c => c.Name == "playreadylive").Single();
// Set the Live Encoder to point to the channel's input endpoint:
string ingestUrl = channel.Input.Endpoints.FirstOrDefault().Url.ToString();
// Use the previewEndpoint to preview and verify
// that the input from the encoder is actually reaching the Channel.
string previewEndpoint = channel.Preview.Endpoints.FirstOrDefault().Url.ToString();
// Once you previewed your stream and verified that it is flowing into your Channel,
// you can create an event by creating an Asset, Program, and Streaming Locator.
IProgram program = CreateAndStartProgram(channel);
ILocator locator = CreateLocatorForAsset(program.Asset, program.ArchiveWindowLength);
// IStreamingEndpoint streamingEndpoint = CreateAndStartStreamingEndpoint();
GetLocatorsInAllStreamingEndpoints(program.Asset);
Console.ReadLine();
// Once you are done streaming, clean up your resources.
//Cleanup(streamingEndpoint, channel);
}
static void Main(string[] args)
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the cached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
bool tokenRestriction = false;
string tokenTemplateString = null;
IContentKey key = CreateCommonTypeContentKey();
// Print out the key ID and Key in base64 string format
Console.WriteLine("Created key {0} with key value {1} ", key.Id, System.Convert.ToBase64String(key.GetClearKeyValue()));
Console.WriteLine("PlayReady License Key delivery URL: {0}", key.GetKeyDeliveryUrl(ContentKeyDeliveryType.PlayReadyLicense));
if (tokenRestriction)
tokenTemplateString = AddTokenRestrictedAuthorizationPolicy(key);
else
AddOpenAuthorizationPolicy(key);
Console.WriteLine("Added authorization policy: {0}", key.AuthorizationPolicyId);
Console.WriteLine();
Console.ReadLine();
}
public static CloudMediaContext GetCloudMediaContext()
{
var amsAccessToken = ClaimsPrincipal.Current.FindFirst(Configuration.ClaimsAmsAcessToken).Value;
var amsCredentials = new MediaServicesCredentials(Configuration.MediaAccount, Configuration.MediaKey);
amsCredentials.AccessToken = amsAccessToken;
CloudMediaContext cntx = new CloudMediaContext(amsCredentials);
return cntx;
}
static void Main(string[] args)
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Use the cached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
// Encoding and encrypting assets //////////////////////
// Load a single MP4 file.
IAsset asset = IngestSingleMP4File(_singleMP4File, AssetCreationOptions.None);
// Encode an MP4 file to a set of multibitrate MP4s.
// Then, package a set of MP4s to clear Smooth Streaming.
IAsset clearSmoothStreamAsset =
ConvertMP4ToMultibitrateMP4sToSmoothStreaming(asset);
// Create a common encryption content key that is used
// a) to set the key values in the MediaEncryptor_PlayReadyProtection.xml file
// that is used for encryption.
// b) to configure the license delivery service and
//
Guid keyId;
byte[] contentKey;
IContentKey key = CreateCommonEncryptionKey(out keyId, out contentKey);
// Add the common encryption key to asset's keys.
// asset.ContentKeys.Add(key);
// The content key authorization policy must be configured by you
// and met by the client in order for the PlayReady license
// to be delivered to the client.
ConfigureLicenseDeliveryService(key);
Uri acquisitionUrl = key.GetKeyDeliveryUrl(ContentKeyDeliveryType.PlayReadyLicense);
// Update the MediaEncryptor_PlayReadyProtection.xml file with the key and URL info.
UpdatePlayReadyConfigurationXMLFile(keyId, contentKey, acquisitionUrl);
// Encrypt your clear Smooth Streaming to Smooth Streaming with PlayReady.
IAsset outputAsset = CreateSmoothStreamEncryptedWithPlayReady(clearSmoothStreamAsset);
// You can use the http://smf.cloudapp.net/healthmonitor player
// to test the smoothStreamURL URL.
string smoothStreamURL = outputAsset.GetSmoothStreamingUri().ToString();
Console.WriteLine("Smooth Streaming URL:");
Console.WriteLine(smoothStreamURL);
// You can use the http://dashif.org/reference/players/javascript/ player
// to test the dashURL URL.
string dashURL = outputAsset.GetMpegDashUri().ToString();
Console.WriteLine("MPEG DASH URL:");
Console.WriteLine(dashURL);
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="apiServer">A <see cref="Uri"/> representing the API endpoint.</param>
/// <param name="credentials">Microsoft WindowsAzure Media Services credentials.</param>
public CloudMediaContext(Uri apiServer, MediaServicesCredentials credentials)
{
this.apiServer = apiServer;
this.ParallelTransferThreadCount = 10;
this.NumberOfConcurrentTransfers = 2;
this.Credentials = credentials;
dataServiceAdapter = new OAuthDataServiceAdapter(credentials, NimbusRestApiCertificateThumbprint, NimbusRestApiCertificateSubject);
versionAdapter = new ServiceVersionAdapter(KnownApiVersions.Current);
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="credentials">Microsoft WindowsAzure Media Services credentials.</param>
public CloudMediaContext(MediaServicesCredentials credentials)
: this(_mediaServicesUri, credentials)
{
}
static void Main(string[] args)
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the cached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
IChannel channel = CreateAndStartChannel();
// The channel's input endpoint:
string ingestUrl = channel.Input.Endpoints.FirstOrDefault().Url.ToString();
Console.WriteLine("Intest URL: {0}", ingestUrl);
// Use the previewEndpoint to preview and verify
// that the input from the encoder is actually reaching the Channel.
string previewEndpoint = channel.Preview.Endpoints.FirstOrDefault().Url.ToString();
Console.WriteLine("Preview URL: {0}", previewEndpoint);
// When Live Encoding is enabled, you can now get a preview of the live feed as it reaches the Channel.
// This can be a valuable tool to check whether your live feed is actually reaching the Channel.
// The thumbnail is exposed via the same end-point as the Channel Preview URL.
string thumbnailUri = new UriBuilder
{
Scheme = Uri.UriSchemeHttps,
Host = channel.Preview.Endpoints.FirstOrDefault().Url.Host,
Path = "thumbnails/input.jpg"
}.Uri.ToString();
Console.WriteLine("Thumbain URL: {0}", thumbnailUri);
// Once you previewed your stream and verified that it is flowing into your Channel,
// you can create an event by creating an Asset, Program, and Streaming Locator.
IAsset asset = CreateAndConfigureAsset();
IProgram program = CreateAndStartProgram(channel, asset);
ILocator locator = CreateLocatorForAsset(program.Asset, program.ArchiveWindowLength);
// You can use slates and ads only if the channel type is Standard.
StartStopAdsSlates(channel);
// Once you are done streaming, clean up your resources.
Cleanup(channel);
}
static int doListAllAssets(string outputFile)
{
MediaServicesCredentials credentials = new MediaServicesCredentials(
_accountName, _accountKey);
CloudMediaContext _context = new CloudMediaContext(credentials);
try
{
int selectlimit = 1000;
int offset = 0;
int selectposition = 0;
int assetcount = _context.Assets.Count();
Console.WriteLine("Assets Total Count:" + assetcount.ToString());
StreamWriter writer = new StreamWriter(outputFile);
string FieldDefines = "\"AssetName=\",\"AssetID\",\"LastModified\",\"StroageAccountName\",ContentKeyId\",\"ContentKeyType\"";
writer.WriteLine(FieldDefines);
while (true)
{
foreach (IAsset asset in _context.Assets.Skip(offset).Take(selectlimit))
{
selectposition++;
string line = "";
var contentkeys = asset.ContentKeys;
if (contentkeys.Count() > 0)
{
foreach (IContentKey contentkey in contentkeys)
{
line = string.Format("\"{0}\",\"{1}\",\"{2}\",\"{3}\",\"{4}\"",
asset.Name,
asset.Id,
asset.StorageAccountName,
contentkey.Id,
contentkey.ContentKeyType
);
break;
}
}
else
{
line = string.Format("\"{0}\",\"{1}\",\"{2}\",\"{3}\",\"{4}\"",
asset.Name,
asset.Id,
asset.StorageAccountName,
"", ""
);
}
writer.WriteLine(line);
}
if (selectposition == selectlimit)
{
offset += selectlimit;
selectposition = 0;
}
else
{
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return -1;
}
return 0;
}
static void Main(string[] args)
{
//var resultsURLs = AzureMediaLib.MediaService.GetProgressiveDownloadURLs("nb:jid:UUID:3880ae6a-e5a4-6642-a786-40437555c8c8");
AzureMediaLib.MediaService.uploadFolderAndTranscode(_mediaFiles, 30);
//string configuration2 = File.ReadAllText(Path.GetFullPath(@"../..\configs\Thumbnails.xml"));
_cachedCredentials = new MediaServicesCredentials(_mediaServicesAccountName, _mediaServicesAccountKey);
_context = new CloudMediaContext(_cachedCredentials);
//DownloadAssetForTest();
Console.WriteLine("finish download test.");
Console.ReadLine();
Console.WriteLine("Creating new asset from local file...");
// Create a new asset and upload a mezzanine file from a local path.
IAsset inputAsset = _context.Assets.CreateFromFile(
_singleMP4File,
AssetCreationOptions.None,
(af, p) =>
{
Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
});
Console.WriteLine("Asset created.");
// Prepare a job with a single task to transcode the previous mezzanine asset
// into a multi-bitrate asset.
//IJob job = _context.Jobs.CreateWithSingleTask(
// MediaProcessorNames.WindowsAzureMediaEncoder,
// MediaEncoderTaskPresetStrings.H264AdaptiveBitrateMP4Set720p,
// inputAsset,
// "Sample Adaptive Bitrate MP4",
// AssetCreationOptions.None);
//create thumbnail
string configuration = File.ReadAllText(Path.GetFullPath(@"../..\configs\Thumbnails.xml"));
var job = _context.Jobs.CreateWithSingleTask(
MediaProcessorNames.WindowsAzureMediaEncoder,
MediaEncoderTaskPresetStrings.Thumbnails,
inputAsset,
"Sample thumbnail 1",
AssetCreationOptions.None);
Console.WriteLine("Submitting transcoding job...");
// Submit the job and wait until it is completed.
job.Submit();
job = job.StartExecutionProgressTask(
j =>
{
Console.WriteLine("Job state: {0}", j.State);
Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress());
},
CancellationToken.None).Result;
Console.WriteLine("Transcoding job finished.");
// The OutputMediaAssets[0] contains the first
// (and in this case the only) output asset
// produced by the encoding job.
IAsset outputAsset = job.OutputMediaAssets[0];
Console.WriteLine("Publishing output asset...");
// Publish the output asset by creating an Origin locator.
// Define the Read only access policy and
// specify that the asset can be accessed for 30 days.
_context.Locators.Create(
LocatorType.OnDemandOrigin,
outputAsset,
AccessPermissions.Read,
TimeSpan.FromDays(30));
// Generate the Smooth Streaming, HLS and MPEG-DASH URLs for adaptive streaming.
Uri smoothStreamingUri = outputAsset.GetSmoothStreamingUri();
Uri hlsUri = outputAsset.GetHlsUri();
Uri mpegDashUri = outputAsset.GetMpegDashUri();
// To stream your content based on the set of
// adaptive bitrate MP4 files, you must first get
// at least one On-demand Streaming reserved unit.
// For more information, see http://msdn.microsoft.com/en-us/library/jj889436.aspx.
Console.WriteLine("Output is now available for adaptive streaming:");
// Show the streaming URLs.
Console.WriteLine(smoothStreamingUri);
Console.WriteLine(hlsUri);
Console.WriteLine(mpegDashUri);
//
// Create a SAS locator that is used for progressive download
// or to download files to a local directory.
// The content that you want to progressively download cannot be encrypted.
_context.Locators.Create(
LocatorType.Sas,
outputAsset,
AccessPermissions.Read,
TimeSpan.FromDays(30));
// Get all the MP4 files in the output asset.
IEnumerable<IAssetFile> mp4AssetFiles = outputAsset
.AssetFiles
.ToList()
.Where(af => af.Name.EndsWith(".mp4", StringComparison.OrdinalIgnoreCase));
// Generate the Progressive Download URLs for each MP4.
List<Uri> mp4ProgressiveDownloadUris =
mp4AssetFiles.Select(af => af.GetSasUri()).ToList();
Console.WriteLine("You can progressively download the following MP4 files:");
mp4ProgressiveDownloadUris.ForEach(uri => Console.WriteLine(uri));
string outputFolder = Path.Combine(_mediaFiles, @"job-output");
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
Console.WriteLine("Downloading output asset files to local folder...");
// Download the output asset to a local folder.
outputAsset.DownloadToFolder(
outputFolder,
(af, p) =>
{
Console.WriteLine("Downloading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
});
Console.WriteLine("Downloaded files are located in '{0}'.", Path.GetFullPath(outputFolder));
}
public static void Main(string[] args)
{
try
{
string accountName = ConfigurationManager.AppSettings["MediaServicesAccountName"];
string accountKey = ConfigurationManager.AppSettings["MediaServicesAccountKey"];
MediaServicesCredentials credentials = new MediaServicesCredentials(accountName, accountKey);
MediaContextBase context = new CloudMediaContext(credentials);
Console.WriteLine("Creating new asset from local file...");
// 1. Create a new asset by uploading a mezzanine file from a local path.
IAsset inputAsset = context.Assets.CreateFromFile(
"video.mp4",
AssetCreationOptions.None,
(af, p) =>
{
Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
});
Console.WriteLine("Asset created.");
// 2. Prepare a job with two tasks:
// - One to transcode the previous mezzanine asset into a multi-bitrate asset
// - One to generate a closed captioning TTML file from the audio
IJob job = context.Jobs.Create("Demo Job");
IMediaProcessor azureMediaEncoder = context.MediaProcessors.GetLatestMediaProcessorByName("Azure Media Encoder");
ITask encodingTask = job.Tasks.AddNew("Encoding Task", azureMediaEncoder, MediaEncoderTaskPresetStrings.H264AdaptiveBitrateMP4Set720p, TaskOptions.None);
encodingTask.InputAssets.Add(inputAsset);
encodingTask.OutputAssets.AddNew("Multibitrate Asset", AssetCreationOptions.None);
IMediaProcessor azureMediaIndexer = context.MediaProcessors.GetLatestMediaProcessorByName("Azure Media Indexer");
ITask indexingTask = job.Tasks.AddNew("Indexing Task", azureMediaIndexer, Resources.IndexerPreset, TaskOptions.None);
indexingTask.InputAssets.Add(inputAsset);
indexingTask.OutputAssets.AddNew("Indexer Result Asset", AssetCreationOptions.None);
Console.WriteLine("Submitting transcoding job...");
// 3. Submit the job and wait until it is completed.
job.Submit();
job = job.StartExecutionProgressTask(
j =>
{
Console.WriteLine("Job state: {0}", j.State);
Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress());
},
CancellationToken.None).Result;
Console.WriteLine("Transcoding job finished.");
IAsset multibitrateOutputAsset = job.OutputMediaAssets[0];
IAsset indexerResultOutputAsset = job.OutputMediaAssets[1];
Console.WriteLine("Creating key authorization policy and delivery policy...");
// 4. [Dynamic Encryption] Configure Key Authorization Policy and Asset Delivery Policy
IContentKey key = CreateEnvelopeTypeContentKey(context, multibitrateOutputAsset);
AddOpenRestrictedAuthorizationPolicy(context, key);
CreateAssetDeliveryPolicy(context, multibitrateOutputAsset, key);
Console.WriteLine("Publishing output asset...");
// 5. Publish the output asset by creating an Origin locator for adaptive streaming, and a SAS locator for progressive download.
context.Locators.Create(LocatorType.OnDemandOrigin, multibitrateOutputAsset, AccessPermissions.Read, TimeSpan.FromDays(30));
context.Locators.Create(LocatorType.Sas, multibitrateOutputAsset, AccessPermissions.Read, TimeSpan.FromDays(30));
IEnumerable<IAssetFile> mp4AssetFiles = multibitrateOutputAsset
.AssetFiles
.ToList()
.Where(af => af.Name.EndsWith(".mp4", StringComparison.OrdinalIgnoreCase));
// 6. [Dynamic Packaging] Generate the Smooth Streaming, HLS and MPEG-DASH URLs for adaptive streaming
Uri smoothStreamingUri = multibitrateOutputAsset.GetSmoothStreamingUri();
Uri hlsv4Uri = multibitrateOutputAsset.GetHlsUri();
Uri hlsv3Uri = multibitrateOutputAsset.GetHlsv3Uri();
Uri mpegDashUri = multibitrateOutputAsset.GetMpegDashUri();
// 7. Generate SAS URL for progressive download.
List<Uri> mp4ProgressiveDownloadUris = mp4AssetFiles.Select(af => af.GetSasUri()).ToList();
// 8. Get the asset URLs.
Console.WriteLine(smoothStreamingUri);
Console.WriteLine(hlsv4Uri);
Console.WriteLine(hlsv3Uri);
Console.WriteLine(mpegDashUri);
mp4ProgressiveDownloadUris.ForEach(uri => Console.WriteLine(uri));
Console.WriteLine("Output asset available for adaptive streaming and progressive download.");
string outputFolder = "indexer-job-output";
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
Console.WriteLine("Downloading output asset files to local folder...");
// 9. Download the indexer result output asset to a local folder.
indexerResultOutputAsset.DownloadToFolder(
outputFolder,
(af, p) =>
{
Console.WriteLine("Downloading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
});
Console.WriteLine("Indexer output files available at '{0}'.", Path.GetFullPath(outputFolder));
Console.WriteLine("VOD workflow finished.");
}
catch (Exception exception)
{
// Parse the XML error message in the Media Services response and create a new
// exception with its content.
exception = MediaServicesExceptionParser.Parse(exception);
Console.Error.WriteLine(exception.Message);
}
finally
{
Console.ReadLine();
}
}
static void Main(string[] args)
{
try
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the chached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
// Add calls to methods defined in this section.
IAsset inputAsset =
UploadFile(@"D:\MediaServices\dotnetsdk\dotnetsdk\videos\Wildlife.wmv", AssetCreationOptions.None);
IAsset encodedAsset =
EncodeToAdaptiveBitrateMP4s(inputAsset, AssetCreationOptions.None);
PublishAssetGetURLs(encodedAsset);
}
catch (Exception exception)
{
// Parse the XML error message in the Media Services response and create a new
// exception with its content.
exception = MediaServicesExceptionParser.Parse(exception);
Console.Error.WriteLine(exception.Message);
}
finally
{
Console.ReadLine();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="apiServer">A <see cref="Uri"/> representing the API endpoint.</param>
/// <param name="credentials">Microsoft WindowsAzure Media Services credentials.</param>
public CloudMediaContext(Uri apiServer, MediaServicesCredentials credentials)
{
this.apiServer = apiServer;
this.ParallelTransferThreadCount = 10;
this.NumberOfConcurrentTransfers = 2;
this.Credentials = credentials;
dataServiceAdapter = new OAuthDataServiceAdapter(credentials, NimbusRestApiCertificateThumbprint, NimbusRestApiCertificateSubject);
versionAdapter = new ServiceVersionAdapter(KnownApiVersions.Current);
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="credentials">Microsoft WindowsAzure Media Services credentials.</param>
public CloudMediaContext(MediaServicesCredentials credentials)
: this(_mediaServicesUri, credentials)
{
}
static void Main(string[] args)
{
//
// Get all of the values we need from the App.Config
//
string mediaServicesAccountName = ConfigurationManager.AppSettings["MediaServiceAccountName"];
string mediaServicesAccountKey = ConfigurationManager.AppSettings["MediaServiceAccountKey"];
string clientId = ConfigurationManager.AppSettings["AcsAccountName"];
string clientSecret = ConfigurationManager.AppSettings["AcsAccountKey"];
string issuerString = ConfigurationManager.AppSettings["AcsEndpoint"];
string scopeString = ConfigurationManager.AppSettings["AcsScope"];
string signingKeyString = ConfigurationManager.AppSettings["AcsSigningKey"];
byte[] signingKey = Convert.FromBase64String(signingKeyString);
//
// Create the context to talk to Azure Media Services
//
MediaServicesCredentials creds = new MediaServicesCredentials(mediaServicesAccountName, mediaServicesAccountKey);
CloudMediaContext context = new CloudMediaContext(creds);
//
// Setup Media Services for Key Delivery of an Envelope Content Key with a Token Restriction.
// The GetTokenRestriction method has all of the details on how the ACS parameters from the App.Config
// are used to configure the token validation logic associated with delivering the content key.
//
List<ContentKeyAuthorizationPolicyRestriction> restrictions = GetTokenRestriction("Token Restriction using token from ACS", issuerString, scopeString, signingKey);
IContentKey contentKey = SetupContentKey(context, restrictions);
//
// Now simulate a client downloading the content key to use for playback by
// using ACS to get an authentication token and using the token to download
// the Envelope key from the Key Delivery service.
//
string authToken = GetToken(clientId, clientSecret, scopeString, issuerString);
Uri keyUrl = contentKey.GetKeyDeliveryUrl(ContentKeyDeliveryType.BaselineHttp);
using (WebClient client = new WebClient())
{
Console.WriteLine("Token=Bearer " + authToken);
client.Headers["Authorization"] = "Bearer " + authToken;
byte[] downloadedKeyValue;
try
{
downloadedKeyValue = client.DownloadData(keyUrl);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\nContent Key acquired successfully!");
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\nKey acquisition failed.\n{0}", ex.Message);
}
}
Console.ResetColor();
Console.ReadLine();
}
private static void SetMediaServicesCredentials()
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the cached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="apiServer">A <see cref="Uri"/> representing the API endpoint.</param>
/// <param name="credentials">Microsoft WindowsAzure Media Services credentials.</param>
public CloudMediaContext(Uri apiServer, MediaServicesCredentials credentials)
{
this.ParallelTransferThreadCount = 10;
this.NumberOfConcurrentTransfers = 2;
this.Credentials = credentials;
OAuthDataServiceAdapter dataServiceAdapter =
new OAuthDataServiceAdapter(credentials, NimbusRestApiCertificateThumbprint, NimbusRestApiCertificateSubject);
ServiceVersionAdapter versionAdapter = new ServiceVersionAdapter(KnownApiVersions.Current);
this.MediaServicesClassFactory = new AzureMediaServicesClassFactory(apiServer, dataServiceAdapter, versionAdapter, this);
this._jobs = new JobBaseCollection(this);
this._jobTemplates = new JobTemplateBaseCollection(this);
this._assets = new AssetCollection(this);
this._files = new AssetFileCollection(this);
this._accessPolicies = new AccessPolicyBaseCollection(this);
this._contentKeys = new ContentKeyCollection(this);
this._notificationEndPoints = new NotificationEndPointCollection(this);
this._mediaProcessors = new MediaProcessorBaseCollection(this);
this._locators = new LocatorBaseCollection(this);
this._ingestManifests = new IngestManifestCollection(this);
this._ingestManifestAssets = new IngestManifestAssetCollection(this,null);
this._ingestManifestFiles = new IngestManifestFileCollection(this, null);
this._storageAccounts = new StorageAccountBaseCollection(this);
}
static MediaService()
{
//init contexts.
_cachedCredentials = new MediaServicesCredentials(_mediaServicesAccountName, _mediaServicesAccountKey);
_context = new CloudMediaContext(_cachedCredentials);
}
static void Main(string[] args)
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the chached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
bool tokenRestriction = true;
string tokenTemplateString = null;
IAsset asset = UploadFileAndCreateAsset(_singleMP4File);
Console.WriteLine("Uploaded asset: {0}", asset.Id);
IAsset encodedAsset = EncodeToAdaptiveBitrateMP4Set(asset);
Console.WriteLine("Encoded asset: {0}", encodedAsset.Id);
IContentKey key = CreateEnvelopeTypeContentKey(encodedAsset);
Console.WriteLine("Created key {0} for the asset {1} ", key.Id, encodedAsset.Id);
Console.WriteLine();
if (tokenRestriction)
tokenTemplateString = AddTokenRestrictedAuthorizationPolicy(key);
else
AddOpenAuthorizationPolicy(key);
Console.WriteLine("Added authorization policy: {0}", key.AuthorizationPolicyId);
Console.WriteLine();
CreateAssetDeliveryPolicy(encodedAsset, key);
Console.WriteLine("Created asset delivery policy. \n");
Console.WriteLine();
if (tokenRestriction && !String.IsNullOrEmpty(tokenTemplateString))
{
// Deserializes a string containing an Xml representation of a TokenRestrictionTemplate
// back into a TokenRestrictionTemplate class instance.
TokenRestrictionTemplate tokenTemplate =
TokenRestrictionTemplateSerializer.Deserialize(tokenTemplateString);
// Generate a test token based on the data in the given TokenRestrictionTemplate.
// Note, you need to pass the key id Guid because we specified
// TokenClaim.ContentKeyIdentifierClaim in during the creation of TokenRestrictionTemplate.
Guid rawkey = EncryptionUtils.GetKeyIdAsGuid(key.Id);
//The GenerateTestToken method returns the token without the word “Bearer” in front
//so you have to add it in front of the token string.
string testToken = TokenRestrictionTemplateSerializer.GenerateTestToken(tokenTemplate, null, rawkey, DateTime.UtcNow.AddDays(365));
Console.WriteLine("The authorization token is:\nBearer {0}", testToken);
Console.WriteLine();
}
// You can use the bit.ly/aesplayer Flash player to test the URL
// (with open authorization policy).
// Paste the URL and click the Update button to play the video.
//
string URL = GetStreamingOriginLocator(encodedAsset);
Console.WriteLine("Smooth Streaming Url: {0}/manifest", URL);
Console.WriteLine();
Console.WriteLine("HLS Url: {0}/manifest(format=m3u8-aapl)", URL);
Console.WriteLine();
Console.ReadLine();
}
static void Main(string[] args)
{
try
{
MediaServicesCredentials credentials = new MediaServicesCredentials(_mediaServicesAccountName, _mediaServicesAccountKey);
CloudMediaContext context = new CloudMediaContext(credentials);
Console.WriteLine("Creating new asset from local file...");
// 1. Create a new asset by uploading a mezzanine file from a local path.
IAsset inputAsset = context.Assets.CreateFromFile(_singleInputMp4Path, AssetCreationOptions.None,
(af, p) =>
{
Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
});
Console.WriteLine("Asset created.");
// 2. Prepare a job with a single task to transcode the previous mezzanine asset
// into a multi-bitrate asset.
IJob job = context.Jobs.CreateWithSingleTask(MediaProcessorNames.WindowsAzureMediaEncoder,
MediaEncoderTaskPresetStrings.H264AdaptiveBitrateMP4Set720p,
inputAsset,
"Sample Adaptive Bitrate MP4",
AssetCreationOptions.None);
Console.WriteLine("Submitting transcoding job...");
// 3. Submit the job and wait until it is completed.
job.Submit();
job = job.StartExecutionProgressTask(j => {
Console.WriteLine("Job state: {0}", j.State);
Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress());
}, CancellationToken.None).Result;
Console.WriteLine("Transcoding job finished.");
IAsset outputAsset = job.OutputMediaAssets[0];
Console.WriteLine("Publishing output asset...");
// 4. Publish the output asset by creating an Origin locator for adaptive streaming,
// and a SAS locator for progressive download.
context.Locators.Create(LocatorType.OnDemandOrigin, outputAsset, AccessPermissions.Read, TimeSpan.FromDays(30));
context.Locators.Create(LocatorType.Sas, outputAsset, AccessPermissions.Read, TimeSpan.FromDays(30));
IEnumerable<IAssetFile> mp4AssetFiles = outputAsset.AssetFiles.ToList()
.Where(af => af.Name.EndsWith(".mp4", StringComparison.OrdinalIgnoreCase));
// 5. Generate the Smooth Streaming, HLS and MPEG-DASH URLs for adaptive streaming,
// and the Progressive Download URL.
Uri smoothStreamingUri = outputAsset.GetSmoothStreamingUri();
Uri hlsUri = outputAsset.GetHlsUri();
Uri mpegDashUri = outputAsset.GetMpegDashUri();
List<Uri> mp4ProgressiveDownloadUris = mp4AssetFiles.Select(af => af.GetSasUri()).ToList();
// 6. Get the asset URLs.
Console.WriteLine(smoothStreamingUri);
Console.WriteLine(hlsUri);
Console.WriteLine(mpegDashUri);
mp4ProgressiveDownloadUris.ForEach(uri => Console.WriteLine(uri));
Console.WriteLine("Output asset available for adaptive streaming and progressive download.");
Console.WriteLine("VOD workflow finished.");
}
catch (Exception exception)
{
// Parse the XML error message in the Media Services response and create a new
// exception with its content.
exception = MediaServicesExceptionParser.Parse(exception);
Console.Error.WriteLine(exception.Message);
}
finally
{
Console.ReadLine();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="apiServer">A <see cref="Uri"/> representing the API endpoint.</param>
/// <param name="credentials">Microsoft WindowsAzure Media Services credentials.</param>
public CloudMediaContext(Uri apiServer, MediaServicesCredentials credentials)
{
this.apiServer = apiServer;
this.ParallelTransferThreadCount = 10;
this.NumberOfConcurrentTransfers = 2;
this.Credentials = credentials;
}
// added by [email protected] to the original template public void ConfigureAuth(IAppBuilder app) { ApplicationDbContext db = new ApplicationDbContext(); app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType); app.UseCookieAuthentication(new CookieAuthenticationOptions()); app.UseOpenIdConnectAuthentication( new OpenIdConnectAuthenticationOptions { ClientId = clientId, Authority = Authority, PostLogoutRedirectUri = postLogoutRedirectUri, Notifications = new OpenIdConnectAuthenticationNotifications() { // If there is a code in the OpenID Connect response, redeem it for an access token and refresh token, and store those away. AuthorizationCodeReceived = (context) => { var code = context.Code; ClientCredential credential = new ClientCredential(clientId, appKey); string signedInUserID = context.AuthenticationTicket.Identity.FindFirst(ClaimTypes.NameIdentifier).Value; AuthenticationContext authContext = new AuthenticationContext(Authority, new ADALTokenCache(signedInUserID)); AuthenticationResult result = authContext.AcquireTokenByAuthorizationCode( code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential, graphResourceId); // added by [email protected] to the original template // Getting KeyDelivery Access Token AuthenticationResult kdAPiresult = authContext.AcquireTokenByAuthorizationCode( code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential, kdResourceId); string kdAccessToken = kdAPiresult.AccessToken; System.IdentityModel.Tokens.JwtSecurityToken kdAccessJwtToken = new System.IdentityModel.Tokens.JwtSecurityToken(kdAccessToken); try { // Initializing MediaServicesCredentials in order to obtain access token to be used to connect var amsCredentials = new MediaServicesCredentials(mediaServicesAccount, mediaServicesKey); // Forces to get access token amsCredentials.RefreshToken(); //Adding media services access token as claim so it can be accessible within controller context.AuthenticationTicket.Identity.AddClaim(new System.Security.Claims.Claim(VideoPortalDemo.Configurations.ClaimsAmsAcessToken, amsCredentials.AccessToken)); } catch { } //context.AuthenticationTicket.Identity.AddClaim( // new System.Security.Claims.Claim("KdAccessJwtSecurityTokenClaim", kdAccessJwtToken.RawData)); // added by [email protected] to the original template return Task.FromResult(0); } } }); }
//
// The Client ID is used by the application to uniquely identify itself to Azure AD.
// The App Key is a credential used to authenticate the application to Azure AD. Azure AD supports password and certificate credentials.
// The Metadata Address is used by the application to retrieve the signing keys used by Azure AD.
// The AAD Instance is the instance of Azure, for example public Azure or Azure China.
// The Authority is the sign-in URL of the tenant.
// The Post Logout Redirect Uri is the URL where the user will be redirected after they sign out.
//
// This is the resource ID of the AAD Graph API. We'll need this to request a token to call the Graph API.
public void ConfigureAuth(IAppBuilder app)
{
app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);
app.UseCookieAuthentication(new CookieAuthenticationOptions());
app.UseOpenIdConnectAuthentication(
new OpenIdConnectAuthenticationOptions
{
ClientId = MediaLibraryWebApp.Configuration.ClientId,
Authority = MediaLibraryWebApp.Configuration.Authority,
PostLogoutRedirectUri = MediaLibraryWebApp.Configuration.PostLogoutRedirectUri,
Notifications = new OpenIdConnectAuthenticationNotifications()
{
//
// If there is a code in the OpenID Connect response, redeem it for an access token and refresh token, and store those away.
//
AuthorizationCodeReceived = (context) =>
{
var code = context.Code;
System.IdentityModel.Tokens.JwtSecurityToken jwtToken = context.JwtSecurityToken;
string userObjectID = context.AuthenticationTicket.Identity.FindFirst(MediaLibraryWebApp.Configuration.ClaimsObjectidentifier).Value;
Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential credential = new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential(MediaLibraryWebApp.Configuration.ClientId, MediaLibraryWebApp.Configuration.AppKey);
NaiveSessionCache cache = new NaiveSessionCache(userObjectID);
AuthenticationContext authContext = new AuthenticationContext(MediaLibraryWebApp.Configuration.Authority, cache);
//Getting a token to connect with GraphApi later on userProfile page
AuthenticationResult graphAPiresult = authContext.AcquireTokenByAuthorizationCode(code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential, MediaLibraryWebApp.Configuration.GraphResourceId);
//Getting a access token which can be used to configure auth restrictions for multiple tentants since audience will be same for each web app requesting this token
//AuthenticationResult kdAPiresult = authContext.AcquireTokenByAuthorizationCode(code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential, MediaLibraryWebApp.Configuration.KdResourceId);
//string kdAccessToken = kdAPiresult.AccessToken;
//Initializing MediaServicesCredentials in order to obtain access token to be used to connect
var amsCredentials = new MediaServicesCredentials(MediaLibraryWebApp.Configuration.MediaAccount, MediaLibraryWebApp.Configuration.MediaKey);
//Forces to get access token
amsCredentials.RefreshToken();
//Adding token to a claim so it can be accessible within controller
context.AuthenticationTicket.Identity.AddClaim(new Claim(MediaLibraryWebApp.Configuration.ClaimsSignInJwtToken, jwtToken.RawData));
//Adding media services access token as claim so it can be accessible within controller
context.AuthenticationTicket.Identity.AddClaim(new Claim(MediaLibraryWebApp.Configuration.ClaimsAmsAcessToken, amsCredentials.AccessToken));
return Task.FromResult(0);
}
}
});
}
static void Main(string[] args)
{
try
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the chached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
// If you want to secure your high quality input media files with strong encryption at rest on disk,
// use AssetCreationOptions.StorageEncrypted instead of AssetCreationOptions.None.
Console.WriteLine("Upload a file.\n");
IAsset inputAsset =
UploadFile(Path.Combine(_mediaFiles, @"BigBuckBunny.mp4"), AssetCreationOptions.None);
Console.WriteLine("Generate thumbnails and get URLs.\n");
IAsset thumbnailAsset = GenerateThumbnail(inputAsset, AssetCreationOptions.None);
PublishAssetGetURLs(thumbnailAsset, false, ".bmp");
Console.WriteLine("Encode to audio and get an on demand URL.\n");
IAsset audioOnly = EncodeToAudioOnly(inputAsset, AssetCreationOptions.None);
PublishAssetGetURLs(audioOnly);
Console.WriteLine("Encode to adaptive bitraite MP4s and get on demand URLs.\n");
// If you want to secure your high quality encoded media files with strong encryption at rest on disk,
// use AssetCreationOptions.StorageEncrypted instead of AssetCreationOptions.None.
//
// If your asset is AssetCreationOptions.StorageEncrypted,
// make sure to call ConfigureClearAssetDeliveryPolicy defined below.
IAsset encodedAsset =
EncodeToAdaptiveBitrateMP4s(inputAsset, AssetCreationOptions.None);
// If your want to delivery a storage encrypted asset,
// you must configure the asset’s delivery policy.
// Before your asset can be streamed,
// the streaming server removes the storage encryption and
//streams your content using the specified delivery policy.
// ConfigureClearAssetDeliveryPolicy(encodedAsset);
PublishAssetGetURLs(encodedAsset);
}
catch (Exception exception)
{
// Parse the XML error message in the Media Services response and create a new
// exception with its content.
exception = MediaServicesExceptionParser.Parse(exception);
Console.Error.WriteLine(exception.Message);
}
finally
{
Console.ReadLine();
}
}
/// <summary>
/// Example where I encode 2 video files (_singleWMVInputFilePath.wmv and 2.mp4)
/// </summary>
/// <param name="aOutputFileFolder"></param>
/// <returns></returns>
public static bool CreateandEncodeOnDemandFile(string aOutputFileFolder, string _singleMP4InputFilePath, string _singleWMVInputFilePath)
{
bool tempresult = true;
try
{
// Create and cache the Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey);
// Used the chached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
IAsset singleWMVAsset = CreateAssetAndUploadSingleFile(AssetCreationOptions.None,
_singleWMVInputFilePath);
// EncodeToH264 creates a job with one task
// that converts a mezzanine file (in this case interview1.wmv)
// into an MP4 file (in this case, "H264 Broadband 720p").
IAsset MP4Asset = CreateEncodingJob(singleWMVAsset, "H264 Broadband 720p", aOutputFileFolder);
// BuildSasUrlForMP4File creates a SAS Locator
// and builds the SAS Url that can be used to
// progressively download the MP4 file.
string fullSASURL = BuildSasUrlForMP4File(MP4Asset);
Console.WriteLine("Progressive download URL: {0}", fullSASURL);
// Download all the files in the asset locally
// (that includes the mainifest.xml file).
DownloadAssetToLocal(MP4Asset, _outputFilesFolder);
Console.WriteLine();
IAsset singleMP4Asset = CreateAssetAndUploadSingleFile(AssetCreationOptions.None,
_singleMP4InputFilePath);
// EncodeToAdaptiveBitrate creates a job with one task
// that encodes a mezzanine file (in this case BigBuckBunny.mp4)
// into an adaptive bitrate MP4 set (in this case, "H264 Adaptive Bitrate MP4 Set 720p").
IAsset adaptiveBitrateAsset = CreateEncodingJob(singleMP4Asset, "H264 Adaptive Bitrate MP4 Set 720p", aOutputFileFolder);
// Get the Streaming Origin Locator URL.
string streamingURL = GetStreamingOriginLocatorURL(adaptiveBitrateAsset);
// Add Smooth Streaming, HLS, and DASH format to the streaming URL.
// NOTE: To be able to play these streams based on the
// adaptiveBitrateAsset asset, you MUST have at least one
// On-demand Streaming reserved unit.
// For more information, see:
// Dynamic Packaging (http://msdn.microsoft.com/en-us/library/azure/jj889436.aspx)
Console.WriteLine("Smooth Streaming format:");
Console.WriteLine("{0}", streamingURL + "/Manifest");
Console.WriteLine("Apple HLS format:");
Console.WriteLine("{0}", streamingURL + "/Manifest(format=m3u8-aapl)");
Console.WriteLine("MPEG DASH format:");
Console.WriteLine("{0}", streamingURL + "/Manifest(format=mpd-time-csf)");
}
catch (Exception)
{
tempresult = false;
}
return tempresult;
}
static void Main(string[] args)
{
_cachedCredentials = new MediaServicesCredentials(
_accountName,
_accountKey);
// Use the cached credentials to create CloudMediaContext.
_context = new CloudMediaContext(_cachedCredentials);
// In this example the storage account from which we copy blobs is not
// associated with the Media Services account into which we copy blobs.
// But the same code will work for coping blobs from a storage account that is
// associated with the Media Services account.
//
// Get a reference to a storage account that is not associated with a Media Services account
// (an external account).
StorageCredentials externalStorageCredentials =
new StorageCredentials(_externalStorageAccountName, _externalStorageAccountKey);
_sourceStorageAccount = new CloudStorageAccount(externalStorageCredentials, true);
//Get a reference to the storage account that is associated with a Media Services account.
StorageCredentials mediaServicesStorageCredentials =
new StorageCredentials(_storageAccountName, _storageAccountKey);
_destinationStorageAccount = new CloudStorageAccount(mediaServicesStorageCredentials, false);
// Upload Smooth Streaming files into a storage account.
string localMediaDir = @"C:\supportFiles\streamingfiles";
CloudBlobContainer blobContainer =
UploadContentToStorageAccount(localMediaDir);
// Create a new asset and copy the smooth streaming files into
// the container that is associated with the asset.
IAsset asset = CreateAssetFromExistingBlobs(blobContainer);
// Get the streaming URL for the smooth streaming files
// that were copied into the asset.
string urlForClientStreaming = CreateStreamingLocator(asset);
Console.WriteLine("Smooth Streaming URL: " + urlForClientStreaming);
Console.ReadLine();
}
