Transcribe long audio files into text

funcsendGCS(wio.Writer,client*speech.Client,gcsURIstring)error{
ctx:=context.Background()
// Send the contents of the audio file with the encoding and
// and sample rate information to be transcripted.
req:=&speechpb.LongRunningRecognizeRequest{
Config:&speechpb.RecognitionConfig{
Encoding:speechpb.RecognitionConfig_LINEAR16,
SampleRateHertz:16000,
LanguageCode:"en-US",
},
Audio:&speechpb.RecognitionAudio{
AudioSource:&speechpb.RecognitionAudio_Uri{Uri:gcsURI},
},
}
op,err:=client.LongRunningRecognize(ctx,req)
iferr!=nil{
returnerr
}
resp,err:=op.Wait(ctx)
iferr!=nil{
returnerr
}
// Print the results.
for_,result:=rangeresp.Results{
for_,alt:=rangeresult.Alternatives{
fmt.Fprintf(w,"\"%v\" (confidence=%3f)\n",alt.Transcript,alt.Confidence)
}
}
returnnil
}

/**
 * Performs non-blocking speech recognition on remote FLAC file and prints the transcription.
 *
 * @param gcsUri the path to the remote LINEAR16 audio file to transcribe.
 */
publicstaticvoidasyncRecognizeGcs(StringgcsUri)throwsException{
// Configure polling algorithm
SpeechSettings.BuilderspeechSettings=SpeechSettings.newBuilder();
TimedRetryAlgorithmtimedRetryAlgorithm=
OperationTimedPollAlgorithm.create(
RetrySettings.newBuilder()
.setInitialRetryDelay(Duration.ofMillis(500L))
.setRetryDelayMultiplier(1.5)
.setMaxRetryDelay(Duration.ofMillis(5000L))
.setInitialRpcTimeout(Duration.ZERO)// ignored
.setRpcTimeoutMultiplier(1.0)// ignored
.setMaxRpcTimeout(Duration.ZERO)// ignored
.setTotalTimeout(Duration.ofHours(24L))// set polling timeout to 24 hours
.build());
speechSettings.longRunningRecognizeOperationSettings().setPollingAlgorithm(timedRetryAlgorithm);
// Instantiates a client with GOOGLE_APPLICATION_CREDENTIALS
try(SpeechClientspeech=SpeechClient.create(speechSettings.build())){
// Configure remote file request for FLAC
RecognitionConfigconfig=
RecognitionConfig.newBuilder()
.setEncoding(AudioEncoding.FLAC)
.setLanguageCode("en-US")
.setSampleRateHertz(16000)
.build();
RecognitionAudioaudio=RecognitionAudio.newBuilder().setUri(gcsUri).build();
// Use non-blocking call for getting file transcription
OperationFuture<LongRunningRecognizeResponse,LongRunningRecognizeMetadata>response=
speech.longRunningRecognizeAsync(config,audio);
while(!response.isDone()){
System.out.println("Waiting for response...");
Thread.sleep(10000);
}
List<SpeechRecognitionResult>results=response.get().getResultsList();
for(SpeechRecognitionResultresult:results){
// There can be several alternative transcripts for a given chunk of speech. Just use the
// first (most likely) one here.
SpeechRecognitionAlternativealternative=result.getAlternativesList().get(0);
System.out.printf("Transcription: %s\n",alternative.getTranscript());
}
}
}

// Imports the Google Cloud client library
constspeech=require('@google-cloud/speech');
// Creates a client
constclient=newspeech.SpeechClient ();
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const gcsUri = 'gs://my-bucket/audio.raw';
// const encoding = 'Encoding of the audio file, e.g. LINEAR16';
// const sampleRateHertz = 16000;
// const languageCode = 'BCP-47 language code, e.g. en-US';
constconfig={
encoding:encoding,
sampleRateHertz:sampleRateHertz,
languageCode:languageCode,
};
constaudio={
uri:gcsUri,
};
constrequest={
config:config,
audio:audio,
};
// Detects speech in the audio file. This creates a recognition job that you
// can wait for now, or get its result later.
const[operation]=awaitclient.longRunningRecognize(request);
// Get a Promise representation of the final result of the job
const[response]=awaitoperation.promise();
consttranscription=response.results
.map(result=>result.alternatives[0].transcript)
.join('\n');
console.log(`Transcription: ${transcription}`);

fromgoogle.cloudimport speech
deftranscribe_gcs(gcs_uri: str) -> str:
"""Asynchronously transcribes the audio file from Cloud Storage
 Args:
 gcs_uri: The Google Cloud Storage path to an audio file.
 E.g., "gs://storage-bucket/file.flac".
 Returns:
 The generated transcript from the audio file provided.
 """
 client = speech.SpeechClient()
 audio = speech.RecognitionAudio (uri=gcs_uri)
 config = speech.RecognitionConfig (
 encoding=speech.RecognitionConfig.AudioEncoding.FLAC,
 sample_rate_hertz=44100,
 language_code="en-US",
 )
 operation = client.long_running_recognize (config=config, audio=audio)
 print("Waiting for operation to complete...")
 response = operation.result(timeout=90)
 transcript_builder = []
 # Each result is for a consecutive portion of the audio. Iterate through
 # them to get the transcripts for the entire audio file.
 for result in response.results:
 # The first alternative is the most likely one for this portion.
 transcript_builder.append(f"\nTranscript: {result.alternatives[0].transcript}")
 transcript_builder.append(f"\nConfidence: {result.alternatives[0].confidence}")
 transcript = "".join(transcript_builder)
 print(transcript)
 return transcript