private TransformOutput GetTransformOutput(MediaTransformOutput transformOutput, Image thumbnailCodec)
{
Preset transformPreset = null;
switch (transformOutput.PresetType)
{
case MediaTransformPreset.AdaptiveStreaming:
EncoderNamedPreset presetName = EncoderNamedPreset.AdaptiveStreaming;
if (!string.IsNullOrEmpty(transformOutput.PresetName))
{
presetName = transformOutput.PresetName;
}
transformPreset = new BuiltInStandardEncoderPreset(presetName);
break;
case MediaTransformPreset.ContentAwareEncoding:
transformPreset = new BuiltInStandardEncoderPreset(EncoderNamedPreset.ContentAwareEncodingExperimental);
break;
case MediaTransformPreset.ThumbnailImages:
case MediaTransformPreset.ThumbnailSprite:
transformPreset = GetThumbnailGeneration(thumbnailCodec);
break;
case MediaTransformPreset.VideoAnalyzer:
transformPreset = new VideoAnalyzerPreset()
{
InsightsToExtract = InsightsType.VideoInsightsOnly
};
break;
case MediaTransformPreset.AudioAnalyzer:
transformPreset = new AudioAnalyzerPreset();
break;
case MediaTransformPreset.FaceDetector:
transformPreset = new FaceDetectorPreset();
break;
}
if (transformPreset == null)
{
return(null);
}
else
{
return(new TransformOutput(transformPreset)
{
RelativePriority = transformOutput.RelativePriority,
OnError = transformOutput.OnError
});
}
}
/// <inheritdoc cref="MediaServicesV3TransformBase"/>
protected override void Create()
{
_ = $"The {Name} Preset.";
// Create new transform
Preset preset = new BuiltInStandardEncoderPreset()
{
PresetName = Name
};
Output = new MediaServicesV3TransformOutput(new TransformOutput[] { new TransformOutput(preset) },
Description);
}
public Transform CreateTransform(string transformName, string transformDescription, MediaTransformOutput[] transformOutputs, int?thumbnailSpriteColumns)
{
Transform transform = null;
bool defaultName = string.IsNullOrEmpty(transformName);
List <TransformOutput> transformOutputPresets = new List <TransformOutput>();
foreach (MediaTransformOutput transformOutput in transformOutputs)
{
TransformOutput transformOutputPreset;
switch (transformOutput.TransformPreset)
{
case MediaTransformPreset.AdaptiveStreaming:
transformName = GetTransformName(defaultName, transformName, transformOutput);
BuiltInStandardEncoderPreset standardEncoderPreset = new BuiltInStandardEncoderPreset(EncoderNamedPreset.AdaptiveStreaming);
transformOutputPreset = GetTransformOutput(standardEncoderPreset, transformOutput);
transformOutputPresets.Add(transformOutputPreset);
break;
case MediaTransformPreset.ThumbnailImages:
transformName = GetTransformName(defaultName, transformName, transformOutput);
StandardEncoderPreset thumbnailPreset = GetThumbnailPreset(thumbnailSpriteColumns);
transformOutputPreset = GetTransformOutput(thumbnailPreset, transformOutput);
transformOutputPresets.Add(transformOutputPreset);
break;
case MediaTransformPreset.VideoAnalyzer:
transformName = GetTransformName(defaultName, transformName, transformOutput);
VideoAnalyzerPreset videoAnalyzerPreset = (VideoAnalyzerPreset)GetAnalyzerPreset(false);
transformOutputPreset = GetTransformOutput(videoAnalyzerPreset, transformOutput);
transformOutputPresets.Add(transformOutputPreset);
break;
case MediaTransformPreset.AudioAnalyzer:
transformName = GetTransformName(defaultName, transformName, transformOutput);
AudioAnalyzerPreset audioAnalyzerPreset = (AudioAnalyzerPreset)GetAnalyzerPreset(true);
transformOutputPreset = GetTransformOutput(audioAnalyzerPreset, transformOutput);
transformOutputPresets.Add(transformOutputPreset);
break;
}
}
if (transformOutputPresets.Count > 0)
{
transform = _media.Transforms.CreateOrUpdate(MediaAccount.ResourceGroupName, MediaAccount.Name, transformName, transformOutputPresets.ToArray(), transformDescription);
}
return(transform);
}
private void ListBoxOutputs_SelectedIndexChanged(object sender, EventArgs e)
{
TransformOutput output = _transform.Outputs.Skip(listBoxOutputs.SelectedIndex).Take(1).FirstOrDefault();
DGOutputs.Rows.Clear();
DGOutputs.Rows.Add("Preset type", output.Preset.GetType().ToString());
string presetJson;
if (output.Preset.GetType() == typeof(BuiltInStandardEncoderPreset))
{
BuiltInStandardEncoderPreset pmes = (BuiltInStandardEncoderPreset)output.Preset;
presetJson = JsonConvert.SerializeObject(pmes, Newtonsoft.Json.Formatting.Indented);
}
else if (output.Preset.GetType() == typeof(AudioAnalyzerPreset))
{
AudioAnalyzerPreset pmes = (AudioAnalyzerPreset)output.Preset;
presetJson = JsonConvert.SerializeObject(pmes, Newtonsoft.Json.Formatting.Indented);
}
else if (output.Preset.GetType() == typeof(StandardEncoderPreset))
{
StandardEncoderPreset pmes = (StandardEncoderPreset)output.Preset;
presetJson = JsonConvert.SerializeObject(pmes, Newtonsoft.Json.Formatting.Indented);
}
else if (output.Preset.GetType() == typeof(VideoAnalyzerPreset))
{
VideoAnalyzerPreset pmes = (VideoAnalyzerPreset)output.Preset;
presetJson = JsonConvert.SerializeObject(pmes, Newtonsoft.Json.Formatting.Indented);
}
else if (output.Preset.GetType() == typeof(FaceDetectorPreset))
{
FaceDetectorPreset pmes = (FaceDetectorPreset)output.Preset;
presetJson = JsonConvert.SerializeObject(pmes, Newtonsoft.Json.Formatting.Indented);
}
else
{
presetJson = JsonConvert.SerializeObject(output.Preset, Newtonsoft.Json.Formatting.Indented);
}
textBoxPresetJson.Text = presetJson;
DGOutputs.Rows.Add("Relative Priority", output.RelativePriority);
}
internal static void ValidateTransform(Transform transform, string expectedTransformName, string expectedTransformDescription, TransformOutput[] expectedOutputs)
{
Assert.Equal(expectedTransformDescription, transform.Description);
Assert.Equal(expectedTransformName, transform.Name);
Assert.Equal(expectedOutputs.Length, transform.Outputs.Count);
for (int i = 0; i < expectedOutputs.Length; i++)
{
Type expectedType = expectedOutputs[i].Preset.GetType();
Assert.Equal(expectedType, transform.Outputs[i].Preset.GetType());
if (typeof(BuiltInStandardEncoderPreset) == expectedType)
{
BuiltInStandardEncoderPreset expected = (BuiltInStandardEncoderPreset)expectedOutputs[i].Preset;
BuiltInStandardEncoderPreset actual = (BuiltInStandardEncoderPreset)transform.Outputs[i].Preset;
Assert.Equal(expected.PresetName, actual.PresetName);
}
else if (typeof(VideoAnalyzerPreset) == expectedType)
{
VideoAnalyzerPreset expected = (VideoAnalyzerPreset)expectedOutputs[i].Preset;
VideoAnalyzerPreset actual = (VideoAnalyzerPreset)transform.Outputs[i].Preset;
Assert.Equal(expected.InsightsToExtract, actual.InsightsToExtract);
Assert.Equal(expected.AudioLanguage, actual.AudioLanguage);
}
else if (typeof(AudioAnalyzerPreset) == expectedType)
{
AudioAnalyzerPreset expected = (AudioAnalyzerPreset)expectedOutputs[i].Preset;
AudioAnalyzerPreset actual = (AudioAnalyzerPreset)transform.Outputs[i].Preset;
Assert.Equal(expected.AudioLanguage, actual.AudioLanguage);
}
else
{
throw new InvalidOperationException($"Unexpected type {expectedType.Name}");
}
}
}
private void listBoxOutputs_SelectedIndexChanged(object sender, EventArgs e)
{
TransformOutput output = _transform.Outputs.Skip(listBoxOutputs.SelectedIndex).Take(1).FirstOrDefault();
DGOutputs.Rows.Clear();
DGOutputs.Rows.Add("Preset type", output.Preset.GetType().ToString());
if (output.Preset.GetType() == typeof(BuiltInStandardEncoderPreset))
{
BuiltInStandardEncoderPreset pmes = (BuiltInStandardEncoderPreset)output.Preset;
DGOutputs.Rows.Add("Preset name", pmes.PresetName);
}
else if (output.Preset.GetType() == typeof(AudioAnalyzerPreset))
{
AudioAnalyzerPreset pmes = (AudioAnalyzerPreset)output.Preset;
DGOutputs.Rows.Add("Audio language", pmes.AudioLanguage);
}
else if (output.Preset.GetType() == typeof(StandardEncoderPreset))
{
StandardEncoderPreset pmes = (StandardEncoderPreset)output.Preset;
// DGOutputs.Rows.Add("Audio language", pmes.);
}
else if (output.Preset.GetType() == typeof(VideoAnalyzerPreset))
{
VideoAnalyzerPreset pmes = (VideoAnalyzerPreset)output.Preset;
DGOutputs.Rows.Add("Audio language", pmes.AudioLanguage);
DGOutputs.Rows.Add("Insights To Extract", pmes.InsightsToExtract);
}
else if (output.Preset.GetType() == typeof(FaceDetectorPreset))
{
FaceDetectorPreset pmes = (FaceDetectorPreset)output.Preset;
DGOutputs.Rows.Add("Resolution", pmes.Resolution.HasValue ? pmes.Resolution.Value.ToString() : string.Empty);
}
DGOutputs.Rows.Add("Relative Priority", output.RelativePriority);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation($"AMS v3 Function - CreateTransform was triggered!");
string requestBody = new StreamReader(req.Body).ReadToEnd();
dynamic data = JsonConvert.DeserializeObject(requestBody);
if (data.transformName == null)
{
return(new BadRequestObjectResult("Please pass transformName in the input object"));
}
string transformName = data.transformName;
if (data.mode == null)
{
return(new BadRequestObjectResult("Please pass mode in the input object"));
}
string description = null;
if (data.description != null)
{
description = data.description;
}
string mode = data.mode;
if (mode != "simple" && mode != "advanced")
{
return(new BadRequestObjectResult("Please pass valid mode in the input object"));
}
//
// Simple Mode
//
if (mode == "simple" && data.preset == null)
{
return(new BadRequestObjectResult("Please pass preset in the input object"));
}
string presetName = data.preset;
if (presetName == "CustomPreset" && data.customPresetJson == null)
{
return(new BadRequestObjectResult("Please pass customPresetJson in the input object"));
}
//
// Advanced Mode
//
if (mode == "advanced" && data.transformOutputs == null)
{
return(new BadRequestObjectResult("Please pass transformOutputs in the input object"));
}
MediaServicesConfigWrapper amsconfig = new MediaServicesConfigWrapper();
string transformId = null;
JsonConverter[] jsonReaders =
{
new MediaServicesHelperJsonReader(),
new MediaServicesHelperTimeSpanJsonConverter()
};
try
{
IAzureMediaServicesClient client = MediaServicesHelper.CreateMediaServicesClientAsync(amsconfig);
// Does a Transform already exist with the desired name?
// Assume that an existing Transform with the desired name
// also uses the same recipe or Preset for processing content.
Transform transform = client.Transforms.Get(amsconfig.ResourceGroup, amsconfig.AccountName, transformName);
if (transform == null)
{
TransformOutput[] outputs = null;
List <TransformOutput> transformOutputs = new List <TransformOutput>();
if (mode == "simple")
{
Preset preset = null;
string audioLanguage = null;
if (data.audioLanguage != null)
{
audioLanguage = data.audioLanguage;
}
if (presetName == "VideoAnalyzer")
{
bool insightEnabled = false;
if (data.insightsToExtract != null && InsightTypeList.ContainsKey(data.insightsToExtract))
{
insightEnabled = true;
}
preset = new VideoAnalyzerPreset(audioLanguage, insightEnabled ? InsightTypeList[data.insightsToExtract] : null);
}
else if (presetName == "AudioAnalyzer")
{
preset = new AudioAnalyzerPreset(audioLanguage);
}
else if (presetName == "CustomPreset")
{
preset = JsonConvert.DeserializeObject <StandardEncoderPreset>(data.customPresetJson.ToString(), jsonReaders);
}
else
{
if (!EncoderNamedPresetList.ContainsKey(presetName))
{
return(new BadRequestObjectResult("Preset not found"));
}
preset = new BuiltInStandardEncoderPreset(EncoderNamedPresetList[presetName]);
}
OnErrorType onError = OnErrorType.StopProcessingJob;
string temp = data.onError;
if (!string.IsNullOrEmpty(temp) && OnErrorTypeList.ContainsKey(temp))
{
onError = OnErrorTypeList[temp];
}
Priority relativePriority = Priority.Normal;
temp = data.relativePriority;
if (!string.IsNullOrEmpty(temp) && PriorityList.ContainsKey(temp))
{
relativePriority = PriorityList[temp];
}
transformOutputs.Add(new TransformOutput(preset, onError, relativePriority));
outputs = transformOutputs.ToArray();
}
else if (mode == "advanced")
{
List <TransformOutput> transformOutputList = JsonConvert.DeserializeObject <List <TransformOutput> >(data.transformOutputs.ToString(), jsonReaders);
outputs = transformOutputList.ToArray();
}
else
{
return(new BadRequestObjectResult("Invalid mode found"));
}
// Create Transform
transform = client.Transforms.CreateOrUpdate(amsconfig.ResourceGroup, amsconfig.AccountName, transformName, outputs);
}
transformId = transform.Id;
}
catch (ApiErrorException e)
{
log.LogError($"ERROR: AMS API call failed with error code: {e.Body.Error.Code} and message: {e.Body.Error.Message}");
return(new BadRequestObjectResult("AMS API call error: " + e.Message + "\nError Code: " + e.Body.Error.Code + "\nMessage: " + e.Body.Error.Message));
}
catch (Exception e)
{
log.LogError($"ERROR: Exception with message: {e.Message}");
return(new BadRequestObjectResult("Error: " + e.Message));
}
return((ActionResult) new OkObjectResult(new
{
transformName = transformName,
transformId = transformId
}));
}
