private async Task <Operation> CreateOperationAsyncInternal(object video, VideoOperationSettings videoOperationSettings)
{
var url = string.Format("{0}/{1}", ServiceHost, videoOperationSettings.MethodName);
var arguments = videoOperationSettings.GetQueryParameters().ToArray();
if (arguments.Length != 0)
{
var queryToAppend = string.Join("&",
arguments.Select(p => WebUtility.UrlEncode(p.Key) + "=" + WebUtility.UrlEncode(p.Value)));
var uriBuilder = new UriBuilder(url);
if (uriBuilder.Query != null && uriBuilder.Query.Length > 1)
{
uriBuilder.Query = uriBuilder.Query.Substring(1) + "&" + queryToAppend;
}
else
{
uriBuilder.Query = queryToAppend;
}
url = uriBuilder.ToString();
}
var response = await SendRequestAsync(HttpMethod.Post, url, video);
Operation operation = new Operation(response.Headers.GetValues(OperationLocation).First());
return(operation);
}
/// <summary>
/// Create video operation.
/// </summary>
/// <param name="videoUrl">Video url.</param>
/// <param name="videoOperationSettings">Settings of operation.</param>
/// <returns>Video operation created.</returns>
public async Task <Operation> CreateOperationAsync(string videoUrl, VideoOperationSettings videoOperationSettings)
{
return(await CreateOperationAsyncInternal(new VideoUrlRequest()
{
Url = videoUrl
}, videoOperationSettings));
}
public virtual Operation CreateOperation(string videoUrl, VideoOperationSettings operationSettings)
{
try
{
var result = Task.Run(async() => await VideoRepository.CreateOperationAsync(videoUrl, operationSettings)).Result;
return(result);
}
catch (Exception ex)
{
Logger.Error("VideoService.CreateOperation failed", this, ex);
}
return(null);
}
/// <summary>
/// Command function to execute a specified video operation
/// </summary>
/// <param name="obj"></param>
private async void ExecuteVideoOperation(object obj)
{
VideoOperationSettings operationSettings = _videoOperations.CreateVideoOperationSettings(SelectedVideoOperation);
using (FileStream originalVideo = new FileStream(_filePath, FileMode.Open, FileAccess.Read))
{
if (operationSettings == null)
{
await _videoOperations.ExecuteVideoEmotionAnalysis(originalVideo);
}
else
{
await _videoOperations.ExecuteVideoOperation(originalVideo, operationSettings);
}
}
VideoSource = new Uri(_filePath);
}
/// <summary>
/// Function to create video operation settings. Emotion operations should not have any settings
/// </summary>
/// <param name="operation">The currently selected API operation</param>
/// <returns>Returns default <see cref="VideoOperationSettings"/> for the currently selected operation</returns>
public VideoOperationSettings CreateVideoOperationSettings(AvailableOperations operation)
{
VideoOperationSettings videoOperationSettings = null;
switch (operation)
{
case AvailableOperations.Emotion:
videoOperationSettings = null;
break;
case AvailableOperations.FaceDetection:
videoOperationSettings = new FaceDetectionOperationSettings();
break;
case AvailableOperations.Stabilization:
videoOperationSettings = new VideoStabilizationOperationSettings();
break;
case AvailableOperations.MotionDetection:
videoOperationSettings = new MotionDetectionOperationSettings()
{
DetectLightChange = true,
FrameSamplingValue = 10,
MergeTimeThreshold = 10,
SensitivityLevel = MotionDetectionOperationSettings.SensitivityLevels.Medium
};
break;
case AvailableOperations.Thumbnail:
videoOperationSettings = new VideoThumbnailOperationSettings()
{
FadeInFadeOut = true,
MaxMotionThumbnailDurationInSecs = 10,
OutputAudio = true,
OutputType = VideoThumbnailOperationSettings.OutputTypes.Video
};
break;
default:
break;
}
return(videoOperationSettings);
}
/// <summary>
/// Execute the selected video operation, when a video is in a given URL
/// Starts a new task to get the operation results
/// </summary>
/// <param name="videoUrl">String containing the video URL</param>
/// <param name="videoOperationSettings"><see cref="VideoOperationSettings"/> for the currently selected operation</param>
/// <returns>No return value</returns>
public async Task ExecuteVideoOperation(string videoUrl, VideoOperationSettings videoOperationSettings)
{
try
{
Operation operation = await _videoServiceClient.CreateOperationAsync(videoUrl, videoOperationSettings);
if (operation == null)
{
RaiseVideoOperationStatus(new VideoOperationStatusEventArgs("Failed", "Failed to create video operation"));
return;
}
await Task.Run(() => GetVideoOperationResultAsync(operation));
}
catch (Exception ex)
{
RaiseVideoOperationStatus(new VideoOperationStatusEventArgs("Failed", $"Failed to execute video operation: {ex.Message}"));
}
}
/// <summary>
/// Create video operation.
/// </summary>
/// <param name="videoUrl">Video url.</param>
/// <param name="videoOperationSettings">Settings of operation.</param>
/// <returns>Video operation created.</returns>
public async Task <Operation> CreateOperationAsync(string videoUrl, VideoOperationSettings videoOperationSettings)
{
return(await CreateOperationAsyncInternal(videoUrl, videoOperationSettings));
}
/// <summary>
/// Create video operation.
/// </summary>
/// <param name="video">Video byte array.</param>
/// <param name="videoOperationSettings">Settings of operation.</param>
/// <returns>Video operation created.</returns>
public async Task <Operation> CreateOperationAsync(byte[] video, VideoOperationSettings videoOperationSettings)
{
return(await CreateOperationAsyncInternal(video, videoOperationSettings));
}
