能否在Qt C++项目中使用Go语言编写的谷歌语音转文本API？

Absolutely! You can totally integrate a Go-written Google Speech-to-Text API into your Qt C++ project—there are a couple of reliable approaches to pull this off, depending on your project’s needs and how tightly you want the two to integrate. Here are the most common methods:

1. Wrap Go code into a C-compatible shared library (using cgo) #

This lets you call Go functions directly from your Qt C++ code by exposing a C-friendly interface from the Go side.

• Step 1: Prepare your Go code
  Add //export comments to the functions you want to call from C++, and set up proper type conversions between Go and C types. For example:

  package main
  
  import "C"
  import (
      "context"
      "unsafe"
      speech "cloud.google.com/go/speech/apiv1"
      "cloud.google.com/go/speech/apiv1/speechpb"
  )
  
  //export RecognizeSpeech
  func RecognizeSpeech(audioData *C.char, audioLen C.int) *C.char {
      // Convert C bytes to Go slice
      goAudio := C.GoBytes(unsafe.Pointer(audioData), audioLen)
      
      // Initialize Google Speech-to-Text client
      ctx := context.Background()
      client, err := speech.NewClient(ctx)
      if err != nil {
          return C.CString("Failed to initialize speech client")
      }
      defer client.Close()
  
      // Build recognition request
      req := &speechpb.RecognizeRequest{
          Config: &speechpb.RecognitionConfig{
              Encoding:        speechpb.RecognitionConfig_LINEAR16,
              SampleRateHertz: 16000,
              LanguageCode:    "en-US",
          },
          Audio: &speechpb.RecognitionAudio{
              AudioSource: &speechpb.RecognitionAudio_Content{Content: goAudio},
          },
      }
      
      resp, err := client.Recognize(ctx, req)
      if err != nil {
          return C.CString("Recognition failed: " + err.Error())
      }
  
      // Format results into a string
      resultStr := ""
      for _, res := range resp.Results {
          for _, alt := range res.Alternatives {
              resultStr += alt.Transcript + "\n"
          }
      }
      return C.CString(resultStr)
  }
  
  func main() {} // Required for cgo compilation
  

• Step 2: Compile the Go code into a shared library
  Use platform-specific go build flags to generate a library your Qt project can link against:

  • Linux/macOS: go build -buildmode=c-shared -o libspeech.so main.go
  • Windows: go build -buildmode=c-shared -o speech.dll main.go

• Step 3: Link to your Qt project
  Update your Qt .pro file to include the library path and linkage:

  LIBS += -L/path/to/your/library -lspeech
  

  Then in your C++ code, declare the exported function and use it:

  extern "C" char* RecognizeSpeech(char* audioData, int audioLen);
  
  // Example usage
  QByteArray audioBytes = /* Your raw audio data here */;
  char* recognitionResult = RecognizeSpeech(audioBytes.data(), audioBytes.size());
  qDebug() << "Speech result:" << QString::fromUtf8(recognitionResult);
  free(recognitionResult); // Critical: Free memory allocated by Go's C.CString
  

  Note: Be mindful of type conversions and memory management—Go’s garbage collector doesn’t track memory allocated for C types, so you must explicitly free it in your C++ code.

2. Use inter-process communication (IPC) between Qt C++ and a Go binary #

If cgo feels too cumbersome, package your Go code as a standalone executable and have your Qt app communicate with it via pipes, sockets, or command-line arguments.

• How it works:

  • Write a Go program that reads audio data (e.g., from standard input, a local socket, or a temporary file), runs the speech recognition, and writes the formatted result to standard output.
  • In Qt, use QProcess to launch the Go executable, send your audio data to its stdin, and read the result from stdout.
  • For clean data exchange, use JSON or Protobuf to serialize audio metadata and results between the two processes.

  Pros: No messy cross-language type handling—each component stays independent, making debugging simpler.
  Cons: Minor overhead from IPC, and you’ll need to handle data serialization logic.

3. Expose the Go API as a network service (REST/gRPC) #

For full decoupling (or if you want to reuse the speech service across multiple apps), wrap your Go code into a REST or gRPC server, then have your Qt app call it over the network.

• REST approach:

  • Use Go’s built-in net/http package to create an HTTP endpoint that accepts audio data (via POST requests), runs the speech recognition, and returns results as JSON.
  • In Qt, use QNetworkAccessManager to send POST requests with your audio data, then parse the JSON response.

• gRPC approach:

  • Define a gRPC service protobuf with methods for speech recognition, generate Go server code and C++ client code.
  • Implement the Go server to call Google’s Speech-to-Text API, then use the generated C++ client in your Qt app to communicate with the server.

  Pros: Complete separation of concerns—your Qt app doesn’t need any knowledge of Go, and you can even host the service on a remote server for scalability.
  Cons: Requires network access, adds deployment complexity (you’ll need to run the service alongside your Qt app).

Quick Integration Tips #

• Ensure your Go code has proper Google Cloud authentication configured (e.g., via the GOOGLE_APPLICATION_CREDENTIALS environment variable). If using a shared library or IPC, pass this environment variable from your Qt app to the Go component.
• Double-check that your audio format (sample rate, encoding, channel count) matches the requirements of Google’s Speech-to-Text API to avoid recognition failures.

内容的提问来源于stack exchange，提问作者Martin Delille