功能介紹

• 支持的輸入格式：單聲道（mono）、16 bit采樣位數，包括PCM、PCM編碼的WAV、OGG封裝的OPUS、OGG封裝的SPEEX、AMR、MP3、AAC。

• 音頻采樣率：8000 Hz、16000 Hz。

• 支持設置返回結果：是否在后處理中添加標點，是否將中文數字轉為阿拉伯數字輸出。

• 支持控制臺配置項目熱詞、定制語言模型。

• 支持多種語言識別，可在控制臺編輯項目進行模型配置，詳情請參見管理項目。

前提條件

• 已獲取項目Appkey，詳情請參見創建項目。

• 已獲取Access Token，詳情請參見獲取Token概述。

交互流程

客戶端向服務端發送帶有音頻數據的HTTPS RESTful POST請求，服務端返回帶有識別結果的HTTPS響應。

服務地址

上傳二進制音頻流

一句話識別請求HTTPS報文實例。

POST /stream/v1/asr?appkey=23f5****&format=pcm&sample_rate=16000&enable_punctuation_prediction=true&enable_inverse_text_normalization=true HTTP/1.1
X-NLS-Token: 450372e4279bcc2b3c793****
Content-type: application/octet-stream
Content-Length: 94616
Host: nls-gateway-cn-shanghai.aliyuncs.com

[audio data]

一個完整的一句話識別RESTful API請求需包含以下要素：HTTPS請求行、HTTPS請求頭部和HTTPS請求體。

• HTTPS請求行

  HTTPS請求行指定了URL和請求參數，由URL和請求參數組成的完整請求鏈接如下：

  https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr?appkey=Yu1******uncS&format=pcm&sample_rate=16000&vocabulary_id=a17******d6b&customization_id=abd******ed8&enable_punctuation_prediction=true&enable_inverse_text_normalization=true&enable_voice_detection=true

  • URL

    協議	URL	方法
    HTTP/1.1	nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr	POST

  • 請求參數

    參數	類型	是否必選	描述
    appkey	String	是	應用Appkey。 獲取Appkey請前往控制臺。
    format	String	否	音頻格式，包括PCM、WAV、OPUS、SPEEX、AMR、MP3、AAC。
    sample_rate	Integer	否	音頻采樣率。取值：16000 Hz、8000 Hz。默認值：16000 Hz。
    vocabulary_id	String	否	添加熱詞表ID。默認：不添加。
    customization_id	String	否	添加自學習模型ID。默認：不添加。
    enable_punctuation_prediction	Boolean	否	是否在后處理中添加標點，默認值：False（關閉。
    enable_inverse_text_normalization	Boolean	否	ITN（逆文本inverse text normalization）中文數字轉換阿拉伯數字。設置為True時，中文數字將轉為阿拉伯數字輸出，默認值：False。
    enable_voice_detection	Boolean	否	是否啟動語音檢測。開啟后能夠識別出一段音頻中有效語音的開始和結束，剔除噪音數據。默認值：False（不開啟）。
    disfluency	Boolean	否	過濾語氣詞，即聲音順滑，默認值：False（關閉）。

• HTTPS請求頭部

  HTTPS請求頭部由“關鍵字-值”對組成，每行一對，關鍵字和值用英文冒號“:”分隔，設置內容如下：

  名稱	類型	是否必選	描述
  X-NLS-Token	String	是	服務鑒權Token。
  Content-type	String	是	取值“application/octet-stream”，表明HTTPS請求體的數據為二進制流。
  Content-Length	long	是	HTTPS請求體中請求數據的長度，即音頻文件的長度。
  Host	String	是	取值“nls-gateway-cn-shanghai.aliyuncs.com”，為HTTPS請求的服務器域名。

• HTTPS請求體

  HTTPS請求體傳入的是二進制音頻數據，因此在HTTPS請求頭部中的Content-Type必須設置為application/octet-stream。

使用音頻文件鏈接

一句話識別請求HTTPS報文實例。

POST /stream/v1/asr?appkey=23f5****&format=pcm&sample_rate=16000&enable_punctuation_prediction=true&enable_inverse_text_normalization=true&audio_address=your-audio-url HTTP/1.1
X-NLS-Token: 450372e4279bcc2b3c793****
Host: nls-gateway-cn-shanghai.aliyuncs.com

一個完整的一句話識別RESTful API請求需包含以下要素：HTTPS請求行、HTTPS請求頭部和HTTPS請求體。

• HTTPS請求行

  HTTPS請求行指定了URL和請求參數，由URL和請求參數組成的完整請求鏈接如下：

  https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr?appkey=Yu1******uncS&format=pcm&sample_rate=16000&vocabulary_id=a17******d6b&customization_id=abd******ed8&enable_punctuation_prediction=true&enable_inverse_text_normalization=true&enable_voice_detection=true&audio_address=your-audio-url

  • URL

    協議	URL	方法
    HTTP/1.1	nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr	POST

  • 請求參數

    參數	類型	是否必選	描述
    appkey	String	是	應用Appkey。 獲取Appkey請前往控制臺。
    format	String	否	音頻格式，包括PCM、WAV、OPUS、SPEEX、AMR、MP3、AAC。
    sample_rate	Integer	否	音頻采樣率。取值：16000 Hz、8000 Hz。默認值：16000 Hz。
    vocabulary_id	String	否	添加熱詞表ID。默認：不添加。
    customization_id	String	否	添加自學習模型ID。默認：不添加。
    enable_punctuation_prediction	Boolean	否	是否在后處理中添加標點，默認值：False（關閉。
    enable_inverse_text_normalization	Boolean	否	ITN（逆文本inverse text normalization）中文數字轉換阿拉伯數字。設置為True時，中文數字將轉為阿拉伯數字輸出，默認值：False。
    enable_voice_detection	Boolean	否	是否啟動語音檢測。開啟后能夠識別出一段音頻中有效語音的開始和結束，剔除噪音數據。默認值：False（不開啟）。
    disfluency	Boolean	否	過濾語氣詞，即聲音順滑，默認值：False（關閉）。
    audio_address	String	否	可通過公網訪問的音頻文件下載鏈接。推薦使用阿里云OSS，具體請參見通過OSS如何獲取訪問URL。

• HTTPS請求頭部

  HTTPS請求頭部由“關鍵字-值”對組成，每行一對，關鍵字和值用英文冒號“:”分隔，設置內容如下：

  名稱	類型	是否必選	描述
  X-NLS-Token	String	是	服務鑒權Token。
  Host	String	是	取值“nls-gateway-cn-shanghai.aliyuncs.com”，為HTTPS請求的服務器域名。

響應結果

發送上傳音頻的HTTPS請求后，會收到服務端的響應，識別結果以JSON字符串的形式保存在響應結果中。

• 成功響應

  {
      "task_id": "cf7b0c5339244ee29cd4e43fb97f****",
      "result": "北京的天氣。",
      "status":20000000,
      "message":"SUCCESS"
  }

• 失敗響應

  以鑒權token無效為例：

  {
      "task_id": "8bae3613dfc54ebfa811a17d8a7a****",
      "result": "",
      "status": 40000001,
      "message": "Gateway:ACCESS_DENIED:The token 'c0c1e860f3*******de8091c68a' is invalid!"
  }

  參數	類型	描述
  task_id	String	32位任務ID。請您記錄該值，以便排查錯誤。
  result	String	語音識別結果。
  status	Integer	服務狀態碼。
  message	String	服務狀態描述。

服務狀態碼

快速測試

1. 下載音頻文件nls-sample-16k.wav。

2. 使用如下cURL命令行進行一句話識別的RESTful API測試。

   curl -X POST -H "X-NLS-Token: ${token}" https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr?appkey=${appkey} --data-binary @${audio_file}

   舉例如下：

   curl -X POST -H "X-NLS-Token: 4a036531cfdd****" https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr?appkey=tt43P2u**** --data-binary @./nls-sample-16k.wav

Java示例

依賴文件如下：

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.9.1</version>
</dependency>

<!-- http://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.83</version>
</dependency>

發送請求與響應：

import com.alibaba.fastjson.JSONPath;
import com.alibaba.nls.client.example.utils.HttpUtil;
import java.util.HashMap;
public class SpeechRecognizerRESTfulDemo {
    private String accessToken;
    private String appkey;

    public SpeechRecognizerRESTfulDemo(String appkey, String token) {
        this.appkey = appkey;
        this.accessToken = token;
    }

    public void process(String fileName, String format, int sampleRate,
                        boolean enablePunctuationPrediction,
                        boolean enableInverseTextNormalization,
                        boolean enableVoiceDetection) {

        /**
         * 設置HTTPS RESTful POST請求：
         * 1.使用HTTPS協議。
         * 2.語音識別服務域名：nls-gateway-cn-shanghai.aliyuncs.com。
         * 3.語音識別接口請求路徑：/stream/v1/asr。
         * 4.設置必選請求參數：appkey、format、sample_rate。
         * 5.設置可選請求參數：enable_punctuation_prediction、enable_inverse_text_normalization、enable_voice_detection。
         */
        String url = "https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr";
        String request = url;
        request = request + "?appkey=" + appkey;
        request = request + "&format=" + format;
        request = request + "&sample_rate=" + sampleRate;
        if (enablePunctuationPrediction) {
            request = request + "&enable_punctuation_prediction=" + true;
        }
        if (enableInverseTextNormalization) {
            request = request + "&enable_inverse_text_normalization=" + true;
        }
        if (enableVoiceDetection) {
            request = request + "&enable_voice_detection=" + true;
        }

        System.out.println("Request: " + request);

        /**
         * 設置HTTPS頭部字段：
         * 1.鑒權參數。
         * 2.Content-Type：application/octet-stream。
         */
        HashMap<String, String> headers = new HashMap<String, String>();
        headers.put("X-NLS-Token", this.accessToken);
        headers.put("Content-Type", "application/octet-stream");

        /**
         * 發送HTTPS POST請求，返回服務端的響應。
         */
        String response = HttpUtil.sendPostFile(request, headers, fileName);

        if (response != null) {
            System.out.println("Response: " + response);
            String result = JSONPath.read(response, "result").toString();
            System.out.println("識別結果：" + result);
        }
        else {
            System.err.println("識別失敗!");
        }

    }

    public static void main(String[] args) {
        if (args.length < 2) {
            System.err.println("SpeechRecognizerRESTfulDemo need params: <token> <app-key>");
            System.exit(-1);
        }

        String token = args[0];
        String appkey = args[1];

        SpeechRecognizerRESTfulDemo demo = new SpeechRecognizerRESTfulDemo(appkey, token);

        String fileName = SpeechRecognizerRESTfulDemo.class.getClassLoader().getResource("./nls-sample-16k.wav").getPath();
        String format = "pcm";
        int sampleRate = 16000;
        boolean enablePunctuationPrediction = true;
        boolean enableInverseTextNormalization = true;
        boolean enableVoiceDetection = false;

        demo.process(fileName, format, sampleRate, enablePunctuationPrediction, enableInverseTextNormalization, enableVoiceDetection);
    }
}

其中，HttpUtils類如下：

import okhttp3.*;
import java.io.File;
import java.io.IOException;
import java.net.SocketTimeoutException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class HttpUtil {

    private static String getResponseWithTimeout(Request q) {
        String ret = null;

        OkHttpClient.Builder httpBuilder = new OkHttpClient.Builder();
        OkHttpClient client = httpBuilder.connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(60, TimeUnit.SECONDS)
                .writeTimeout(60, TimeUnit.SECONDS)
                .build();

        try {
            Response s = client.newCall(q).execute();
            ret = s.body().string();
            s.close();
        } catch (SocketTimeoutException e) {
            ret = null;
            System.err.println("get result timeout");
        } catch (IOException e) {
            System.err.println("get result error " + e.getMessage());
        }

        return ret;
    }

    public static String sendPostFile(String url, HashMap<String, String> headers, String fileName) {
        RequestBody body;

        File file = new File(fileName);
        if (!file.isFile()) {
            System.err.println("The filePath is not a file: " + fileName);
            return null;
        } else {
            body = RequestBody.create(MediaType.parse("application/octet-stream"), file);
        }

        Headers.Builder hb = new Headers.Builder();
        if (headers != null && !headers.isEmpty()) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                hb.add(entry.getKey(), entry.getValue());
            }
        }

        Request request = new Request.Builder()
                .url(url)
                .headers(hb.build())
                .post(body)
                .build();

        return getResponseWithTimeout(request);
    }

    public static String sendPostData(String url, HashMap<String, String> headers, byte[] data) {
        RequestBody body;

        if (data.length == 0) {
            System.err.println("The send data is empty.");
            return null;
        } else {
            body = RequestBody.create(MediaType.parse("application/octet-stream"), data);
        }

        Headers.Builder hb = new Headers.Builder();
        if (headers != null && !headers.isEmpty()) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                hb.add(entry.getKey(), entry.getValue());
            }
        }

        Request request = new Request.Builder()
                .url(url)
                .headers(hb.build())
                .post(body)
                .build();

        return getResponseWithTimeout(request);
    }
}

C++示例

C++示例使用第三方函數庫curl處理HTTPS請求和響應。下載curl庫和Demo文件。

目錄說明如下所示。

編譯運行操作步驟：

假設示例文件已解壓至path/to路徑下，在Linux終端依次執行如下命令編譯運行程序。

• 支持Cmake：

  1. 確認本地系統已安裝Cmake 2.4及以上版本。

  2. cd path/to/sdk/lib。

  3. tar -zxvpf linux.tar.gz。

  4. cd path/to/sdk。

  5. ./build.sh。

  6. cd path/to/sdk/demo。

  7. ./restfulAsrDemo <your-token> <your-appkey>。

• 不支持Cmake：

  1. cd path/to/sdk/lib。

  2. tar -zxvpf linux.tar.gz。

  3. cd path/to/sdk/demo。

  4. g++ -o restfulAsrDemo restfulAsrDemo.cpp -I path/to/sdk/include -L path/to/sdk/lib/linux -lssl -lcrypto -lcurl -D_GLIBCXX_USE_CXX11_ABI=0。

  5. export LD_LIBRARY_PATH=path/to/sdk/lib/linux/。

  6. ./restfulAsrDemo <your-token> <your-appkey>。

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include "curl/curl.h"

using namespace std;

#ifdef _WIN32
string UTF8ToGBK(const string& strUTF8) {
    int len = MultiByteToWideChar(CP_UTF8, 0, strUTF8.c_str(), -1, NULL, 0);
    unsigned short * wszGBK = new unsigned short[len + 1];
    memset(wszGBK, 0, len * 2 + 2);

    MultiByteToWideChar(CP_UTF8, 0, (char*)strUTF8.c_str(), -1, (wchar_t*)wszGBK, len);

    len = WideCharToMultiByte(CP_ACP, 0, (wchar_t*)wszGBK, -1, NULL, 0, NULL, NULL);

    char *szGBK = new char[len + 1];
    memset(szGBK, 0, len + 1);
    WideCharToMultiByte(CP_ACP, 0, (wchar_t*)wszGBK, -1, szGBK, len, NULL, NULL);

    string strTemp(szGBK);
    delete[] szGBK;
    delete[] wszGBK;

    return strTemp;
}

#endif

/**
 * 一句話識別RESTful API HTTPS請求的響應回調函數
 * 識別結果為JSON格式的字符串
 */
size_t responseCallback(void* ptr, size_t size, size_t nmemb, void* userData) {
    string* srResult = (string*)userData;

    size_t len = size * nmemb;
    char *pBuf = (char*)ptr;
    string response = string(pBuf, pBuf + len);
#ifdef _WIN32
    response = UTF8ToGBK(response);
#endif
    cout << "current result: " << response << endl;

    *srResult += response;
    cout << "total result: " << *srResult << endl;

    return len;
}

int sendAsrRequest(const char* request, const char* token, const char* fileName, string* srResult) {
    CURL* curl = NULL;
    CURLcode res;

    /**
    * 讀取音頻文件
    */
    ifstream fs;
    fs.open(fileName, ios::out | ios::binary);
    if (!fs.is_open()) {
        cerr << "The audio file is not exist!" << endl;
        return -1;
    }
    stringstream buffer;
    buffer << fs.rdbuf();
    string audioData(buffer.str());

    curl = curl_easy_init();
    if (curl == NULL) {
        return -1;
    }

    /**
    * 設置HTTPS請求行
    */
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
    curl_easy_setopt(curl, CURLOPT_URL, request);

    /**
    * 設置HTTPS請求頭部
    */
    struct curl_slist* headers = NULL;
    // token
    string X_NLS_Token = "X-NLS-Token:";
    X_NLS_Token += token;
    headers = curl_slist_append(headers, X_NLS_Token.c_str());
    // Content-Type
    headers = curl_slist_append(headers, "Content-Type:application/octet-stream");
    // Content-Length
    string content_Length = "Content-Length:";
    ostringstream oss;
    oss << content_Length << audioData.length();
    content_Length = oss.str();
    headers = curl_slist_append(headers, content_Length.c_str());

    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

    /**
    * 設置HTTPS請求數據
    */
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, audioData.c_str());
    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, audioData.length());

    /**
    * 設置HTTPS請求的響應回調函數
    */
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, responseCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, srResult);

    /**
    * 發送HTTPS請求
    */
    res = curl_easy_perform(curl);

    // 釋放資源
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);

    if (res != CURLE_OK) {
        cerr << "curl_easy_perform failed: " << curl_easy_strerror(res) << endl;
        return -1;
    }

    return 0;
}

int process(const char* request, const char* token, const char* fileName) {
    // 全局只初始化一次
    curl_global_init(CURL_GLOBAL_ALL);

    string srResult = "";
    int ret = sendAsrRequest(request, token, fileName, &srResult);

    curl_global_cleanup();

    return ret;
}

int main(int argc, char* argv[]) {
    if (argc < 3) {
        cerr << "params is not valid. Usage: ./demo your_token your_appkey" << endl;
        return -1;
    }

    string token = argv[1];
    string appKey = argv[2];

    string url = "https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr";
    string format = "pcm";
    int sampleRate = 16000;
    bool enablePunctuationPrediction = true;
    bool enableInverseTextNormalization = true;
    bool enableVoiceDetection = false;
    string fileName = "sample.pcm";

    /**
    * 設置RESTful請求參數
    */
    ostringstream oss;
    oss << url;
    oss << "?appkey=" << appKey;
    oss << "&format=" << format;
    oss << "&sample_rate=" << sampleRate;
    if (enablePunctuationPrediction) {
        oss << "&enable_punctuation_prediction=" << "true";
    }
    if (enableInverseTextNormalization) {
        oss << "&enable_inverse_text_normalization=" << "true";
    }
    if (enableVoiceDetection) {
        oss << "&enable_voice_detection=" << "true";
    }

    string request = oss.str();
    cout << "request: " << request << endl;

    process(request.c_str(), token.c_str(), fileName.c_str());

    return 0;
}

Python示例

如果使用內網訪問URL，請使用HTTP協議，需要替換如下函數，將HTTPSConnection修改為HTTPConnection：
 # Python 2.x 請使用httplib
 # conn = httplib.HTTPConnection(host)
 # Python 3.x 請使用http.client
 conn = http.client.HTTPConnection(host)

# -*- coding: UTF-8 -*-
# Python 2.x引入httplib模塊
# import httplib
# Python 3.x引入http.client模塊
import http.client

import json

def process(request, token, audioFile) :

    # 讀取音頻文件
    with open(audioFile, mode = 'rb') as f:
        audioContent = f.read()

    host = 'nls-gateway-cn-shanghai.aliyuncs.com'

    # 設置HTTPS請求頭部
    httpHeaders = {
        'X-NLS-Token': token,
        'Content-type': 'application/octet-stream',
        'Content-Length': len(audioContent)
        }

    # Python 2.x使用httplib
    # conn = httplib.HTTPSConnection(host)
    
    # Python 3.x使用http.client
    conn = http.client.HTTPSConnection(host)

    conn.request(method='POST', url=request, body=audioContent, headers=httpHeaders)

    response = conn.getresponse()
    print('Response status and response reason:')
    print(response.status ,response.reason)

    body = response.read()
    try:
        print('Recognize response is:')
        body = json.loads(body)
        print(body)

        status = body['status']
        if status == 20000000 :
            result = body['result']
            print('Recognize result: ' + result)
        else :
            print('Recognizer failed!')

    except ValueError:
        print('The response is not json format string')

    conn.close()



appKey = '填入appkey'
token = '填入服務鑒權Token'

# 服務請求地址
url = 'https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr'

# 音頻文件
audioFile = '/path/to/nls-sample-16k.wav'
format = 'pcm'
sampleRate = 16000
enablePunctuationPrediction  = True
enableInverseTextNormalization = True
enableVoiceDetection  = False

# 設置RESTful請求參數
request = url + '?appkey=' + appKey
request = request + '&format=' + format
request = request + '&sample_rate=' + str(sampleRate)

if enablePunctuationPrediction :
    request = request + '&enable_punctuation_prediction=' + 'true'

if enableInverseTextNormalization :
    request = request + '&enable_inverse_text_normalization=' + 'true'

if enableVoiceDetection :
    request = request + '&enable_voice_detection=' + 'true'

print('Request: ' + request)


process(request, token, audioFile)

PHP示例

<?php

function process($token, $request, $audioFile) {
    /**
     * 讀取音頻文件
     */
    $audioContent = file_get_contents($audioFile);
    if ($audioContent == FALSE) {
        print "The audio file is not exist!\n";
        return;
    }

    $curl = curl_init();
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($curl, CURLOPT_TIMEOUT, 120);

    /**
     * 設置HTTPS請求行
     */
    curl_setopt($curl, CURLOPT_URL, $request);
    curl_setopt($curl, CURLOPT_POST,TRUE);

    /**
     * 設置HTTPS請求頭部
     */
    $contentType = "application/octet-stream";
    $contentLength = strlen($audioContent);
    $headers = array(
        "X-NLS-Token:" . $token,
        "Content-type:" . $contentType,
        "Content-Length:" . strval($contentLength)
    );
    curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);

    /**
     * 設置HTTPS請求數據
     */
    curl_setopt($curl, CURLOPT_POSTFIELDS, $audioContent);
    curl_setopt($curl, CURLOPT_NOBODY, FALSE);

    /**
     * 發送HTTPS請求
     */
    $returnData = curl_exec($curl);

    curl_close($curl);

    if ($returnData == FALSE) {
        print "curl_exec failed!\n";
        return;
    }

    print $returnData . "\n";

    $resultArr = json_decode($returnData, true);

    $status = $resultArr["status"];
    if ($status == 20000000) {
        $result = $resultArr["result"];
        print "The audio file recognized result: " . $result . "\n";
    }
    else {
        print "The audio file recognized failed.\n";
    }

}


$appkey = "填入appkey";
$token = "填入服務鑒權Token";

$url = "https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr";
$audioFile = "/path/to/nls-sample-16k.wav";
$format = "pcm";
$sampleRate = 16000;
$enablePunctuationPrediction = TRUE;
$enableInverseTextNormalization = TRUE;
$enableVoiceDetection = FALSE;

/**
 * 設置RESTful請求參數
 */
$request = $url;
$request = $request . "?appkey=" . $appkey;
$request = $request . "&format=" . $format;
$request = $request . "&sample_rate=" . strval($sampleRate);
if ($enablePunctuationPrediction) {
    $request = $request . "&enable_punctuation_prediction=" . "true";
}
if ($enableInverseTextNormalization) {
    $request = $request . "&enable_inverse_text_normalization=" . "true";
}
if ($enableVoiceDetection) {
    $request = $request . "&enable_voice_detection=" . "true";
}

print "Request: " . $request . "\n";

process($token, $request, $audioFile);

?>

Node.js示例

const request = require('request');
const fs = require('fs');


function callback(error, response, body) {
        if (error != null) {
                console.log(error);
        }
        else {
                console.log('The audio file recognized result:');
                console.log(body);
                if (response.statusCode == 200) {
                        body = JSON.parse(body);
                        if (body.status == 20000000) {
                                console.log('result: ' + body.result);
                                console.log('The audio file recognized succeed!');
                        } else {
                                console.log('The audio file recognized failed!');
                        }
                } else {
                        console.log('The audio file recognized failed, http code: ' + response.statusCode);
                }
        }
}

function process(requestUrl, token, audioFile) {
        /**
         * 讀取音頻文件
        */
        var audioContent = null;
        try {
                audioContent = fs.readFileSync(audioFile);
        } catch(error) {
                if (error.code == 'ENOENT') {
                        console.log('The audio file is not exist!');
                }
                return;
        }

        /**
         * 設置HTTPS請求頭部
        */
        var httpHeaders = {
                'X-NLS-Token': token,
                'Content-type': 'application/octet-stream',
                'Content-Length': audioContent.length
        };

        var options = {
                url: requestUrl,
                method: 'POST',
                headers: httpHeaders,
                body: audioContent
        };

        request(options, callback);
}


var appkey = '填入appkey';
var token = '填入服務鑒權Token';

var url = 'https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr';
var audioFile = '/path/to/nls-sample-16k.wav';
var format = 'pcm';
var sampleRate = '16000';
var enablePunctuationPrediction = true;
var enableInverseTextNormalization = true;
var enableVoiceDetection  = false;

/**
 * 設置RESTful請求參數
 */
var requestUrl = url;
requestUrl = requestUrl + '?appkey=' + appkey;
requestUrl = requestUrl + '&format=' + format;
requestUrl = requestUrl + '&sample_rate=' + sampleRate;
if (enablePunctuationPrediction) {
        requestUrl = requestUrl + '&enable_punctuation_prediction=' + 'true';
}
if (enableInverseTextNormalization) {
        requestUrl = requestUrl + '&enable_inverse_text_normalization=' + 'true';
}
if (enableVoiceDetection) {
        requestUrl = requestUrl + '&enable_voice_detection=' + 'true';
}

process(requestUrl, token, audioFile);

.Net示例

using System;
using System.Net.Http;
using System.IO;
using Newtonsoft.Json.Linq;

namespace RESTfulAPI
{
    class SpeechRecognizerRESTfulDemo
    {
        private string token;
        private string appkey;

        public SpeechRecognizerRESTfulDemo(string appkey, string token)
        {
            this.appkey = appkey;
            this.token = token;
        }

        public void process(string fileName, string format, int sampleRate,
            bool enablePunctuationPrediction,
            bool enableInverseTextNormalization,
            bool enableVoiceDetection)
        {
            /**
             * 設置HTTPS REST POST請求
             * 1.使用HTTPS協議
             * 2.語音識別服務域名：nls-gateway-cn-shanghai.aliyuncs.com
             * 3.語音識別接口請求路徑：/stream/v1/asr
             * 4.設置必選請求參數：appkey、format、sample_rate，
             * 5.設置可選請求參數：enable_punctuation_prediction、enable_inverse_text_normalization、enable_voice_detection
             */
            string url = "https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr";
            url = url + "?appkey=" + appkey;
            url = url + "&format=" + format;
            url = url + "&sample_rate=" + sampleRate;
            if (enablePunctuationPrediction)
            {
                url = url + "&enable_punctuation_prediction=" + true;
            }
            if (enableInverseTextNormalization)
            {
                url = url + "&enable_inverse_text_normalization=" + true;
            }
            if (enableVoiceDetection)
            {
                url = url + "&enable_voice_detection=" + true;
            }

            System.Console.WriteLine("URL: " + url);


            HttpClient client = new HttpClient();
            /**
             * 設置HTTPS頭部字段
             * 鑒權參數
             */
            client.DefaultRequestHeaders.Add("X-NLS-Token", token);
            if (!File.Exists(fileName))
            {
                System.Console.WriteLine("The audio file dose not exist");
                return;
            }
            byte[] audioData = File.ReadAllBytes(fileName);

            /**
             * 設置HTTPS Body
             * 音頻二進制數據
             * Content-Type：application/octet-stream
             */
            ByteArrayContent content = new ByteArrayContent(audioData);
            content.Headers.Add("Content-Type", "application/octet-stream");

            /**
             * 發送HTTPS POST請求，處理服務端的響應。
             */
            HttpResponseMessage response = client.PostAsync(url, content).Result;

            string responseBodyAsText = response.Content.ReadAsStringAsync().Result;
            System.Console.WriteLine("Response: " + responseBodyAsText);

            if (response.IsSuccessStatusCode)
            {
                JObject obj = JObject.Parse(responseBodyAsText);
                string result = obj["result"].ToString();
                System.Console.WriteLine("識別結果： " + result);
            }
            else
            {
                System.Console.WriteLine("Response status code and reason phrase: " +
                    response.StatusCode + " " + response.ReasonPhrase);
                System.Console.WriteLine("識別失敗！");
            }

        }

        static void Main(string[] args)
        {
            if (args.Length < 2)
            {
                System.Console.WriteLine("SpeechRecognizerRESTfulDemo need params: <token> <app-key>");
                return;
            }

            string token = args[0];
            string appkey = args[1];

            SpeechRecognizerRESTfulDemo demo = new SpeechRecognizerRESTfulDemo(appkey, token);

            string fileName = "nls-sample-16k.wav";
            string format = "pcm";
            int sampleRate = 16000;
            bool enablePunctuationPrediction = true;
            bool enableInverseTextNormalization = true;
            bool enableVoiceDetection = false;

            demo.process(fileName, format, sampleRate,
                enablePunctuationPrediction, enableInverseTextNormalization, enableVoiceDetection);

        }
    }
}

GO示例

package main

import (
    "fmt"
        "encoding/json"
        "net/http"
        "io/ioutil"
        "strconv"
        "bytes"
)

func process(appkey string, token string, fileName string, format string, sampleRate int,
             enablePunctuationPrediction bool, enableInverseTextNormalization bool, enableVoiceDetection bool) {
                         
    /**
     * 設置HTTPS REST POST請求：
     * 1.使用HTTPS協議
     * 2.語音識別服務域名：nls-gateway-cn-shanghai.aliyuncs.com
     * 3.語音識別接口請求路徑：/stream/v1/asr
     * 4.設置必選請求參數：appkey、format、sample_rate，
     * 5.設置可選請求參數：enable_punctuation_prediction、enable_inverse_text_normalization、enable_voice_detection
     */                 
        var url string = "https://nls-gateway-cn-shanghai.aliyuncs.com/stream/v1/asr"
        url = url + "?appkey=" + appkey
        url = url + "&format=" + format
        url = url + "&sample_rate=" + strconv.Itoa(sampleRate)
        if (enablePunctuationPrediction) {
            url = url + "&enable_punctuation_prediction=" + "true"
        }
        if (enableInverseTextNormalization) {
            url = url + "&enable_inverse_text_normalization=" + "true"
        }
        if (enableVoiceDetection) {
            url = url + "&enable_voice_detection=" + "false"
        }

    fmt.Println(url)
        
        /**
         * 讀取音頻數據，作為HTTPS請求體。
         。*/
        audioData, err := ioutil.ReadFile(fileName)
        if err != nil {
            panic(err)
        }
        
        request, err := http.NewRequest("POST", url, bytes.NewBuffer(audioData))
        if err != nil {
            panic(err)
        }
        
        /**
     * 設置HTTPS頭部字段：
     * 1.鑒權參數。
     * 2.Content-Type：application/octet-stream。
     */
        request.Header.Add("X-NLS-Token", token)
        request.Header.Add("Content-Type", "application/octet-stream")
        
        /**
     * 發送HTTPS POST請求，處理服務端的響應。
     */
        client := &http.Client{}
        response, err := client.Do(request)
        if err != nil {
            panic(err)
        }
        
        defer response.Body.Close()
        
        body, _ := ioutil.ReadAll(response.Body)
        fmt.Println(string(body))
        
        statusCode := response.StatusCode
        if (statusCode == 200) {
            var resultMap map[string]interface{}
            err = json.Unmarshal([]byte(body), &resultMap)
            if err != nil {
                panic(err)
            }
        
            var result string = resultMap["result"].(string)
            fmt.Println("識別成功：" + result)
        } else {
            fmt.Println("識別失敗，HTTP StatusCode: " + strconv.Itoa(statusCode))
        }
        
}

func main() {

    var appkey string = "填入appkey"
        var token  string = "填入token"
        
        var fileName string = "nls-sample-16k.wav"
        var format string = "pcm"
        var sampleRate int = 16000
        var enablePunctuationPrediction bool = true
        var enableInverseTextNormalization bool = true
        var enableVoiceDetection = false
        
        process(appkey, token, fileName, format, sampleRate, enablePunctuationPrediction, enableInverseTextNormalization, enableVoiceDetection)
        

}