func TestRecognize(t *testing.T) {
testutil.SystemTest(t)
ctx := context.Background()
client, err := speech.NewClient(ctx)
if err != nil {
t.Fatal(err)
}
opName, err := send(client, "./quit.raw")
if err != nil {
t.Fatal(err)
}
if opName == "" {
t.Fatal("got no op name; want one")
}
resp, err := wait(client, opName)
if err != nil {
t.Fatal(err)
}
if len(resp.Results) == 0 {
t.Fatal("got no results; want at least one")
}
result := resp.Results[0]
if len(result.Alternatives) < 1 {
t.Fatal("got no alternatives; want at least one")
}
if got, want := result.Alternatives[0].Transcript, "quit"; got != want {
t.Errorf("Transcript: got %q; want %q", got, want)
}
}
func main() {
if len(os.Args) < 2 {
fmt.Fprintln(os.Stderr, usage)
os.Exit(2)
}
ctx := context.Background()
client, err := speech.NewClient(ctx)
if err != nil {
log.Fatal(err)
}
opName, err := send(client, os.Args[1])
if err != nil {
log.Fatal(err)
}
resp, err := wait(client, opName)
if err != nil {
log.Fatal(err)
}
// Print the results.
for _, result := range resp.Results {
for _, alt := range result.Alternatives {
fmt.Printf("\"%v\" (confidence=%3f)\n", alt.Transcript, alt.Confidence)
}
}
}
func recognize(file string) (*speechpb.SyncRecognizeResponse, error) {
ctx := context.Background()
// [START init]
client, err := speech.NewClient(ctx)
if err != nil {
log.Fatal(err)
}
// [END init]
// [START request]
data, err := ioutil.ReadFile(file)
if err != nil {
log.Fatal(err)
}
// Send the contents of the audio file with the encoding and
// and sample rate information to be transcripted.
resp, err := client.SyncRecognize(ctx, &speechpb.SyncRecognizeRequest{
Config: &speechpb.RecognitionConfig{
Encoding: speechpb.RecognitionConfig_LINEAR16,
SampleRate: 16000,
},
Audio: &speechpb.RecognitionAudio{
AudioSource: &speechpb.RecognitionAudio_Content{Content: data},
},
})
// [END request]
return resp, err
}
func main() {
ctx := context.Background()
conn, err := transport.DialGRPC(ctx,
option.WithEndpoint("speech.googleapis.com:443"),
option.WithScopes("https://www.googleapis.com/auth/cloud-platform"),
)
if err != nil {
log.Fatal(err)
}
defer conn.Close()
// [START speech_streaming_mic_recognize]
client, err := speech.NewClient(ctx)
if err != nil {
log.Fatal(err)
}
stream, err := client.StreamingRecognize(ctx)
if err != nil {
log.Fatal(err)
}
// Send the initial configuration message.
if err := stream.Send(&speechpb.StreamingRecognizeRequest{
StreamingRequest: &speechpb.StreamingRecognizeRequest_StreamingConfig{
StreamingConfig: &speechpb.StreamingRecognitionConfig{
Config: &speechpb.RecognitionConfig{
Encoding: speechpb.RecognitionConfig_LINEAR16,
SampleRate: 16000,
},
},
},
}); err != nil {
log.Fatal(err)
}
go func() {
// Pipe stdin to the API.
buf := make([]byte, 1024)
for {
n, err := os.Stdin.Read(buf)
if err == io.EOF {
return // Nothing else to pipe, return from this goroutine.
}
if err != nil {
log.Printf("Could not read from stdin: %v", err)
continue
}
if err = stream.Send(&speechpb.StreamingRecognizeRequest{
StreamingRequest: &speechpb.StreamingRecognizeRequest_AudioContent{
AudioContent: buf[:n],
},
}); err != nil {
log.Printf("Could not send audio: %v", err)
}
}
}()
for {
resp, err := stream.Recv()
if err == io.EOF {
break
}
if err != nil {
log.Fatalf("Cannot stream results: %v", err)
}
if err := resp.Error; err != nil {
log.Fatalf("Could not recognize: %v", err)
}
for _, result := range resp.Results {
fmt.Printf("Result: %+v\n", result)
}
}
// [END speech_streaming_mic_recognize]
}