////////////////////////////////////////////////////////////// NEW VERSION //////////////////////////////////////////////////////////////////////////////////// public static IJob SubmitEncodingJobWithNotificationEndPoint(CloudMediaContext _context, string mediaProcessorName, InitialSetupResult initialSetup, INotificationEndPoint _notificationEndPoint) { // Declare a new job. IJob job = _context.Jobs.Create($"Job_Encoding_{initialSetup.Video.VideoFileName}"); //Create an encrypted asset and upload the mp4 IAsset asset = LoadExistingAsset(initialSetup.Asset.Id, _context); // Get a media processor reference, and pass to it the name of the // processor to use for the specific task. IMediaProcessor processor = GetLatestMediaProcessorByName(mediaProcessorName, _context); // Create a task with the conversion details, using a configuration file. ITask task = job.Tasks.AddNew($"Job_Encoding_Task_{initialSetup.Video.VideoFileName}", processor, "Adaptive Streaming", Microsoft.WindowsAzure.MediaServices.Client.TaskOptions.None); // Specify the input asset to be encoded. task.InputAssets.Add(asset); // Add an output asset to contain the results of the job. task.OutputAssets.AddNew($"Output_Encoding_{initialSetup.Video.VideoFileName}", AssetCreationOptions.None); // Add a notification point to the job. You can add multiple notification points. job.JobNotificationSubscriptions.AddNew(NotificationJobState.FinalStatesOnly, _notificationEndPoint); job.Submit(); return(job); }
public PageService( IProjectService projectService, IPageQueries pageQueries, IPageCommands pageCommands, PageEvents eventHandlers, IMediaProcessor mediaProcessor, IContentProcessor contentProcessor, IPageUrlResolver pageUrlResolver, IMemoryCache cache, IStringLocalizer <cloudscribe.SimpleContent.Web.SimpleContent> localizer, IPageNavigationCacheKeys cacheKeys, IContentHistoryCommands historyCommands, ILogger <PageService> logger ) { _projectService = projectService; _pageQueries = pageQueries; _pageCommands = pageCommands; _mediaProcessor = mediaProcessor; _pageUrlResolver = pageUrlResolver; _contentProcessor = contentProcessor; _cache = cache; _cacheKeys = cacheKeys; _eventHandlers = eventHandlers; _sr = localizer; _historyCommands = historyCommands; _log = logger; }
private static async Task <IJob> CreateMediaEncodeJob(CloudMediaContext context, IAsset assetToEncode) { //string encodingPreset = "H264 Broadband 720p"; string encodingPreset = "H264 Smooth Streaming 720p"; IJob job = context.Jobs.Create("Encoding " + assetToEncode.Name + " to " + encodingPreset); string[] y = context.MediaProcessors.Where(mp => mp.Name.Equals("Azure Media Encoder")) .ToArray() .Select(mp => mp.Version) .ToArray(); IMediaProcessor latestWameMediaProcessor = context.MediaProcessors.Where(mp => mp.Name.Equals("Azure Media Encoder")) .ToArray() .OrderByDescending( mp => new Version(int.Parse(mp.Version.Split('.', ',')[0]), int.Parse(mp.Version.Split('.', ',')[1]))) .First(); ITask encodeTask = job.Tasks.AddNew("Encoding", latestWameMediaProcessor, encodingPreset, TaskOptions.None); encodeTask.InputAssets.Add(assetToEncode); encodeTask.OutputAssets.AddNew(assetToEncode.Name + " as " + encodingPreset, AssetCreationOptions.None); job.StateChanged += new EventHandler <JobStateChangedEventArgs>((sender, jsc) => Console.WriteLine( $"{((IJob) sender).Name}\n State: {jsc.CurrentState}\n Time: {DateTime.UtcNow.ToString(@"yyyy_M_d_hhmmss")}\n\n")); return(await job.SubmitAsync()); }
public void ShouldSubmitAndFinishJobWithMultipleAssetAndVerifyOrderOfInputAssets() { // Create multiple assets, set them as parents for a job, and validate that the parent links are set. IAsset asset1 = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallWmv2, AssetCreationOptions.StorageEncrypted); IAsset asset2 = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IAsset asset3 = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallMp41, AssetCreationOptions.StorageEncrypted); asset1.Name = "SmallWmv2"; asset2.Name = "SmallWmv"; asset3.Name = "SmallMP41"; asset1.Update(); asset2.Update(); asset3.Update(); string configuration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.MultiConfig); IJob job = _mediaContext.Jobs.Create("Test"); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); ITask task = job.Tasks.AddNew("Task1", mediaProcessor, configuration, TaskOptions.None); task.InputAssets.Add(asset1); task.InputAssets.Add(asset2); task.InputAssets.Add(asset3); task.OutputAssets.AddNew("JobOutput", options: AssetCreationOptions.None); job.Submit(); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); Assert.IsTrue(job.InputMediaAssets.Count == 3); Assert.IsTrue(job.InputMediaAssets[0].Name == "SmallWmv2"); Assert.IsTrue(job.InputMediaAssets[1].Name == "SmallWmv"); Assert.IsTrue(job.InputMediaAssets[2].Name == "SmallMP41"); }
internal IJob CreateJob(MediaJob mediaJob) { IJob job = _media.Jobs.Create(mediaJob.Name, mediaJob.Priority); foreach (MediaJobTask jobTask in mediaJob.Tasks) { string processorId = Processors.GetMediaProcessorId(jobTask.MediaProcessor); IMediaProcessor processor = GetEntityById(MediaEntity.Processor, processorId) as IMediaProcessor; ITask currentTask = job.Tasks.AddNew(jobTask.Name, processor, jobTask.ProcessorConfig, jobTask.Options); if (jobTask.ParentIndex.HasValue) { ITask parentTask = job.Tasks[jobTask.ParentIndex.Value]; currentTask.InputAssets.AddRange(parentTask.OutputAssets); } else { IAsset[] assets = GetAssets(jobTask.InputAssetIds); currentTask.InputAssets.AddRange(assets); } currentTask.OutputAssets.AddNew(jobTask.OutputAssetName, jobTask.OutputAssetEncryption, jobTask.OutputAssetFormat); } INotificationEndPoint notificationEndpoint = GetNotificationEndpoint(mediaJob.Notification); if (notificationEndpoint != null) { job.JobNotificationSubscriptions.AddNew(NotificationJobState.FinalStatesOnly, notificationEndpoint); } SetProcessorUnits(job, mediaJob.Scale); job.Submit(); return(job); }
public void ShouldCreateJobWithMultipleAssetsAndValidateParentLinks() { // Create multiple assets, set them as parents for a job, and validate that the parent links are set. IAsset asset1 = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IAsset asset2 = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallWmv2, AssetCreationOptions.StorageEncrypted); IAsset asset3 = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallMp41, AssetCreationOptions.StorageEncrypted); string configuration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.MultiConfig); IJob job = _mediaContext.Jobs.Create("Test"); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); ITask task = job.Tasks.AddNew("Task1", mediaProcessor, configuration, TaskOptions.None); task.InputAssets.Add(asset1); task.InputAssets.Add(asset2); task.InputAssets.Add(asset3); task.OutputAssets.AddNew("JobOutput", options: AssetCreationOptions.None); job.Submit(); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished, delegate(double d) { Console.WriteLine(d); }); Assert.IsTrue(job.OutputMediaAssets[0].ParentAssets.Count == 3); IEnumerable <string> parentIds = job.OutputMediaAssets[0].ParentAssets.Select(a => a.Id); Assert.IsTrue(parentIds.Contains(asset1.Id)); Assert.IsTrue(parentIds.Contains(asset2.Id)); Assert.IsTrue(parentIds.Contains(asset3.Id)); }
public static int AddTask(Microsoft.Azure.WebJobs.ExecutionContext execContext, CloudMediaContext context, IJob job, IAsset sourceAsset, string value, string processor, string presetfilename, string stringtoreplace, ref int taskindex, int priority = 10, string specifiedStorageAccountName = null) { if (value != null) { // Get a media processor reference, and pass to it the name of the // processor to use for the specific task. IMediaProcessor mediaProcessor = MediaServicesHelper.GetLatestMediaProcessorByName(context, processor); string presetPath = Path.Combine(System.IO.Directory.GetParent(execContext.FunctionDirectory).FullName, "presets", presetfilename); string Configuration = File.ReadAllText(presetPath).Replace(stringtoreplace, value); // Create a task with the encoding details, using a string preset. var task = job.Tasks.AddNew(processor + " task", mediaProcessor, Configuration, TaskOptions.None); task.Priority = priority; // Specify the input asset to be indexed. task.InputAssets.Add(sourceAsset); // Add an output asset to contain the results of the job. // Use a non default storage account in case this was provided in 'AddTask' task.OutputAssets.AddNew(sourceAsset.Name + " " + processor + " Output", specifiedStorageAccountName, AssetCreationOptions.None); return(taskindex++); } else { return(-1); } }
public BlogService( IProjectService projectService, IProjectSecurityResolver security, IPostQueries postQueries, IPostCommands postCommands, IMediaProcessor mediaProcessor, IContentProcessor contentProcessor, //IHtmlProcessor htmlProcessor, IBlogRoutes blogRoutes, PostEvents eventHandlers, IUrlHelperFactory urlHelperFactory, IActionContextAccessor actionContextAccesor, IHttpContextAccessor contextAccessor = null) { _security = security; _postQueries = postQueries; _postCommands = postCommands; context = contextAccessor?.HttpContext; _mediaProcessor = mediaProcessor; _urlHelperFactory = urlHelperFactory; _actionContextAccesor = actionContextAccesor; _projectService = projectService; _contentProcessor = contentProcessor; _blogRoutes = blogRoutes; _eventHandlers = eventHandlers; }
static public IAsset EncodeToAdaptiveBitrateMP4Set(IAsset asset) { // Declare a new job. IJob job = _context.Jobs.Create("Media Encoder Standard Job"); // Get a media processor reference, and pass to it the name of the // processor to use for the specific task. IMediaProcessor processor = GetLatestMediaProcessorByName("Media Encoder Standard"); // Create a task with the encoding details, using a string preset. // In this case "H264 Multiple Bitrate 720p" preset is used. ITask task = job.Tasks.AddNew("My encoding task", processor, "H264 Multiple Bitrate 720p", TaskOptions.None); // Specify the input asset to be encoded. task.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is not encrypted. task.OutputAssets.AddNew("Output asset", AssetCreationOptions.None); job.StateChanged += new EventHandler <JobStateChangedEventArgs>(JobStateChanged); job.Submit(); job.GetExecutionProgressTask(CancellationToken.None).Wait(); return(job.OutputMediaAssets[0]); }
public MetaWeblogService( IProjectService projectService, IProjectSecurityResolver security, IContentHistoryCommands contentHistoryCommands, IPageUrlResolver pageUrlResolver, IBlogUrlResolver blogUrlResolver, IMediaProcessor mediaProcessor, ITimeZoneHelper timeZoneHelper, ITreeCache treeCache, ILogger <MetaWeblogService> logger, IBlogService blogService = null, IPageService pageService = null ) { _projectService = projectService; _security = security; _contentHistoryCommands = contentHistoryCommands; _pageUrlResolver = pageUrlResolver; _blogUrlResolver = blogUrlResolver; _timeZoneHelper = timeZoneHelper; _blogService = blogService ?? new NotImplementedBlogService(); _pageService = pageService ?? new NotImplementedPageService(); _mediaProcessor = mediaProcessor; _mapper = new MetaWeblogModelMapper(); _navigationCache = treeCache; _log = logger; }
public void Encode(IAsset asset, params string[] encodings) { IJob job = mediaContext.Jobs.Create("Encoding task"); var theProcessor = from p in mediaContext.MediaProcessors where p.Name == "Windows Azure Media Encoder" select p; //string configuration = File.ReadAllText(configFilePath); IMediaProcessor processor = theProcessor.First(); var i = 0; foreach (var encoding in encodings) { ITask task = job.Tasks.AddNew(i.ToString() + " task", processor, encoding, TaskCreationOptions.ProtectedConfiguration); task.InputMediaAssets.Add(asset); task.OutputMediaAssets.AddNew(i.ToString() + " output asset", true, AssetCreationOptions.CommonEncryptionProtected); i++; } job.Submit(); CheckJobProgress(job.Id); job = GetJob(job.Id); IAsset outputAsset = job.OutputMediaAssets[0]; GetSasUrl(outputAsset, TimeSpan.FromMinutes(5)); }
public void ShouldReportJobProgress() { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); string name = GenerateName("Job 1"); IJob job = CreateAndSubmitOneTaskJob(_mediaContext, name, mediaProcessor, GetWamePreset(mediaProcessor), asset, TaskOptions.None); bool progressChanged = false; var task = Task.Factory.StartNew(delegate { while (!IsFinalJobState(job.State)) { Thread.Sleep(100); double progress = job.Tasks[0].Progress; if (progress > 0 && progress < 100) { progressChanged = true; } job.Refresh(); } }); task.Wait(); task.ThrowIfFaulted(); Assert.AreEqual(JobState.Finished, job.State); Assert.IsTrue(progressChanged, "Task progress has not been changed while job is expected to be finished"); }
public void ShouldSubmitJobWhereOutPutInNoneDefaultStorage() { var nondefault = _mediaContext.StorageAccounts.Where(c => c.IsDefault == false).FirstOrDefault(); //This test need to be executed when media account multiple storage account associated with it. if (nondefault == null) { return; } IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); string name = GenerateName("Job 1"); IJob job = _mediaContext.Jobs.Create(name); ITask task = job.Tasks.AddNew("Task1", mediaProcessor, GetWamePreset(mediaProcessor), TaskOptions.None); task.InputAssets.Add(asset); var outputAsset = task.OutputAssets.AddNew("Output asset", nondefault.Name, AssetCreationOptions.None); job.Submit(); Assert.AreEqual(nondefault.Name, outputAsset.StorageAccountName, "Storage account are not matching"); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); var refreshed = _mediaContext.Jobs.Where(c => c.Id == job.Id).FirstOrDefault(); Assert.IsNotNull(refreshed); Assert.AreEqual(1, refreshed.Tasks.Count, "Number of Tasks in job is not matching"); Assert.AreEqual(1, refreshed.Tasks[0].OutputAssets.Count, "Number of output assets in job is not matching"); Assert.AreEqual(nondefault.Name, refreshed.Tasks[0].OutputAssets[0].StorageAccountName, "Storage account name in output assset is not matching"); }
public PageService( IProjectService projectService, IProjectSecurityResolver security, IPageQueries pageQueries, IPageCommands pageCommands, PageEvents eventHandlers, IMediaProcessor mediaProcessor, IUrlHelperFactory urlHelperFactory, IMemoryCache cache, IPageNavigationCacheKeys cacheKeys, IActionContextAccessor actionContextAccesor, IHttpContextAccessor contextAccessor = null) { this.projectService = projectService; this.security = security; this.pageQueries = pageQueries; this.pageCommands = pageCommands; context = contextAccessor?.HttpContext; this.mediaProcessor = mediaProcessor; this.urlHelperFactory = urlHelperFactory; this.actionContextAccesor = actionContextAccesor; htmlProcessor = new HtmlProcessor(); this.cache = cache; this.cacheKeys = cacheKeys; this.eventHandlers = eventHandlers; }
public void EncodeAsset(IAsset asset, List <String> options) { if (context == null) { throw new ArgumentNullException("context null - can't communicate"); } if (asset == null) { throw new ArgumentNullException("asset null - can't upload"); } IJob job = context.Jobs.Create(""); mediaProcessor = GetMediaProcessor("Windows Azure Media Encoder"); foreach (String configOption in options) { ITask task = job.Tasks.AddNew("task " + configOption, mediaProcessor, configOption, TaskCreationOptions.None); task.InputMediaAssets.Add(asset); task.OutputMediaAssets.AddNew(asset.Name + " " + configOption, true, AssetCreationOptions.None); } job.Submit(); }
private IAsset CreateMbrMp4Asset(AssetCreationOptions options) { IMediaProcessor encoder = JobTests.GetEncoderMediaProcessor(_mediaContext); IJob job = _mediaContext.Jobs.Create("Job for ValidateEffectiveEncryptionStatusOfMultiBitRateMP4"); ITask adpativeBitrateTask = job.Tasks.AddNew("MP4 to Adaptive Bitrate Task", encoder, "H264 Adaptive Bitrate MP4 Set 720p", TaskOptions.None); // Specify the input Asset IAsset asset = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallMp41, AssetCreationOptions.None); adpativeBitrateTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). IAsset abrAsset = adpativeBitrateTask.OutputAssets.AddNew("Multibitrate MP4s", options); job.Submit(); job.GetExecutionProgressTask(CancellationToken.None).Wait(); job.Refresh(); return(job.OutputMediaAssets[0]); }
private IAsset CreateHlsFromSmoothAsset(IAsset sourceAsset, AssetCreationOptions options) { IJob job = _mediaContext.Jobs.Create("Smooth to Hls Job"); IMediaProcessor mediaProcessor = JobTests.GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncryptorName); string smoothToHlsConfiguration = null; if (options == AssetCreationOptions.EnvelopeEncryptionProtected) { smoothToHlsConfiguration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.SmoothToEncryptHlsConfig); } else { smoothToHlsConfiguration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.SmoothToHlsConfig); } ITask task = job.Tasks.AddNew("Smooth to Hls conversion task", mediaProcessor, smoothToHlsConfiguration, TaskOptions.None); task.InputAssets.Add(sourceAsset); task.OutputAssets.AddNew("JobOutput", options); job.Submit(); job.GetExecutionProgressTask(CancellationToken.None).Wait(); job.Refresh(); return(job.OutputMediaAssets[0]); }
private IAsset ValidateMultibitrateMP4s(IAsset multibitrateMP4sAsset) { // Set .ism as a primary file // in a multibitrate MP4 set. SetISMFileAsPrimary(multibitrateMP4sAsset); // Create a new job. IJob job = _MediaServiceContext.Jobs.Create("MP4 validation and converstion to Smooth Stream job."); // Read the task configuration data into a string. string configMp4Validation = LoadEncodeProfile(myConfig.XmlValidationProfile); // Get the SDK extension method to get a reference to the Azure Media Packager. IMediaProcessor processor = GetLatestMediaProcessorByName(myConfig.MediaProcessorName); // Create a task with the conversion details, using the configuration data. ITask task = job.Tasks.AddNew("Mp4 Validation Task", processor, configMp4Validation, TaskOptions.None); // Specify the input asset to be validated. task.InputAssets.Add(multibitrateMP4sAsset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). task.OutputAssets.AddNew(string.Format(myConfig.OutputAssetName, multibitrateMP4sAsset.Name), AssetCreationOptions.None); // Submit the job and wait until it is completed. job.Submit(); Task progressJobTask = job.GetExecutionProgressTask(CancellationToken.None); this.WaitJobFinish(job.Id); return(job.OutputMediaAssets[0]); }
/// <summary> /// Creates a task to encrypt Smooth Streaming with PlayReady. /// Note: To deliver DASH, make sure to set the useSencBox and adjustSubSamples /// configuration properties to true. /// In this example, MediaEncryptor_PlayReadyProtection.xml contains configuration. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset EncryptSmoothStreamWithPlayReadyTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Azure Media Encryptor. IMediaProcessor playreadyProcessor = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaEncryptor); // Read the configuration XML. // // Note that the configuration defined in MediaEncryptor_PlayReadyProtection.xml // is using keySeedValue. It is recommended that you do this only for testing // and not in production. For more information, see // http://msdn.microsoft.com/en-us/library/windowsazure/dn189154.aspx. // string configPlayReady = File.ReadAllText(Path.Combine(_configurationXMLFiles, @"MediaEncryptor_PlayReadyProtection.xml")); ITask playreadyTask = job.Tasks.AddNew("My PlayReady Task", playreadyProcessor, configPlayReady, TaskOptions.ProtectedConfiguration); playreadyTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.CommonEncryptionProtected. IAsset playreadyAsset = playreadyTask.OutputAssets.AddNew( "PlayReady Smooth Streaming", AssetCreationOptions.CommonEncryptionProtected); return(playreadyAsset); }
/// <summary> /// Creates a task to convert the MP4 file(s) to a Smooth Streaming asset. /// Adds the new task to a job. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset PackageMP4ToSmoothStreamingTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Azure Media Packager. IMediaProcessor packager = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaPackager); // Azure Media Packager does not accept string presets, so load xml configuration string smoothConfig = File.ReadAllText(Path.Combine( _configurationXMLFiles, "MediaPackager_MP4toSmooth.xml")); // Create a new Task to convert adaptive bitrate to Smooth Streaming. ITask smoothStreamingTask = job.Tasks.AddNew("MP4 to Smooth Task", packager, smoothConfig, TaskOptions.None); // Specify the input Asset, which is the output Asset from the first task smoothStreamingTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). IAsset smoothOutputAsset = smoothStreamingTask.OutputAssets.AddNew("Clear Smooth Stream", AssetCreationOptions.None); return(smoothOutputAsset); }
public void ShouldSaveJobAsTemplateAndCreateNewJobwithItWhereOutPutInNoneDefaultStorage() { var nondefault = _mediaContext.StorageAccounts.Where(c => c.IsDefault == false).FirstOrDefault(); //This test need to be executed when media account multiple storage account associated with it. if (nondefault == null) { return; } IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); string name = GenerateName("Job 1"); IJob job = _mediaContext.Jobs.Create(name); ITask task = job.Tasks.AddNew("Task1", mediaProcessor, GetWamePreset(mediaProcessor), TaskOptions.None); task.InputAssets.Add(asset); var outputAsset = task.OutputAssets.AddNew("Output asset", nondefault.Name, AssetCreationOptions.None); job.Submit(); var template = job.SaveAsTemplate("JobTests.StorageAccounts.cs_" + Guid.NewGuid().ToString()); string newJobName = GenerateName("Job from template with non default storage account"); var newJob = _mediaContext.Jobs.Create(newJobName, template, new[] { asset }); newJob.Submit(); WaitForJob(newJob.Id, JobState.Finished, VerifyAllTasksFinished); newJob = _mediaContext.Jobs.Where(c => c.Id == newJob.Id).FirstOrDefault(); Assert.AreEqual(nondefault.Name, newJob.Tasks[0].OutputAssets[0].StorageAccountName, "Storage account name in output assset is not matching"); }
static private IJob CreateEncodingJob(IAsset asset) { // Declare a new job IJob job = mediaContext.Jobs.Create("Encode to SD MP4"); // Encoding profile string profile = "H264 Multiple Bitrate 16x9 SD"; Console.WriteLine($"Encoding Profile: {profile}"); // Get a media processor reference, and pass to it the name of the // processor to use for the specific task. IMediaProcessor processor = mediaContext.MediaProcessors. Where(p => p.Name == "Media Encoder Standard").ToList(). OrderBy(p => new Version(p.Version)).LastOrDefault(); // Add task to job ITask task = job.Tasks.AddNew("Encode to SD MP4 task", processor, profile, TaskOptions.None); task.InputAssets.Add(asset); task.OutputAssets.AddNew("Bitten by the Frost SD", AssetCreationOptions.None); // Hook an event handler for job state changes // job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChangedHandler); job.Submit(); //job.GetExecutionProgressTask(new CancellationToken()).Wait(); Console.WriteLine("Encoding job submitted."); return(job); }
public BlogService( IProjectService projectService, IProjectSecurityResolver security, IPostQueries postQueries, IPostCommands postCommands, IMediaProcessor mediaProcessor, IHtmlProcessor htmlProcessor, IBlogRoutes blogRoutes, PostEvents eventHandlers, IUrlHelperFactory urlHelperFactory, IActionContextAccessor actionContextAccesor, IHttpContextAccessor contextAccessor = null) { this.security = security; this.postQueries = postQueries; this.postCommands = postCommands; context = contextAccessor?.HttpContext; this.mediaProcessor = mediaProcessor; this.urlHelperFactory = urlHelperFactory; this.actionContextAccesor = actionContextAccesor; this.projectService = projectService; this.htmlProcessor = htmlProcessor; this.blogRoutes = blogRoutes; this.eventHandlers = eventHandlers; }
private IAsset CreateEncodingJob(IAsset workflow, IAsset video) { IEncoderSupport myEncodigSupport = new EncoderSupport(_MediaServicesContext); // Declare a new job. currentJob = _MediaServicesContext.Jobs.Create(myConfig.EncodingJobName); // Get a media processor reference, and pass to it the name of the // processor to use for the specific task. IMediaProcessor processor = myEncodigSupport.GetLatestMediaProcessorByName("Media Encoder Premium Workflow"); // Create a task with the encoding details, using a string preset. ITask task = currentJob.Tasks.AddNew(myConfig.EncodigTaskName, processor, "", TaskOptions.None); // Specify the input asset to be encoded. task.InputAssets.Add(workflow); task.InputAssets.Add(video); // we add one asset // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is not encrypted. task.OutputAssets.AddNew(video.Name + "_mb", AssetCreationOptions.None); // Use the following event handler to check job progress. // The StateChange method is the same as the one in the previous sample currentJob.StateChanged += new EventHandler <JobStateChangedEventArgs>(myEncodigSupport.StateChanged); // Launch the job. currentJob.Submit(); //9. Revisa el estado de ejecución del JOB Task progressJobTask = currentJob.GetExecutionProgressTask(CancellationToken.None); //10. en vez de utilizar progressJobTask.Wait(); que solo muestra cuando el JOB termina //se utiliza el siguiente codigo para mostrar avance en porcentaje, como en el portal myEncodigSupport.WaitJobFinish(currentJob.Id); return(currentJob.OutputMediaAssets.FirstOrDefault()); }
public void CreateThumbnails(Models.Asset asset) { // Declare a new job. IJob job = this.MediaService.MediaContext.Jobs.Create(asset.MediaAsset.Name + " Thumbnails"); // Get a media processor reference, and pass to it the name of the // processor to use for the specific task. Use a method like the // GetMediaProcessor method shown in this document. IMediaProcessor processor = this.MediaService .GetMediaProcessorByName(MediaEncoders.WINDOWS_AZURE_MEDIA_ENCODER); ITask task3 = job.Tasks.AddNew("Thumnail creator", processor, @"<?xml version=""1.0"" encoding=""utf-16""?> <Thumbnail Size=""150,150"" Type=""Jpeg"" Filename=""{OriginalFilename}_{ThumbnailTime}.{DefaultExtension}""> <Time Value=""0:0:4"" Step=""0:0:1"" Stop=""0:0:5""/> </Thumbnail>", TaskOptions.None); task3.InputAssets.Add(asset.MediaAsset); IAsset thumbprintAssets = task3.OutputAssets .AddNew(asset.MediaAsset.Name + " Thumbpnails", AssetCreationOptions.None); job.Submit(); }
public void CreateNewJob(Models.Asset asset, string mediaEncoder, string taskPreset) { // Declare a new job. IJob job = this.MediaService.MediaContext.Jobs.Create(asset.MediaAsset.Name + " Job"); // Get a media processor reference, and pass to it the name of the // processor to use for the specific task. Use a method like the // GetMediaProcessor method shown in this document. IMediaProcessor processor = this.MediaService .GetMediaProcessorByName(mediaEncoder); // Create a task with the encoding details, using a string preset. ITask task = job.Tasks.AddNew("Ad-hoc Task", processor, taskPreset, TaskOptions.None); // Specify the input asset to be encoded. task.InputAssets.Add(asset.MediaAsset); //Add an output asset to contain the results of the job. //This output is specified as AssetCreationOptions.None, which //means the output asset is in the clear (unencrypted). IAsset outputAsset = task.OutputAssets.AddNew(asset.MediaAsset.Name + " result ", AssetCreationOptions.None); job.Submit(); }
public void DecryptAsset(Models.Asset theAsset) { // Declare a new job. IJob job = this.MediaService.MediaContext.Jobs.Create(theAsset.MediaAsset.Name + " Decrypting Job"); // Get a media processor reference, and pass to it the name of the // processor to use for the specific task. Use a method like the // GetMediaProcessor method shown in this document. IMediaProcessor processor = this.MediaService .GetMediaProcessorByName(MediaEncoders.STORAGE_DECRYPTION_ENCODER); // Create a task with the encoding details, using a string preset. ITask task = job.Tasks.AddNew("New Decrypting", processor, string.Empty, TaskOptions.None); // Specify the input asset to be encoded. task.InputAssets.Add(theAsset.MediaAsset); //Add an output asset to contain the results of the job. //This output is specified as AssetCreationOptions.None, which //means the output asset is in the clear (unencrypted). IAsset decruptedAsset = task.OutputAssets .AddNew(theAsset.MediaAsset.Name + " decrypted", AssetCreationOptions.None); // Launch the job. job.Submit(); }
public PageService( IProjectService projectService, IProjectSecurityResolver security, IPageQueries pageQueries, IPageCommands pageCommands, PageEvents eventHandlers, IMediaProcessor mediaProcessor, IContentProcessor contentProcessor, //IHtmlProcessor htmlProcessor, IUrlHelperFactory urlHelperFactory, IPageRoutes pageRoutes, IMemoryCache cache, IStringLocalizer <cloudscribe.SimpleContent.Web.SimpleContent> localizer, IPageNavigationCacheKeys cacheKeys, IActionContextAccessor actionContextAccesor, IHttpContextAccessor contextAccessor = null) { this.projectService = projectService; this.security = security; this.pageQueries = pageQueries; this.pageCommands = pageCommands; context = contextAccessor?.HttpContext; this.mediaProcessor = mediaProcessor; this.urlHelperFactory = urlHelperFactory; this.actionContextAccesor = actionContextAccesor; this.pageRoutes = pageRoutes; _contentProcessor = contentProcessor; //this.htmlProcessor = htmlProcessor; this.cache = cache; this.cacheKeys = cacheKeys; this.eventHandlers = eventHandlers; sr = localizer; }
public RedditMessageHandlerTests() { _fakeRedditClientWrapper = A.Fake <IRedditClientWrapper>(); SetupCommentRootPostStubs(); _fakeMediaProcessor = A.Fake <IMediaProcessor>(); _fakeReplyBuilder = A.Fake <IReplyBuilder>(); _redditMessageHandler = new RedditMessageHandler(_fakeRedditClientWrapper, _fakeMediaProcessor, _fakeReplyBuilder); }
public IJob CreateJob(MediaJob mediaJob, MediaJobInput[] jobInputs, out IJobTemplate jobTemplate) { IJob job = null; jobTemplate = null; if (!string.IsNullOrEmpty(mediaJob.TemplateId)) { List <IAsset> inputAssets = new List <IAsset>(); foreach (MediaJobInput jobInput in jobInputs) { IAsset asset = GetEntityById(MediaEntity.Asset, jobInput.AssetId) as IAsset; if (asset != null) { inputAssets.Add(asset); } } jobTemplate = GetEntityById(MediaEntity.JobTemplate, mediaJob.TemplateId) as IJobTemplate; job = _media.Jobs.Create(mediaJob.Name, jobTemplate, inputAssets, mediaJob.Priority); } else if (mediaJob.Tasks.Length > 0) { job = _media.Jobs.Create(mediaJob.Name, mediaJob.Priority); foreach (MediaJobTask jobTask in mediaJob.Tasks) { string processorId = Processor.GetProcessorId(jobTask.MediaProcessor, jobTask.ProcessorConfig); IMediaProcessor processor = GetEntityById(MediaEntity.Processor, processorId) as IMediaProcessor; ITask currentTask = job.Tasks.AddNew(jobTask.Name, processor, jobTask.ProcessorConfig, jobTask.Options); if (jobTask.ParentIndex.HasValue) { ITask parentTask = job.Tasks[jobTask.ParentIndex.Value]; currentTask.InputAssets.AddRange(parentTask.OutputAssets); } else { IAsset[] assets = GetAssets(jobTask.InputAssetIds); currentTask.InputAssets.AddRange(assets); } currentTask.OutputAssets.AddNew(jobTask.OutputAssetName, jobTask.OutputAssetEncryption, jobTask.OutputAssetFormat); } INotificationEndPoint notificationEndpoint = GetNotificationEndpoint(); job.JobNotificationSubscriptions.AddNew(NotificationJobState.FinalStatesOnly, notificationEndpoint); } if (job != null) { if (mediaJob.SaveWorkflow) { string templateName = mediaJob.Name; jobTemplate = job.SaveAsTemplate(templateName); } else { SetProcessorUnits(job, jobTemplate, mediaJob.NodeType, true); job.Submit(); } } return(job); }
public MediaAnalyticsGeneric(CloudMediaContext context, IMediaProcessor processor, Image processorImage, bool preview) { InitializeComponent(); this.Icon = Bitmaps.Azure_Explorer_ico; _context = context; _processor = processor; _preview = preview; _processorImage = processorImage; buttonJobOptions.Initialize(_context); }
// media processor versions public static string GetWamePreset(IMediaProcessor mediaProcessor) { var mpVersion = new Version(mediaProcessor.Version); if (mpVersion.Major == 1) { return WameV1Preset; } else { return WameV2Preset; } }
public IAsset GenerateThumbnail(IJob job, IAsset asset, IMediaProcessor processor, int width, int height) { var task = job.Tasks.AddNew("Thumnail creator", processor, string.Format(@"<?xml version=""1.0"" encoding=""utf-16""?> <Thumbnail Size=""{0},{1}"" Type=""Jpeg"" Filename=""{{OriginalFilename}}_{{ThumbnailTime}}.{{DefaultExtension}}""> <Time Value=""0:0:5""/> <Time Value=""0:0:4"" Step=""0:0:1"" Stop=""0:0:5""/> </Thumbnail>", width, height), TaskOptions.None); task.InputAssets.Add(asset); var thumbprintAsset = task.OutputAssets.AddNew(string.Format("{0} thumbnail", asset.Name), AssetCreationOptions.None); return thumbprintAsset; }
public static IJob CreateAndSubmitOneTaskJob(CloudMediaContext context, string name, IMediaProcessor mediaProcessor, string preset, IAsset asset, TaskOptions options) { IJob job = context.Jobs.Create(name); job.Priority = InitialJobPriority; ITask task = job.Tasks.AddNew("Task1", mediaProcessor, preset, options); task.InputAssets.Add(asset); task.OutputAssets.AddNew("Output asset", AssetCreationOptions.None); DateTime timebeforeSubmit = DateTime.UtcNow; job.Submit(); Assert.AreEqual(1, job.Tasks.Count, "Job contains unexpected amount of tasks"); Assert.AreEqual(1, job.InputMediaAssets.Count, "Job contains unexpected total amount of input assets"); Assert.AreEqual(1, job.OutputMediaAssets.Count, "Job contains unexpected total amount of output assets"); Assert.AreEqual(1, job.Tasks[0].InputAssets.Count, "job.Task[0] contains unexpected amount of input assets"); Assert.AreEqual(1, job.Tasks[0].OutputAssets.Count, "job.Task[0] contains unexpected amount of output assets"); Assert.IsFalse(String.IsNullOrEmpty(job.Tasks[0].InputAssets[0].Id), "Asset Id is Null or empty"); Assert.IsFalse(String.IsNullOrEmpty(job.Tasks[0].OutputAssets[0].Id), "Asset Id is Null or empty"); return job; }
public void LaunchJobs(IMediaProcessor processor, List<IAsset> selectedassets, string jobname, int jobpriority, string taskname, string outputassetname, List<string> configuration, AssetCreationOptions myAssetCreationOptions, TaskOptions myTaskOptions, string storageaccountname = "") { foreach (IAsset asset in selectedassets) { string jobnameloc = jobname.Replace(Constants.NameconvInputasset, asset.Name); IJob myJob = _context.Jobs.Create(jobnameloc, jobpriority); foreach (string config in configuration) { string tasknameloc = taskname.Replace(Constants.NameconvInputasset, asset.Name).Replace(Constants.NameconvAMEpreset, config); ITask myTask = myJob.Tasks.AddNew( tasknameloc, processor, config, myTaskOptions); myTask.InputAssets.Add(asset); // Add an output asset to contain the results of the task string outputassetnameloc = outputassetname.Replace(Constants.NameconvInputasset, asset.Name).Replace(Constants.NameconvAMEpreset, config); if (storageaccountname == "") { myTask.OutputAssets.AddNew(outputassetnameloc, asset.StorageAccountName, myAssetCreationOptions); // let's use the same storage account than the input asset } else { myTask.OutputAssets.AddNew(outputassetnameloc, storageaccountname, myAssetCreationOptions); } } // Submit the job and wait until it is completed. try { myJob.Submit(); } catch (Exception e) { // Add useful information to the exception if (selectedassets.Count < 5) // only if 4 or less jobs submitted { MessageBox.Show(string.Format("There has been a problem when submitting the job '{0}'", jobnameloc) + Constants.endline + Constants.endline + Program.GetErrorMessage(e), "Job Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } // Add useful information to the exception TextBoxLogWriteLine("There has been a problem when submitting the job {0}.", jobnameloc, true); TextBoxLogWriteLine(e); return; } TextBoxLogWriteLine("Job '{0}' submitted.", jobnameloc); Task.Factory.StartNew(() => dataGridViewJobsV.DoJobProgress(myJob)); } DotabControlMainSwitch(Constants.TabJobs); DoRefreshGridJobV(false); }
public void LaunchJobs_OneJobPerInputAssetWithSpecificConfig(IMediaProcessor processor, List<IAsset> selectedassets, string jobname, int jobpriority, string taskname, string outputassetname, List<string> configuration, AssetCreationOptions myAssetCreationOptions, TaskOptions myTaskOptions, string storageaccountname = "") { // a job per asset, one task per job, but each task has a specific config Task.Factory.StartNew(() => { int index = -1; foreach (IAsset asset in selectedassets) { index++; string jobnameloc = jobname.Replace(Constants.NameconvInputasset, asset.Name); IJob myJob = _context.Jobs.Create(jobnameloc, jobpriority); string config = configuration[index]; string tasknameloc = taskname.Replace(Constants.NameconvInputasset, asset.Name).Replace(Constants.NameconvAMEpreset, config); ITask myTask = myJob.Tasks.AddNew( tasknameloc, processor, config, myTaskOptions); myTask.InputAssets.Add(asset); // Add an output asset to contain the results of the task string outputassetnameloc = outputassetname.Replace(Constants.NameconvInputasset, asset.Name).Replace(Constants.NameconvAMEpreset, config); if (storageaccountname == "") { myTask.OutputAssets.AddNew(outputassetnameloc, asset.StorageAccountName, myAssetCreationOptions); // let's use the same storage account than the input asset } else { myTask.OutputAssets.AddNew(outputassetnameloc, storageaccountname, myAssetCreationOptions); } // Submit the job and wait until it is completed. bool Error = false; try { TextBoxLogWriteLine("Job '{0}' : submitting...", jobnameloc); myJob.Submit(); } catch (Exception ex) { // Add useful information to the exception TextBoxLogWriteLine("Job '{0}' : problem", jobnameloc, true); TextBoxLogWriteLine(ex); Error = true; } if (!Error) { TextBoxLogWriteLine("Job '{0}' : submitted.", jobnameloc); Task.Factory.StartNew(() => dataGridViewJobsV.DoJobProgress(myJob)); } TextBoxLogWriteLine(); } DotabControlMainSwitch(Constants.TabJobs); DoRefreshGridJobV(false); } ); }