Speech api changes

speech/grpc/README.md

@@ -73,20 +73,35 @@ note that the audio file must be in RAW format. You can use `sox`
 (available, e.g. via [http://sox.sourceforge.net/](http://sox.sourceforge.net/)
 or [homebrew](http://brew.sh/)) to convert audio files to raw format.
 
-### Run the non-streaming client
+### Run the sync client
 
-You can run the batch client like this:
+You can run the sync client like this:
 
 ```sh
-$ bin/speech-sample-nonstreaming.sh --host=speech.googleapis.com --port=443 \
---file=<audio file path> --sampling=<sample rate>
+$ bin/speech-sample-sync.sh --host=speech.googleapis.com --port=443 \
+--uri=<audio file uri> --sampling=<sample rate>
 ```
 
 Try a streaming rate of 16000 and the included sample audio file, as follows:
 
 ```sh
-$ bin/speech-sample-nonstreaming.sh --host=speech.googleapis.com --port=443 \
---file=resources/audio.raw --sampling=16000
+$ bin/speech-sample-sync.sh --host=speech.googleapis.com --port=443 \
+--uri=resources/audio.raw --sampling=16000
+```
+
+### Run the async client
+
+You can run the async client like this:
+
+```sh
+bin/speech-sample-async.sh --host=speech.googleapis.com --port=443 \
+--uri=<audio file uri> --sampling=<sample rate>
+```
+
+Try a streaming rate of 16000 and the included sample audio file, as follows:
+```sh
+$ bin/speech-sample-async.sh --host=speech.googleapis.com --port=443 \
+--uri=resources/audio.raw --sampling=16000
 ```
 
 ### Run the streaming client

speech/grpc/bin/speech-sample-nonstreaming.sh → speech/grpc/bin/speech-sample-async.sh

@@ -15,4 +15,4 @@
 
 SRC_DIR=$(cd "$(dirname "$0")/.."; pwd)
 java -cp ${SRC_DIR}/target/grpc-sample-1.0-jar-with-dependencies.jar \
- com.google.cloud.speech.grpc.demos.NonStreamingRecognizeClient "$@"
+ com.google.cloud.speech.grpc.demos.AsyncRecognizeClient "$@"

speech/grpc/bin/speech-sample-streaming.sh

@@ -15,4 +15,4 @@
 
 SRC_DIR=$(cd "$(dirname "$0")/.."; pwd)
 java -cp ${SRC_DIR}/target/grpc-sample-1.0-jar-with-dependencies.jar \
- com.google.cloud.speech.grpc.demos.RecognizeClient "$@"
+ com.google.cloud.speech.grpc.demos.StreamingRecognizeClient "$@"

speech/grpc/bin/speech-sample-sync.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+SRC_DIR=$(cd "$(dirname "$0")/.."; pwd)
+java -cp ${SRC_DIR}/target/grpc-sample-1.0-jar-with-dependencies.jar \
+ com.google.cloud.speech.grpc.demos.SyncRecognizeClient "$@"

speech/grpc/src/main/java/com/google/cloud/speech/grpc/demos/AsyncRecognizeClient.java

@@ -0,0 +1,248 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Client that sends audio to Speech.AsyncRecognize via gRPC and returns longrunning operation.
+// The results are received via the google.longrunning.Operations interface.
+//
+// Uses a service account for OAuth2 authentication, which you may obtain at
+// https://console.developers.google.com
+// API Manager > Google Cloud Speech API > Enable
+// API Manager > Credentials > Create credentials > Service account key > New service account.
+//
+// Then set environment variable GOOGLE_APPLICATION_CREDENTIALS to the full path of that file.
+
+package com.google.cloud.speech.grpc.demos;
+
+import com.google.auth.oauth2.GoogleCredentials;
+import com.google.cloud.speech.v1beta1.AsyncRecognizeRequest;
+import com.google.cloud.speech.v1beta1.AsyncRecognizeResponse;
+import com.google.cloud.speech.v1beta1.RecognitionAudio;
+import com.google.cloud.speech.v1beta1.RecognitionConfig;
+import com.google.cloud.speech.v1beta1.RecognitionConfig.AudioEncoding;
+import com.google.cloud.speech.v1beta1.SpeechGrpc;
+
+import com.google.longrunning.GetOperationRequest;
+import com.google.longrunning.Operation;
+import com.google.longrunning.OperationsGrpc;
+
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.auth.ClientAuthInterceptor;
+import io.grpc.netty.NegotiationType;
+import io.grpc.netty.NettyChannelBuilder;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.DefaultParser;
+import org.apache.commons.cli.OptionBuilder;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Client that sends audio to Speech.AsyncRecognize and returns transcript.
+ */
+public class AsyncRecognizeClient {
+
+ private static final Logger logger =
+ Logger.getLogger(AsyncRecognizeClient.class.getName());
+
+ private static final List<String> OAUTH2_SCOPES =
+ Arrays.asList("https://www.googleapis.com/auth/cloud-platform");
+
+ private final String host;
+ private final int port;
+ private final URI input;
+ private final int samplingRate;
+
+ private final ManagedChannel channel;
+ private final SpeechGrpc.SpeechBlockingStub stub;
+ private final OperationsGrpc.OperationsBlockingStub statusStub;
+
+ /**
+ * Construct client connecting to Cloud Speech server at {@code host:port}.
+ */
+ public AsyncRecognizeClient(String host, int port, URI input, int samplingRate)
+ throws IOException {
+ this.host = host;
+ this.port = port;
+ this.input = input;
+ this.samplingRate = samplingRate;
+
+ GoogleCredentials creds = GoogleCredentials.getApplicationDefault();
+ creds = creds.createScoped(OAUTH2_SCOPES);
+ channel = NettyChannelBuilder.forAddress(host, port)
+ .negotiationType(NegotiationType.TLS)
+ .intercept(new ClientAuthInterceptor(creds, Executors.newSingleThreadExecutor()))
+ .build();
+ stub = SpeechGrpc.newBlockingStub(channel);
+ statusStub = OperationsGrpc.newBlockingStub(channel);
+
+ logger.info("Created stub for " + host + ":" + port);
+ }
+
+ private RecognitionAudio createRecognitionAudio() throws IOException {
+ return RecognitionAudioFactory.createRecognitionAudio(this.input);
+ }
+
+ public void shutdown() throws InterruptedException {
+ channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+ }
+
+ /** Send an async-recognize request to server. */
+ public void recognize() {
+ RecognitionAudio audio;
+ try {
+ audio = createRecognitionAudio();
+ } catch (IOException e) {
+ logger.log(Level.WARNING, "Failed to read audio uri input: " + input);
+ return;
+ }
+ logger.info("Sending " + audio.getContent().size() + " bytes from audio uri input: " + input);
+ RecognitionConfig config = RecognitionConfig.newBuilder()
+ .setEncoding(AudioEncoding.LINEAR16)
+ .setSampleRate(samplingRate)
+ .build();
+ AsyncRecognizeRequest request = AsyncRecognizeRequest.newBuilder()
+ .setConfig(config)
+ .setAudio(audio)
+ .build();
+
+ Operation operation;
+ Operation status;
+ try {
+ operation = stub.asyncRecognize(request);
+
+ //Print the long running operation handle
+ logger.log(Level.INFO, String.format("Operation handle: %s, URI: %s", operation.getName(),
+ input.toString()));
+ } catch (StatusRuntimeException e) {
+ logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+ return;
+ }
+
+ while (true) {
+ try {
+ logger.log(Level.INFO, "Waiting 2s for operation, {0} processing...", operation.getName());
+ Thread.sleep(2000);
+ GetOperationRequest operationReq = GetOperationRequest.newBuilder()
+ .setName(operation.getName())
+ .build();
+ status = statusStub.getOperation(
+ GetOperationRequest.newBuilder()
+ .setName(operation.getName())
+ .build()
+ );
+
+ if (status.getDone()) {
+ break;
+ }
+ } catch (Exception ex) {
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ }
+
+ try {
+ AsyncRecognizeResponse asyncRes = status.getResponse().unpack(AsyncRecognizeResponse.class);
+
+ logger.info("Received response: " + asyncRes);
+ } catch (com.google.protobuf.InvalidProtocolBufferException ex) {
+ logger.log(Level.WARNING, "Unpack error, {0}",ex.getMessage());
+ }
+ }
+
+ public static void main(String[] args) throws Exception {
+
+ String audioFile = "";
+ String host = "speech.googleapis.com";
+ Integer port = 443;
+ Integer sampling = 16000;
+
+ CommandLineParser parser = new DefaultParser();
+
+ Options options = new Options();
+ options.addOption(OptionBuilder.withLongOpt("uri")
+ .withDescription("path to audio uri")
+ .hasArg()
+ .withArgName("FILE_PATH")
+ .create());
+ options.addOption(OptionBuilder.withLongOpt("host")
+ .withDescription("endpoint for api, e.g. speech.googleapis.com")
+ .hasArg()
+ .withArgName("ENDPOINT")
+ .create());
+ options.addOption(OptionBuilder.withLongOpt("port")
+ .withDescription("SSL port, usually 443")
+ .hasArg()
+ .withArgName("PORT")
+ .create());
+ options.addOption(OptionBuilder.withLongOpt("sampling")
+ .withDescription("Sampling Rate, i.e. 16000")
+ .hasArg()
+ .withArgName("RATE")
+ .create());
+
+ try {
+ CommandLine line = parser.parse(options, args);
+ if (line.hasOption("uri")) {
+ audioFile = line.getOptionValue("uri");
+ } else {
+ System.err.println("An Audio uri must be specified (e.g. file:///foo/baz.raw).");
+ System.exit(1);
+ }
+
+ if (line.hasOption("host")) {
+ host = line.getOptionValue("host");
+ } else {
+ System.err.println("An API enpoint must be specified (typically speech.googleapis.com).");
+ System.exit(1);
+ }
+
+ if (line.hasOption("port")) {
+ port = Integer.parseInt(line.getOptionValue("port"));
+ } else {
+ System.err.println("An SSL port must be specified (typically 443).");
+ System.exit(1);
+ }
+
+ if (line.hasOption("sampling")) {
+ sampling = Integer.parseInt(line.getOptionValue("sampling"));
+ } else {
+ System.err.println("An Audio sampling rate must be specified.");
+ System.exit(1);
+ }
+ } catch (ParseException exp) {
+ System.err.println("Unexpected exception:" + exp.getMessage());
+ System.exit(1);
+ }
+
+ AsyncRecognizeClient client =
+ new AsyncRecognizeClient(host, port, URI.create(audioFile), sampling);
+ try {
+ client.recognize();
+ } finally {
+ client.shutdown();
+ }
+ }
+}

speech/grpc/src/main/java/com/google/cloud/speech/grpc/demos/AudioRequestFactory.java → speech/grpc/src/main/java/com/google/cloud/speech/grpc/demos/RecognitionAudioFactory.java

@@ -17,20 +17,21 @@
 
 package com.google.cloud.speech.grpc.demos;
 
-import com.google.cloud.speech.v1.AudioRequest;
+import com.google.cloud.speech.v1beta1.RecognitionAudio;
 import com.google.protobuf.ByteString;
 
+import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 
 /*
- * AudioRequestFactory takes a URI as an input and creates an AudioRequest. The URI can point to a
- * local file or a file on Google Cloud Storage.
+ * RecognitionAudioFactory takes a URI as an input and creates a RecognitionAudio. 
+ * The URI can point to a local file or a file on Google Cloud Storage.
  */
-public class AudioRequestFactory {
+public class RecognitionAudioFactory {
 
  private static final String FILE_SCHEME = "file";
  private static final String GS_SCHEME = "gs";
@@ -39,27 +40,31 @@ public class AudioRequestFactory {
  * Takes an input URI of form $scheme:// and converts to audio request.
  *
  * @param uri input uri
- * @return AudioRequest audio request
+ * @return RecognitionAudio recognition audio
  */
- public static AudioRequest createRequest(URI uri)
+ public static RecognitionAudio createRecognitionAudio(URI uri)
  throws IOException {
- if (uri.getScheme() == null || uri.getScheme().equals(FILE_SCHEME)) {
+ if (uri.getScheme() == null) {
+ uri = new File(uri.toString()).toURI();
+ Path path = Paths.get(uri);
+ return audioFromBytes(Files.readAllBytes(path));
+ } else if (uri.getScheme().equals(FILE_SCHEME)) {
  Path path = Paths.get(uri);
  return audioFromBytes(Files.readAllBytes(path));
  } else if (uri.getScheme().equals(GS_SCHEME)) {
- return AudioRequest.newBuilder().setUri(uri.toString()).build();
+ return RecognitionAudio.newBuilder().setUri(uri.toString()).build();
  }
  throw new RuntimeException("scheme not supported " + uri.getScheme());
  }
 
  /**
- * Convert bytes to AudioRequest.
+ * Convert bytes to RecognitionAudio.
  *
  * @param bytes input bytes
- * @return AudioRequest audio request
+ * @return RecognitionAudio recognition audio
  */
- private static AudioRequest audioFromBytes(byte[] bytes) {
- return AudioRequest.newBuilder()
+ private static RecognitionAudio audioFromBytes(byte[] bytes) {
+ return RecognitionAudio.newBuilder()
  .setContent(ByteString.copyFrom(bytes))
  .build();
  }