public async Task ExecuteAsync(WorkerJobHelper <AIJob> jobHelper)
{
S3Locator inputFile;
if (!jobHelper.JobInput.TryGet <S3Locator>(nameof(inputFile), out inputFile))
{
throw new Exception("Invalid or missing input file.");
}
string mediaFileUrl;
if (!string.IsNullOrWhiteSpace(inputFile.HttpEndpoint))
{
mediaFileUrl = inputFile.HttpEndpoint;
}
else
{
var bucketLocation = await inputFile.GetBucketLocationAsync();
var s3SubDomain = !string.IsNullOrWhiteSpace(bucketLocation) ? $"s3-{bucketLocation}" : "s3";
mediaFileUrl = $"https://{s3SubDomain}.amazonaws.com/{inputFile.AwsS3Bucket}/{inputFile.AwsS3Key}";
}
string mediaFormat;
if (mediaFileUrl.EndsWith("mp3", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "mp3";
}
else if (mediaFileUrl.EndsWith("mp4", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "mp4";
}
else if (mediaFileUrl.EndsWith("wav", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "wav";
}
else if (mediaFileUrl.EndsWith("flac", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "flac";
}
else
{
throw new Exception($"Unable to determine media format from input file '{mediaFileUrl}'");
}
var transcribeParameters = new StartTranscriptionJobRequest
{
TranscriptionJobName = "TranscriptionJob-" + jobHelper.JobAssignmentId.Substring(jobHelper.JobAssignmentId.LastIndexOf("/") + 1),
LanguageCode = "en-US",
Media = new Media {
MediaFileUri = mediaFileUrl
},
MediaFormat = mediaFormat,
OutputBucketName = jobHelper.Request.GetRequiredContextVariable("ServiceOutputBucket")
};
using (var transcribeService = new AmazonTranscribeServiceClient())
await transcribeService.StartTranscriptionJobAsync(transcribeParameters);
}
/// <summary>
/// Starts an asynchronous job to transcribe speech to text.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the StartTranscriptionJob service method.</param>
///
/// <returns>The response from the StartTranscriptionJob service method, as returned by TranscribeService.</returns>
/// <exception cref="Amazon.TranscribeService.Model.BadRequestException">
/// There is a problem with one of the input fields. Check the S3 bucket name, make sure
/// that the job name is not a duplicate, and confirm that you are using the correct file
/// format. Then resend your request.
/// </exception>
/// <exception cref="Amazon.TranscribeService.Model.ConflictException">
/// The <code>JobName</code> field is a duplicate of a previously entered job name. Resend
/// your request with a different name.
/// </exception>
/// <exception cref="Amazon.TranscribeService.Model.InternalFailureException">
/// There was an internal error. Check the error message and try your request again.
/// </exception>
/// <exception cref="Amazon.TranscribeService.Model.LimitExceededException">
/// Either you have sent too many requests or your input file is longer than 2 hours.
/// Wait before you resend your request, or use a smaller file and resend the request.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/transcribe-2017-10-26/StartTranscriptionJob">REST API Reference for StartTranscriptionJob Operation</seealso>
public virtual StartTranscriptionJobResponse StartTranscriptionJob(StartTranscriptionJobRequest request)
{
var marshaller = new StartTranscriptionJobRequestMarshaller();
var unmarshaller = StartTranscriptionJobResponseUnmarshaller.Instance;
return(Invoke <StartTranscriptionJobRequest, StartTranscriptionJobResponse>(request, marshaller, unmarshaller));
}
/// <summary>
/// Initiates the asynchronous execution of the StartTranscriptionJob operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the StartTranscriptionJob operation on AmazonTranscribeServiceClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartTranscriptionJob
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/transcribe-2017-10-26/StartTranscriptionJob">REST API Reference for StartTranscriptionJob Operation</seealso>
public virtual IAsyncResult BeginStartTranscriptionJob(StartTranscriptionJobRequest request, AsyncCallback callback, object state)
{
var marshaller = StartTranscriptionJobRequestMarshaller.Instance;
var unmarshaller = StartTranscriptionJobResponseUnmarshaller.Instance;
return(BeginInvoke <StartTranscriptionJobRequest>(request, marshaller, unmarshaller,
callback, state));
}
/// <summary>
/// Starts an asynchronous job to transcribe speech to text.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the StartTranscriptionJob service method.</param>
///
/// <returns>The response from the StartTranscriptionJob service method, as returned by TranscribeService.</returns>
/// <exception cref="Amazon.TranscribeService.Model.BadRequestException">
/// Your request didn't pass one or more validation tests. For example, if the transcription
/// you're trying to delete doesn't exist or if it is in a non-terminal state (for example,
/// it's "in progress"). See the exception <code>Message</code> field for more information.
/// </exception>
/// <exception cref="Amazon.TranscribeService.Model.ConflictException">
/// When you are using the <code>StartTranscriptionJob</code> operation, the <code>JobName</code>
/// field is a duplicate of a previously entered job name. Resend your request with a
/// different name.
///
///
/// <para>
/// When you are using the <code>UpdateVocabulary</code> operation, there are two jobs
/// running at the same time. Resend the second request later.
/// </para>
/// </exception>
/// <exception cref="Amazon.TranscribeService.Model.InternalFailureException">
/// There was an internal error. Check the error message and try your request again.
/// </exception>
/// <exception cref="Amazon.TranscribeService.Model.LimitExceededException">
/// Either you have sent too many requests or your input file is too long. Wait before
/// you resend your request, or use a smaller file and resend the request.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/transcribe-2017-10-26/StartTranscriptionJob">REST API Reference for StartTranscriptionJob Operation</seealso>
public virtual StartTranscriptionJobResponse StartTranscriptionJob(StartTranscriptionJobRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = StartTranscriptionJobRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartTranscriptionJobResponseUnmarshaller.Instance;
return(Invoke <StartTranscriptionJobResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the StartTranscriptionJob operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the StartTranscriptionJob operation on AmazonTranscribeServiceClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartTranscriptionJob
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/transcribe-2017-10-26/StartTranscriptionJob">REST API Reference for StartTranscriptionJob Operation</seealso>
public virtual IAsyncResult BeginStartTranscriptionJob(StartTranscriptionJobRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = StartTranscriptionJobRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartTranscriptionJobResponseUnmarshaller.Instance;
return(BeginInvoke(request, options, callback, state));
}
private async Task ProcessTranscribe(string bucket, string key)
{
Settings settings = new Settings();
settings.ShowSpeakerLabels = true;
settings.MaxSpeakerLabels = 2;
settings.VocabularyName = "Vocab";
Media media = new Media();
media.MediaFileUri = string.Format("https://s3.us-east-2.amazonaws.com/{0}/{1}", bucket, key);
CancellationToken token = new CancellationToken();
StartTranscriptionJobRequest startRequest = new StartTranscriptionJobRequest();
startRequest.LanguageCode = LanguageCode.EnUS;
startRequest.Settings = settings;
startRequest.Media = media;
startRequest.MediaFormat = MediaFormat.Mp3;
startRequest.TranscriptionJobName = Guid.NewGuid().ToString();
StartTranscriptionJobResponse response = await transClient.StartTranscriptionJobAsync(startRequest, token);
GetTranscriptionJobRequest request = new GetTranscriptionJobRequest();
request.TranscriptionJobName = startRequest.TranscriptionJobName;
bool isComplete = false;
while (!isComplete)
{
GetTranscriptionJobResponse response2 = await transClient.GetTranscriptionJobAsync(request);
if (response2.TranscriptionJob.TranscriptionJobStatus == TranscriptionJobStatus.COMPLETED)
{
//we need to DL the file to S3
isComplete = true;
WriteFileToS3(response2.TranscriptionJob.Transcript.TranscriptFileUri, startRequest.TranscriptionJobName);
}
else if (response2.TranscriptionJob.TranscriptionJobStatus == TranscriptionJobStatus.FAILED)
{
isComplete = true;
//need to log the error.
}
else
{
System.Threading.Thread.Sleep(5000);//wait 5 seconds and check again
//not done yet
}
}
}
public async Task <State> StartTranscribeAsync(State state, ILambdaContext context)
{
context.Logger.LogLine($"Starting transcribe {state.VideoName}, S3 location {state.S3Url}");
var request = new StartTranscriptionJobRequest
{
TranscriptionJobName = $"{state.VideoName.Replace(" ", "")}-{Guid.NewGuid().ToString()}",
LanguageCode = LanguageCode.EnUS,
MediaFormat = MediaFormat.Mp4,
Media = new Media
{
MediaFileUri = state.S3Url
}
};
var response = await _transcribeClient.StartTranscriptionJobAsync(request);
state.TranscriptionJobName = request.TranscriptionJobName;
context.Logger.LogLine($"Transcribe initiated, job name: {response.TranscriptionJob.TranscriptionJobName}");
return(state);
}
private async Task <TranscriptionJob> StartTranscriptionJob(string jobName, string mediaFileUri, string fileExt)
{
var transcriptionRequest = new StartTranscriptionJobRequest()
{
LanguageCode = "en-US",
Media = new Media()
{
MediaFileUri = mediaFileUri
},
MediaFormat = fileExt,
TranscriptionJobName = jobName,
Settings = new Settings()
{
MaxSpeakerLabels = MAX_SPEAKER_LABELS,
ShowSpeakerLabels = true
},
};
Console.WriteLine($"Start Transcription job: {DateTime.Now}");
var getTranscribeResponse = await config.AzTranscribeClient.StartTranscriptionJobAsync(transcriptionRequest);
return(getTranscribeResponse?.TranscriptionJob);
}
public async Task <SpeechRecognitionResult> ParseSpeectToText(string[] args)
{
if (string.IsNullOrEmpty(args[0]))
{
return(null);
}
var uploadDetails = await _amazonUploaderService.UploadBase64Wav(args[0]);
if (string.IsNullOrEmpty(uploadDetails.FileRoute))
{
return(null);
}
var transciptionJobName = "Transcribe_" + uploadDetails.FileRoute;
var request = new StartTranscriptionJobRequest()
{
Media = new Media()
{
MediaFileUri = "https://s3." + uploadDetails.BucketRegion + ".amazonaws.com/" + uploadDetails.BucketName + "/" + uploadDetails.FileRoute
},
LanguageCode = new LanguageCode(LanguageCode.EnUS),
MediaFormat = new MediaFormat("Wav"),
TranscriptionJobName = transciptionJobName
};
try
{
var res = await _amazonTranscribeService.StartTranscriptionJobAsync(request);
var jobComplete = false;
GetTranscriptionJobResponse jobRes = null;
while (!jobComplete)
{
jobRes = await _amazonTranscribeService.GetTranscriptionJobAsync(new GetTranscriptionJobRequest()
{
TranscriptionJobName = transciptionJobName
});
if (jobRes != null && jobRes.TranscriptionJob.TranscriptionJobStatus !=
TranscriptionJobStatus.COMPLETED)
{
System.Threading.Thread.Sleep(5000);
}
else
{
jobComplete = true;
}
}
var jsonRes = "";
using (var client = _httpProxyClientService.CreateHttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = client
.GetAsync(jobRes.TranscriptionJob.Transcript.TranscriptFileUri).Result;
if (!response.IsSuccessStatusCode)
{
return(null);
}
jsonRes = response.Content.ReadAsStringAsync().Result;
}
// Once done delete the file
await _amazonUploaderService.DeleteFile(uploadDetails.FileRoute);
return(new SpeechRecognitionResult()
{
StatusCode = 200,
JSONResult = jsonRes
});
}
catch (AmazonTranscribeServiceException ex)
{
Console.WriteLine("Error: " + ex.Message);
}
return(null);
}
/// <summary>
/// Initiates the asynchronous execution of the StartTranscriptionJob operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the StartTranscriptionJob operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/transcribe-2017-10-26/StartTranscriptionJob">REST API Reference for StartTranscriptionJob Operation</seealso>
public virtual Task <StartTranscriptionJobResponse> StartTranscriptionJobAsync(StartTranscriptionJobRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = StartTranscriptionJobRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartTranscriptionJobResponseUnmarshaller.Instance;
return(InvokeAsync <StartTranscriptionJobResponse>(request, options, cancellationToken));
}
internal static async Task ProcessJobAssignmentAsync(AwsAiServiceWorkerRequest @event)
{
var resourceManager = @event.GetAwsV4ResourceManager();
var table = new DynamoDbTable(@event.StageVariables["TableName"]);
var jobAssignmentId = @event.JobAssignmentId;
try
{
// 1. Setting job assignment status to RUNNING
await UpdateJobAssignmentStatusAsync(resourceManager, table, jobAssignmentId, "RUNNING", null);
// 2. Retrieving WorkflowJob
var job = await RetrieveJobAsync(resourceManager, table, jobAssignmentId);
// 3. Retrieve JobProfile
var jobProfile = await RetrieveJobProfileAsync(resourceManager, job);
// 4. Retrieve job inputParameters
var jobInput = job.JobInput;
// 5. Check if we support jobProfile and if we have required parameters in jobInput
ValidateJobProfile(jobProfile, jobInput);
S3Locator inputFile;
if (!jobInput.TryGet <S3Locator>(nameof(inputFile), out inputFile))
{
throw new Exception("Invalid or missing input file.");
}
S3Locator outputLocation;
if (!jobInput.TryGet <S3Locator>(nameof(outputLocation), out outputLocation))
{
throw new Exception("Invalid or missing output location.");
}
switch (jobProfile.Name)
{
case JOB_PROFILE_TRANSCRIBE_AUDIO:
string mediaFileUrl;
if (!string.IsNullOrWhiteSpace(inputFile.HttpEndpoint))
{
mediaFileUrl = inputFile.HttpEndpoint;
}
else
{
var bucketLocation = await inputFile.GetBucketLocationAsync();
var s3SubDomain = !string.IsNullOrWhiteSpace(bucketLocation) ? $"s3-{bucketLocation}" : "s3";
mediaFileUrl = $"https://{s3SubDomain}.amazonaws.com/{inputFile.AwsS3Bucket}/{inputFile.AwsS3Key}";
}
string mediaFormat;
if (mediaFileUrl.EndsWith("mp3", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "mp3";
}
else if (mediaFileUrl.EndsWith("mp4", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "mp4";
}
else if (mediaFileUrl.EndsWith("wav", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "wav";
}
else if (mediaFileUrl.EndsWith("flac", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "flac";
}
else
{
throw new Exception($"Unable to determine media format from input file '{mediaFileUrl}'");
}
var transcribeParameters = new StartTranscriptionJobRequest
{
TranscriptionJobName = "TranscriptionJob-" + jobAssignmentId.Substring(jobAssignmentId.LastIndexOf("/") + 1),
LanguageCode = "en-US",
Media = new Media {
MediaFileUri = mediaFileUrl
},
MediaFormat = mediaFormat,
OutputBucketName = @event.StageVariables["ServiceOutputBucket"]
};
var transcribeService = new AmazonTranscribeServiceClient();
var startJobResponse = await transcribeService.StartTranscriptionJobAsync(transcribeParameters);
Logger.Debug(startJobResponse.ToMcmaJson().ToString());
break;
case JOB_PROFILE_TRANSLATE_TEXT:
var s3Bucket = inputFile.AwsS3Bucket;
var s3Key = inputFile.AwsS3Key;
GetObjectResponse s3Object;
try
{
s3Object = await inputFile.GetAsync();
}
catch (Exception error)
{
throw new Exception($"Unable to read file in bucket '{s3Bucket}' with key '{s3Key}'.", error);
}
var inputText = await new StreamReader(s3Object.ResponseStream).ReadToEndAsync();
var translateParameters = new TranslateTextRequest
{
SourceLanguageCode = jobInput.TryGet("sourceLanguageCode", out string srcLanguageCode) ? srcLanguageCode : "auto",
TargetLanguageCode = jobInput.Get <string>("targetLanguageCode"),
Text = inputText
};
var translateService = new AmazonTranslateClient();
var translateResponse = await translateService.TranslateTextAsync(translateParameters);
var s3Params = new PutObjectRequest
{
BucketName = outputLocation.AwsS3Bucket,
Key = (!string.IsNullOrWhiteSpace(outputLocation.AwsS3KeyPrefix) ? outputLocation.AwsS3Key : string.Empty) + Guid.NewGuid() + ".txt",
ContentBody = translateResponse.TranslatedText
};
var outputS3 = await outputLocation.GetClientAsync();
await outputS3.PutObjectAsync(s3Params);
var jobOutput = new JobParameterBag();
jobOutput["outputFile"] = new S3Locator
{
AwsS3Bucket = s3Params.BucketName,
AwsS3Key = s3Params.Key
};
Logger.Debug("Updating job assignment");
await UpdateJobAssignmentWithOutputAsync(table, jobAssignmentId, jobOutput);
await UpdateJobAssignmentStatusAsync(resourceManager, table, jobAssignmentId, "COMPLETED");
break;
case JOB_PROFILE_DETECT_CELEBRITIES:
var randomBytes = new byte[16];
new Random().NextBytes(randomBytes);
var clientToken = randomBytes.HexEncode();
var base64JobId = Encoding.UTF8.GetBytes(jobAssignmentId).HexEncode();
var rekoParams = new StartCelebrityRecognitionRequest
{
Video = new Video
{
S3Object = new Amazon.Rekognition.Model.S3Object
{
Bucket = inputFile.AwsS3Bucket,
Name = inputFile.AwsS3Key
}
},
ClientRequestToken = clientToken,
JobTag = base64JobId,
NotificationChannel = new NotificationChannel
{
RoleArn = REKO_SNS_ROLE_ARN,
SNSTopicArn = SNS_TOPIC_ARN
}
};
var rekognitionClient = new AmazonRekognitionClient();
var startCelebRecognitionResponse = await rekognitionClient.StartCelebrityRecognitionAsync(rekoParams);
Logger.Debug(startCelebRecognitionResponse.ToMcmaJson().ToString());
break;
}
}
catch (Exception ex)
{
Logger.Exception(ex);
try
{
await UpdateJobAssignmentStatusAsync(resourceManager, table, jobAssignmentId, "FAILED", ex.ToString());
}
catch (Exception innerEx)
{
Logger.Exception(innerEx);
}
}
}
public string GetTranscriptURL()
{
string result = string.Empty;
try
{
AmazonTranscribeServiceClient client = new AmazonTranscribeServiceClient(ConfigurationManager.AppSettings["AmazonAccessKey"],
ConfigurationManager.AppSettings["AmazonSecretAccessKey"],
RegionEndpoint.EUWest1);
if (client != null)
{
string url = String.Format(ConfigurationManager.AppSettings["AmazonBucketURL"],
ConfigurationManager.AppSettings["AmazonBucketName"],
keyName);
Media media = new Media();
StartTranscriptionJobResponse transcriptionJobResponse = null;
GetTranscriptionJobResponse checkJob = null;
media.MediaFileUri = url;
StartTranscriptionJobRequest transcriptionJobRequest = new StartTranscriptionJobRequest();
string name = Guid.NewGuid().ToString();
transcriptionJobRequest.TranscriptionJobName = name;
transcriptionJobRequest.MediaFormat = "wav";
transcriptionJobRequest.Media = media;
transcriptionJobRequest.LanguageCode = "en-US";
GetTranscriptionJobRequest getTranscriptionJobRequest = new GetTranscriptionJobRequest();
getTranscriptionJobRequest.TranscriptionJobName = name;
bool finished = false;
transcriptionJobResponse = client.StartTranscriptionJob(transcriptionJobRequest);
while (!finished)
{
checkJob = client.GetTranscriptionJob(getTranscriptionJobRequest);
if (checkJob != null)
{
if (!checkJob.TranscriptionJob.TranscriptionJobStatus.Value.Contains("IN_PROGRESS"))
{
finished = true;
}
Thread.Sleep(1000);
}
}
result = checkJob.TranscriptionJob.Transcript.TranscriptFileUri;
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(result);
}
private async Task Transcribe(string filePath)
{
var fileNameWithExtension = Path.GetFileName(filePath);
var hash = (DateTime.Now.Ticks);
var jobName = "Test_" + fileNameWithExtension + "_" + hash;
var bucketref = "https://s3." + _bucketRegion + ".amazonaws.com/" + _bucketName + "/" + fileNameWithExtension;
Media fileref = new Media {
MediaFileUri = bucketref
};
var fileInfoContainer = CheckValidityAndReturnFileInfo(filePath).GetEnumerator();
fileInfoContainer.MoveNext();
var filetype = fileInfoContainer.Current.Key;
var bitrate = fileInfoContainer.Current.Value;
//TODO standardize a way to define / figure out the file properties
var request = new StartTranscriptionJobRequest
{
TranscriptionJobName = jobName,
LanguageCode = "en-US",
MediaSampleRateHertz = bitrate,
MediaFormat = filetype,
Media = fileref
};
//initial request to service
await _atClient.StartTranscriptionJobAsync(request);
//generate polling request to check in on service
var pollingreq = new GetTranscriptionJobRequest
{
TranscriptionJobName = request.TranscriptionJobName
};
//status of request
string status;
do
{
//check the request
var step = await _atClient.GetTranscriptionJobAsync(pollingreq);
//generate new status
status = step.TranscriptionJob.TranscriptionJobStatus.Value;
//sleep for 5 seconds before trying again
Thread.Sleep(10000);
//check if the transcription job failed for any reason
if (status == "FAILED")
{
Environment.Exit(0);
}
} while (status != "COMPLETED"); //run until complete
//Check the request one more time to get final updated info
var final = await _atClient.GetTranscriptionJobAsync(pollingreq);
//Generate an Http client to use to GET the JSON data from the URI
using (var temp = new HttpClient())
{
var location = final.TranscriptionJob.Transcript.TranscriptFileUri;
var msg = await temp.GetAsync(location);
var responseBody = await msg.Content.ReadAsStringAsync();
//Newtonsoft Parsing body
var data = JObject.Parse(responseBody);
var query = (string)data["results"]["transcripts"][0]["transcript"];
if (!Directory.Exists(TranscriptDestination))
{
Directory.CreateDirectory(TranscriptDestination);
}
if (File.Exists(TranscriptDestination + "aws_" + Path.GetFileNameWithoutExtension(filePath) + ".txt"))
{
File.Delete(TranscriptDestination + "aws_" + Path.GetFileNameWithoutExtension(filePath) + ".txt");
}
File.WriteAllText((TranscriptDestination + "aws_" + Path.GetFileNameWithoutExtension(filePath) + ".txt"), query);
}
}
public async static Task <string> TranscribeDemo(IAmazonTranscribeService transcribeClient, string lauguageCode, string mediaUri)
{
string result = null;
Media media = new Media()
{
MediaFileUri = mediaUri
};
StartTranscriptionJobRequest transcriptionRequest = new StartTranscriptionJobRequest()
{
TranscriptionJobName = DateTime.Now.Millisecond.ToString(),
Media = media,
MediaFormat = MediaFormat.Wav.ToString(),
LanguageCode = lauguageCode,
OutputBucketName = "reinvent-indiamazones"
};
try
{
Task <StartTranscriptionJobResponse> transcriptionTask = transcribeClient.StartTranscriptionJobAsync(transcriptionRequest);
StartTranscriptionJobResponse transcriptionResponse = await transcriptionTask;
TranscriptionJob transcriptionJob = transcriptionResponse.TranscriptionJob;
bool loop = true;
while (loop == true)
{
if (transcriptionResponse.TranscriptionJob.TranscriptionJobStatus == TranscriptionJobStatus.IN_PROGRESS)
{
Console.WriteLine(transcriptionResponse.TranscriptionJob.TranscriptionJobName);
Console.WriteLine(transcriptionResponse.TranscriptionJob.TranscriptionJobStatus);
if (transcriptionResponse.TranscriptionJob.Transcript != null)
{
Console.WriteLine(transcriptionResponse.TranscriptionJob.Transcript.TranscriptFileUri);
}
Thread.Sleep(3000);
}
else if (transcriptionResponse.TranscriptionJob.TranscriptionJobStatus == TranscriptionJobStatus.COMPLETED)
{
Console.Write("Transcription job completed.");
DateTime completionTime = transcriptionJob.CompletionTime;
result = transcriptionJob.Transcript.TranscriptFileUri;
loop = false;
}
else
{
Console.WriteLine(transcriptionResponse.TranscriptionJob.TranscriptionJobStatus);
result = string.Empty;
loop = false;
}
}
result = transcriptionResponse.TranscriptionJob.Transcript.TranscriptFileUri;
}
catch (AmazonTranscribeServiceException transcribeException)
{
Console.WriteLine(transcribeException.Message, transcribeException.InnerException);
}
return(result);
}
