Process Assets with the Media Services SDK for .NET

private static IMediaProcessor GetLatestMediaProcessorByName(string mediaProcessorName)
{
    // The possible strings that can be passed into the 
    // method for the mediaProcessor parameter:
    //   Windows Azure Media Encoder
    //   Windows Azure Media Packager
    //   Windows Azure Media Encryptor
    //   Storage Decryption

    var processor = _context.MediaProcessors.Where(p => p.Name == mediaProcessorName).
        ToList().OrderBy(p => new Version(p.Version)).LastOrDefault();

    if (processor == null)
        throw new ArgumentException(string.Format("Unknown media processor", mediaProcessorName));

    return processor;
}

IMediaProcessor processor = GetLatestMediaProcessorByName("Windows Azure Media Encoder");

public static IJob CreateEncodingJob( string inputMediaFilePath, string outputFolder)
{
    //Create an encrypted asset and upload to storage. 
    IAsset asset = CreateAssetAndUploadSingleFile(AssetCreationOptions.StorageEncrypted, inputMediaFilePath);

    // Declare a new job.
    IJob job = _context.Jobs.Create("My encoding job");
    // Get a media processor reference, and pass to it the name of the 
    // processor to use for the specific task.
    IMediaProcessor processor = GetLatestMediaProcessorByName("Windows Azure Media Encoder");

    // Create a task with the encoding details, using a string preset.
    ITask task = job.Tasks.AddNew("My encoding task",
        processor,
        "H264 Broadband 720p",
        _protectedConfig);

    // 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 in the clear (unencrypted). 
    task.OutputAssets.AddNew("Output asset",
        AssetCreationOptions.None);

    // Use the following event handler to check job progress.  
    job.StateChanged += new
            EventHandler<JobStateChangedEventArgs>(StateChanged);

    // Launch the job.
    job.Submit();

    // Optionally log job details. This displays basic job details
    // to the console and saves them to a JobDetails-{JobId}.txt file 
    // in your output folder.
    LogJobDetails(job.Id);

    // Check job execution and wait for job to finish. 
    Task progressJobTask = job.GetExecutionProgressTask(CancellationToken.None);
    progressJobTask.Wait();

     // Get an updated job reference after waiting for a job on 
     // a thread.
     job = GetJob(job.Id);

    return job;
}

private static void LogJobDetails(string jobId)
{
   StringBuilder builder = new StringBuilder();
   IJob job = GetJob(jobId);

   builder.AppendLine("\nJob ID: " + job.Id);
   builder.AppendLine("Job Name: " + job.Name);
   builder.AppendLine("Job submitted (client UTC time): " + DateTime.UtcNow.ToString());
   builder.AppendLine("Media Services account name: " + _accountName);

   // Write the output to a local file and to the console. The template 
   // for an error output file is:  JobDetails-{JobId}.txt
   string outputFile = Path.Combine(_outputFilesFolder, @"JobDetails-" + JobIdAsFileName(job.Id) + ".txt");
   WriteToFile(outputFile, builder.ToString());
   Console.Write(builder.ToString());
}

public static IJob CreateChainedTaskEncodingJob( string inputMediaFilePath, string outputFolder)
{
    //Create an encrypted asset and upload to storage. 
    IAsset asset = CreateAssetAndUploadSingleFile(AssetCreationOptions.StorageEncrypted, inputMediaFilePath);

    // Declare a new job.
    IJob job = _context.Jobs.Create("My task-chained encoding job");

    // Set up the first task to encode the input file.

    // Get a media processor reference


    IMediaProcessor processor = GetLatestMediaProcessorByName("Windows Azure Media Encoder");

    // Create a task with the encoding details, using a string preset.
    ITask task = job.Tasks.AddNew("My encoding task",
        processor,
        "H264 Broadband 720p",
        _protectedConfig);

    // Specify the input asset to be encoded.
    task.InputAssets.Add(asset);

    // Specify the storage-encrypted output asset.
    task.OutputAssets.AddNew("My storage-encrypted output asset",
        AssetCreationOptions.StorageEncrypted);

    // Set up the second task to decrypt the encoded output file from 
    // the first task.

    // Get another media processor instance
    IMediaProcessor decryptProcessor = GetLatestMediaProcessorByName("Storage Decryption");

    // Declare the decryption task. 
    ITask decryptTask = job.Tasks.AddNew("My decryption task",
        decryptProcessor,
        string.Empty,
        _clearConfig);

    // Specify the input asset to be decrypted. This is the output 
    // asset from the first task. 
    decryptTask.InputAssets.Add(task.OutputAssets[0]);

    // Specify an output asset to contain the results of the job. 
    // This should have AssetCreationOptions.None. 
    decryptTask.OutputAssets.AddNew("My decrypted output asset",
 AssetCreationOptions.None);

    // Use the following event handler to check job progress. 
    job.StateChanged += new
 EventHandler<JobStateChangedEventArgs>(StateChanged);

    // Launch the job.
    job.Submit();

    // Optionally log job details. 



    LogJobDetails(job.Id);

    // Check job execution and wait for job to finish. 
    Task progressJobTask = job.GetExecutionProgressTask(CancellationToken.None);
    progressJobTask.Wait();

     // Get an updated job reference after waiting for a job on 
     // a thread.
     job = GetJob(job.Id);

     return job;
}

private static IJob ProtectWithPlayReady ( string inputMediaFilePath, string configFilePath)
{
   // Create a storage-encrypted asset and upload the mp4. 
   IAsset asset = CreateAssetAndUploadSingleFile(AssetCreationOptions.StorageEncrypted, inputMediaFilePath);

   // Declare a new job to contain the tasks
   IJob job = _context.Jobs.Create("My PlayReady Protection job");

   // Set up the first task. 

   // Read the task configuration data into a string
   string configMp4ToSmooth = File.ReadAllText(Path.GetFullPath(configFilePath + @"\MediaPackager_MP4ToSmooth.xml"));

   // Get a media processor reference
   IMediaProcessor processor = GetLatestMediaProcessorByName("Windows Azure Media Packager");

   // Create a task with the conversion details, using the configuration data
   ITask task = job.Tasks.AddNew("My Mp4 to Smooth Task",
      processor,
      configMp4ToSmooth,
      _clearConfig);

   // Specify the input asset to be converted.
   task.InputAssets.Add(asset);

   // Add an output asset to contain the results of the job.
   task.OutputAssets.AddNew("Streaming output asset", AssetCreationOptions.None);

   IAsset smoothOutputAsset = task.OutputAssets[0];

   // Set up the second task. 

   // Read the configuration data into a string. 
   string configPlayReady = File.ReadAllText(Path.GetFullPath(configFilePath + @"\MediaEncryptor_PlayReadyProtection.xml"));

   // Get a media processor reference
   IMediaProcessor playreadyProcessor = GetLatestMediaProcessorByName("Windows Azure Media Encryptor");

   // Create a second task. 
   ITask playreadyTask = job.Tasks.AddNew("My PlayReady Task",
      playreadyProcessor,
      configPlayReady,
      _protectedConfig);

   // Add the input asset, which is the smooth streaming output asset from the first task. 
   playreadyTask.InputAssets.Add(smoothOutputAsset);

   // Add an output asset to contain the results of the job.
   playreadyTask.OutputAssets.AddNew("PlayReady protected output asset",
      AssetCreationOptions.None);

   // Use the following event handler to check job progress. 
   job.StateChanged += new EventHandler<JobStateChangedEventArgs>(StateChanged);

   // Launch the job.
   job.Submit();

   // Optionally log job details. 
   LogJobDetails(job.Id);

   // Check job execution and wait for job to finish. 
   Task progressJobTask = job.GetExecutionProgressTask(CancellationToken.None);
      progressJobTask.Wait();

   // Get a refreshed job reference after waiting on a thread.
   job = GetJob(job.Id);

   // Check for errors
   if (job.State == JobState.Error)
   {
      Console.WriteLine("\nExiting method due to job error.");
   }

   return job;
}

public static ITask CreateThumbnail ( string configFilePath, string inputFilePath, string outputFolder)
{
    IAsset asset = CreateAssetAndUploadSingleFile(AssetCreationOptions.StorageEncrypted, inputFilePath);

    // Declare a new job.
    IJob job = _context.Jobs.Create("My Thumbnail job");
    // Get a media processor reference, and pass to it the name of the 
    // processor to use for the specific task.
    IMediaProcessor processor = GetLatestMediaProcessorByName("Windows Azure Media Encoder");


    ITask task = job.Tasks.AddNew("My thumbnail task",
        processor,
        "Thumbnails",
        _protectedConfig);
    // 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 asset",
        AssetCreationOptions.None);

    // Use the following event handler to check job progress.  
    job.StateChanged += new
            EventHandler<JobStateChangedEventArgs>(StateChanged);

    // Launch the job.
    job.Submit();

    // Optionally log job details. This displays basic job details
    // to the console and saves them to a JobDetails-{JobId}.txt file 
    // in your output folder.
    LogJobDetails(job.Id);

    // Check job execution and wait for job to finish. 
    Task progressJobTask = job.GetExecutionProgressTask(CancellationToken.None);
    progressJobTask.Wait();

     // Get an updated job reference after waiting for a job on 
     // a thread.
     job = GetJob(job.Id);

      // If job state is Error, the event handling 
      // method for job progress should log errors.  Here we check 
      // for error state and exit if needed.
      if (job.State == JobState.Error)
      {
         Console.WriteLine("\nExiting method due to job error.");
         return task;
      }
    return task;
}