帮助与文档 > 产品文档 > 语音识别ASR > API 文档

有道智云语音识别 API 说明文档

有道智云短语音识别 API 简介

有道短语音识别API接口提供有道的短语音识别服务,包含了中文和英文的识别功能。您只需要通过调用有道语音识别API,传入待识别的音频文件,并指定要识别的源语言种类,以POST方式请求就可以得到相应的识别结果。

上传的文件时长不能超过15s,文件大小不能超过2M。

有道语音识别API HTTP地址:

http://openapi.youdao.com/asrapi

有道语音识别API HTTPS地址:

https://openapi.youdao.com/asrapi

接口调用参数

调用API需要向接口发送以下字段来访问服务。

字段名类型含义必填备注
qtext要识别的音频文件的base64编码字符串True必须是Base64编码
langTypetext源语言True语言列表
appKeytext应用 IDTrue可在 应用管理 查看
salttext随机数True
signtext签名,通过md5(appKey+q+salt+密钥)生成TrueappKey+q+salt+密钥的MD5值
formattext语音文件的格式,wavtruewav
ratetext采样率, 8000 或者 16000, 推荐 16000 采用率true8000
channeltext声道数, 仅支持单声道,请填写固定值1true1
typetext上传类型, 仅支持base64上传,请填写固定值1true1

签名生成方法如下:

  1. 将请求参数中的 appKey,识别文本 q (注意为UTF-8编码),随机数 salt密钥 (可在 应用管理 查看), 按照 appKey+q+salt+密钥 的顺序拼接得到字符串 str
  2. 对字符串 str 做md5,得到32位大写的 sign (参考Java生成MD5示例)

注意:

  1. 请先将需要识别的音频文件转换为 Base64 编码
  2. 在发送 HTTP 请求之前需要对各字段做 URL encode。
  3. 在生成签名拼接 appKey+q+salt+密钥 字符串时,q 不需要做 URL encode,在生成签名之后,发送 HTTP 请求之前才需要对要发送的待识别文本字段 q 做 URL encode。

输出结果

响应结果是以json形式输出,包含字段如下表所示:

字段含义
errorCode识别结果错误码,一定存在
result识别结果,识别成功一定存在

示例

{
    "result": [
        "今天天气不错"
    ],    //识别结果
    "errorCode": "0",    //错误码。一定存在
}

支持的语言表

支持中文和英文音频的识别。

语言代码
中文zh-CHS
英文en

语音支持

格式支持:wav(不压缩、pcm编码)

采样率:8k或者16k。推荐16k。

编码:16bit位深的单声道

格式代码
wavwav

错误代码列表

错误码含义
101缺少必填的参数
102不支持的语言类型
103请求文本过长
104不支持的API类型
105不支持的签名类型
106不支持的响应类型
107不支持的传输加密类型
108appKey无效
109batchLog格式不正确
110无相关服务的有效实例
111用户无效
112请求服务无效
113请求文本不能为空
201解密失败
202签名检验失败
203访问IP地址不在可访问IP列表
205使用的接入方式(Android SDK、iOS SDK、API)与创建的应用平台类型不一致
301词典查询失败
302小语种识别失败
303服务的异常
401账户已经欠费停止
402offlinesdk不可用
411访问频率受限,请稍后访问
412超过最大请求字符数
4001不支持的语音识别格式
4002不支持的语音识别采样率
4003不支持的语音识别声道
4004不支持的语音上传类型
4005不支持的语言类型
4006识别音频文件过大
4007识别音频时长过长
4201解密失败
4301语音识别失败
4303服务的异常
4411访问频率受限,请稍后访问
4412超过最大请求时长

常见问题及注意事项

  • 返回110

应用没有绑定服务实例,可以新建服务实例,绑定服务实例。

  • 返回108

appKey无效,注册账号, 登录后台创建应用和实例并完成绑定, 可获得应用ID和密钥等信息,其中应用ID就是appKey( 注意不是应用密钥)

  • 返回101

首先确保必填参数齐全,然后,确认参数书写是否正确。

  • 返回202

如果确认 appKeyappSecret 的正确性,仍返回202,一般是编码问题。请确保 q 为UTF-8编码.

  • 返回205

确保接入方式(Android SDK、IOS SDK、API)与创建的应用平台类型一致。

音频转换

本部分描述如何把其他格式的音频转成符合语音识别输入要求的格式文件。

语音识别底层使用的是pcm格式,因此推荐使用pcm格式音频。音频格式转换推荐使用ffmpeg

ffmpeg简介

ffmpeg是一个自由软件,可以运行音频、视频多种格式的录影、转换、流功能,包含libavcodec--这是一个用于多个项目中的音频、视频的解码器库,以及libavformat--一个音频和视频格式转换库。

ffmpeg官网:https://www.ffmpeg.org/

ffmpeg的github地址:https://github.com/FFmpeg/FFmpeg

ffmpeg编译参数

ffmpeg默认支持pcm与wav(pcm编码)格式,额外的编译参数如下:

—enable-libopencore-amrnb 支持amr-nb(8000 采样率) 读写

—enable-libopencore-amrwb 支持amr-wb(16000 采样率) 读取

—enable-libvo-amrwbenc 支持amr-wb(16000 采样率) 写入

—enable-libmp3lame 支持mp3 写入

ffmpeg -codecs 可以查看所有的格式:

D..... = Decoding supported  # 读取
.E.... = Encoding supported  # 写入
..A... = Audio codec      # 音频编码
....L. = Lossy compression # 有损
.....S = Lossless compression # 无损
DEA..S pcm_s16le            PCM signed 16-bit little-endian
DEA.LS wavpack              WavPack
DEA.L. mp3  MP3 (MPEG audio layer 3)
DEA.L. amr_nb       AMR-NB (Adaptive Multi-Rate NarrowBand)
DEA.L. amr_wb       AMR-WB (Adaptive Multi-Rate WideBand)

主要参数

-i 设定输入流

-f 设定格式

-ss 开始时间

wav、mp3、amr格式都自带头部,包含采样率、编码、多声道等信息。而pcm为原始音频信息,没有头部信息。wav(pcm编码)就是pcm文件加了wav的头部信息。

输入wav、mp3、amr:

-i audio.wav/audio.mp3/audio.amr

输入pcm格式:pcm需要额外告知编码格式,采样率,单声道信息

-f s16le -ac 1 -ar 16000 -i 16k.pcm    //单声道、16000采样率、16bits编码的pcm文件

音频参数

-ar 设定采样率

-ac 设定声音的channel数

-acodec 设定声音编解码器,未设定时则使用与输入流相同的编解码器

-an 不处理音频

-ab 设置比特率(单位:bit/s,也许老版是kb/s),前面ac设置为立体声时要以一半的比特率来设置,比如192kbps的就设置为96,转换默认比特率都较小,转换默认比特率都较小,要听到高品质声音的话建议设到160kbps(80)以上。

在原始采样率 大于或者接近16000的时候,推荐使用16000,8000采样率会降低识别效果。

输出wav和amr时,如果没有指定声音编解码器,则会选择默认的编码器。

输出pcm:

-f s16le -ac 1 -ar 16000 16k.pcm  // 单声道 16000 采样率 16bits编码 pcm文件

输出wav:

-ar 1 -ar 16000 16k.wav //单声道 16000 采样率 16bits编码 pcm编码的wav文件

amr-nb:全称是:Adaptive Multi-Rate,自适应多速率,是一种音频编码文件格式,专用于有效地压缩语音频率。amr-nb格式只能选 8000采样率。bit rates越高音质越好,但是文件越大

bit rates 4.75k, 5.15k, 5.9k, 6.7k, 7.4k, 7.95k, 10.2k or 12.2k

输出 amr-wb 格式,采样率 16000。 bit rates越高音质越好,但是文件越大。

6600 8850 12650 14250 15850 18250 19850 23050 23850

常用参数

-y 覆盖同名文件

-v 日志输出 基本如-v ERROR -v quiet等

转换命令示例

ffmpeg {常用参数} {输入音频参数} {输出音频参数}

wav 文件转 16k 16bits 位深的单声道pcm文件

ffmpeg -y  -i 16k.wav  -acodec pcm_s16le -f s16le -ac 1 -ar 16000 16k.pcm

pcm文件转wav:

ffmpeg -y -f s16le -ar 16000 -ac 1 -acodec pcm_s16le 16k.pcm 16k.wav

m4a文件转16k 16bits 位深的单声道pcm文件

D:\ffmpeg\bin>ffmpeg -y -i test.m4a -acodec pcm_s16le -f s16le -ac 1 -ar 1600
0 16k.pcm

PCM文件音频介绍

pcm保存的是未压缩的音频信息,没有头文件

16bits编码是指每次采样信息用2个字节保存。

16000采样率,是指1秒采样16000次,常见的音频是44100HZ,即一秒采样44100次。

单声道: 只有一个声道。

根据这些信息,可以得出:

1ms的16采样率音频文件大小是 2*16 = 32字节 。

1ms的8采样率音频文件大小是 2*8 = 16字节,由此即可得到音频的长度。

常用语言 Demo

Java 示例
Python 示例
C# 示例
PHP 示例
package outfox.ead.openapi;

import org.apache.http.HttpEntity;
import org.apache.http.HttpVersion;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import outfox.ead.openapi.util.EnDeCriptUtil;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
* Created by liyang_ly on 2018/2/6.
*/
public class AsrDemoForHttp {
    static Logger logger = LoggerFactory.getLogger(OCRDemo.class);
    public static String GetImageStr(String imgFile)
    {//将图片文件转化为字节数组字符串,并对其进行Base64编码处理
        InputStream in = null;
        byte[] data = null;
        //读取图片字节数组
        try
        {
            in = new FileInputStream(imgFile);
            data = new byte[in.available()];
            in.read(data);
            in.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        //对字节数组Base64编码
        return EnDeCriptUtil.base64Encode(data);//返回Base64编码过的字节数组字符串
    }
    public static void main(String[] args) throws Exception {
        Map<String, String> map = new HashMap<String, String>();
        String apiUrl = "http://openapi.youdao.com/asrapi";
        map.put("appKey", "您的应用ID");
        String q = GetImageStr("D:/16k.wav");
        map.put("q",q);
        map.put("format", "wav");
        map.put("rate", "16000");
        map.put("channel", "1");
        map.put("type", "1");
        map.put("pkn", "adb");
        map.put("salt", "123");
        map.put("langType", "zh-CHS");
        String sign = md5(map.get("appKey")+map.get("q")+map.get("salt")+"您的应用密钥");
        map.put("sign", sign);
        map.put("docType", "json");

        String result = requestOCRForHttp(apiUrl, map);
        System.out.println(result);
    }
    public static String requestOCR(String url,String s,int et) throws Exception{
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        /**HttpPost*/
        HttpPost httpPost = new HttpPost(url);
        httpPost.setProtocolVersion(HttpVersion.HTTP_1_0);
        httpPost.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE);
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        params.add(new BasicNameValuePair("s", s));
        params.add(new BasicNameValuePair("et", String.valueOf(et)));
        httpPost.setEntity(new UrlEncodedFormEntity(params,"UTF-8"));
        /**HttpResponse*/
        CloseableHttpResponse httpResponse = httpClient.execute(httpPost);
        try{
            HttpEntity httpEntity = httpResponse.getEntity();
            result = EntityUtils.toString(httpEntity, "utf-8");
            EntityUtils.consume(httpEntity);
        }finally{
            try{
                if(httpResponse!=null){
                    httpResponse.close();
                }
            }catch(IOException e){
                logger.info("## release resouce error ##" + e);
            }
        }
        return result;
    }

    public static String requestOCRForHttp(String url,Map<String,String> requestParams) throws Exception{
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        /**HttpPost*/
        HttpPost httpPost = new HttpPost(url);
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        System.out.println(requestParams.keySet().size());
        for(String key:requestParams.keySet()){
            if(!"q".equals(key))
            System.out.println(key+":"+requestParams.get(key));
            params.add(new BasicNameValuePair(key, requestParams.get(key)));
        }
        httpPost.setEntity(new UrlEncodedFormEntity(params,"UTF-8"));
        /**HttpResponse*/
        CloseableHttpResponse httpResponse = httpClient.execute(httpPost);
        try{
            HttpEntity httpEntity = httpResponse.getEntity();
            result = EntityUtils.toString(httpEntity, "utf-8");
            EntityUtils.consume(httpEntity);
        }finally{
            try{
                if(httpResponse!=null){
                    httpResponse.close();
                }
            }catch(IOException e){
                logger.info("## release resouce error ##" + e);
            }
        }
        return result;
    }
    /**
    * 生成32位MD5摘要
    * @param string
    * @return
    */
    public static String md5(String string) {
        if(string == null){
            return null;
        }
        char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        'A', 'B', 'C', 'D', 'E', 'F'};
        byte[] btInput = string.getBytes();
        try{
            /** 获得MD5摘要算法的 MessageDigest 对象 */
            MessageDigest mdInst = MessageDigest.getInstance("MD5");
            /** 使用指定的字节更新摘要 */
            mdInst.update(btInput);
            /** 获得密文 */
            byte[] md = mdInst.digest();
            /** 把密文转换成十六进制的字符串形式 */
            int j = md.length;
            char str[] = new char[j * 2];
            int k = 0;
            for (byte byte0 : md) {
                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                str[k++] = hexDigits[byte0 & 0xf];
            }
            return new String(str);
        }catch(NoSuchAlgorithmException e){
            return null;
        }
    }

    /**
    * 根据api地址和参数生成请求URL
    * @param url
    * @param params
    * @return
    */
    public static String getUrlWithQueryString(String url, Map<String, String> params) {
        if (params == null) {
            return url;
        }

        StringBuilder builder = new StringBuilder(url);
        if (url.contains("?")) {
            builder.append("&");
        } else {
            builder.append("?");
        }

        int i = 0;
        for (String key : params.keySet()) {
            String value = params.get(key);
            if (value == null) { // 过滤空的key
                continue;
            }

            if (i != 0) {
                builder.append('&');
            }

            builder.append(key);
            builder.append('=');
            builder.append(encode(value));

            i++;
        }

        return builder.toString();
    }
    /**
    * 进行URL编码
    * @param input
    * @return
    */
    public static String encode(String input) {
        if (input == null) {
            return "";
        }

        try {
            return URLEncoder.encode(input, "utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        return input;
    }
}
# -*- coding: utf-8 -*-
import requests
import md5
import random
import wave
import base64
import sys

reload(sys)
sys.setdefaultencoding('utf-8')
asrUrl = "http://openapi.youdao.com/asrapi"
appKey = "您的应用ID"
appSecret = "您的应用密钥"

def asr(app_key, q ,app_secret ,lang,channel,rate,format):
    data = {}
    salt = random.randint(1, 65536)

    sign = app_key + q + str(salt) + app_secret
    m1 = md5.new()
    m1.update(sign)
    sign = m1.hexdigest()

    data['appKey'] = app_key
    data['q'] = q
    data['salt'] = salt
    data['sign'] = sign
    data['langType'] = lang
    data['channel'] = channel
    data['rate'] = rate
    data['format'] = format
    data['type'] = 1
    headers = {"Content-Type": "application/x-www-form-urlencoded"}
    response = requests.post(asrUrl,data=data,headers = headers)
    return response


filename = 'd:/en.wav'
extension = filename[filename.rindex('.')+1:]
if extension == "wav" :
    # load wav
    file_to_play = wave.open(filename, 'rb')
    file_wav = open(r'd:\en.wav', 'rb')
    q = base64.b64encode(file_wav.read())
    file_wav.close()
    sample_width = file_to_play.getsampwidth()
    sample_rate = file_to_play.getframerate()
    nchannels = file_to_play.getnchannels()
    bit_rate = 16

    # request
    response = asr(appKey,q,appSecret,"en",nchannels,sample_rate,'wav')
    print response.content
else:
    print '不支持的音频类型'

using System;
using System.Web;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;

namespace zhiyun_csharp_demo
{
    using System;
    using System.Collections.Specialized;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using System.Text;
    using System.Web;
    using System.Security.Cryptography;
    using System.Drawing;

    class Asr
    {

        public static void Main()
        {

            String url = "http://openapi.youdao.com/asrapi";
            Dictionary<String, String> dic = new Dictionary<String, String>();

            string q = ImgToBase64String("d:/16k.wav");
            string appKey = "您的应用ID";
            string appSecret = "您的应用密钥";

            /** 目标语言 */
            string langType = "en";
            /** 音频格式:目前支持pcm和wav(pcm编码) */
            string format = "wav";
            /** 音频采样率:目前支持16000和8000 */
            string rate = "16000";
            /** 音频频道 */
            string channel = "1";
            /** 上传类型 */
            string type = "1";
            /** 随机数,自己随机生成,建议时间戳 */
            string salt = DateTime.Now.Millisecond.ToString();

            MD5 md5 = new MD5CryptoServiceProvider();
            string md5Str = appKey + q + salt + appSecret;
            byte[] output = md5.ComputeHash(System.Text.Encoding.UTF8.GetBytes(md5Str));
            string sign = BitConverter.ToString(output).Replace("-", "");
            dic.Add("q", System.Web.HttpUtility.UrlEncode(q));
            dic.Add("appKey", appKey);
            dic.Add("langType", langType);
            dic.Add("format", format);
            dic.Add("rate", rate);
            dic.Add("channel", channel);
            dic.Add("type", type);
            dic.Add("salt", salt);
            dic.Add("sign", sign);
            string result = Post(url, dic);
            Console.WriteLine(result);

        }

        protected static string ImgToBase64String(string Imagefilename)
        {
            try
            {
                FileStream filestream = new FileStream(Imagefilename, FileMode.Open);
                byte[] arr = new byte[filestream.Length];
                filestream.Position = 0;
                filestream.Read(arr, 0, (int)filestream.Length);
                filestream.Close();
                return Convert.ToBase64String(arr);
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        public static string Post(string url, Dictionary<String, String> dic)
        {
            string result = "";
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
            req.Method = "POST";
            req.ContentType = "application/x-www-form-urlencoded";
            #region 添加Post 参数
            StringBuilder builder = new StringBuilder();
            int i = 0;
            foreach (var item in dic)
            {
                if (i > 0)
                    builder.Append("&");
                builder.AppendFormat("{0}={1}", item.Key, item.Value);
                i++;
            }
            Console.WriteLine(builder.ToString());
            byte[] data = Encoding.UTF8.GetBytes(builder.ToString());
            req.ContentLength = data.Length;
            using (Stream reqStream = req.GetRequestStream())
            {
                reqStream.Write(data, 0, data.Length);
                reqStream.Close();
            }
            #endregion
            HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
            Stream stream = resp.GetResponseStream();
            //获取响应内容
            using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
            {
                result = reader.ReadToEnd();
            }
            return result;
        }


    }
}
<?php
define("CURL_TIMEOUT",   2000);
define("URL",            "http://nb036x.corp.youdao.com:8999/asrapi");
define("APP_KEY",         "您的应用ID"); //替换为您的应用ID
define("SEC_KEY",        "您的应用密钥");//替换为您的密钥

function asr($q, $type, $langType, $channel, $rate, $format)
{
                     $args = array(
        'q' => $q,
        'appKey' => APP_KEY,
        'salt' => rand(10000,99999),
        'type' => $type,
        'langType' => $langType,
        'channel' => $channel,
        'rate' => $rate,
        'format' => $format,
    );
                     $args['sign'] = buildSign(APP_KEY, $q, $args['salt'], SEC_KEY);
                     $ret = call(URL, $args);
    echo $ret;
                     $ret = json_decode($ret, true);
    return $ret;
}

//加密
function buildSign($appKey, $query, $salt, $secKey)
{/*{{{*/
                     $str = $appKey . $query . $salt . $secKey;
                     $ret = md5($str);
    return $ret;
}/*}}}*/

//发起网络请求
function call($url, $args=null, $method="post", $testflag = 0, $timeout = CURL_TIMEOUT, $headers=array())
{/*{{{*/
                     $ret = false;
                     $i = 0;
    while($ret === false)
    {
        if($i > 1)
            break;
        if($i > 0)
        {
            sleep(1);
        }
                     $ret = callOnce($url, $args, $method, false, $timeout, $headers);
                     $i++;
    }
    return $ret;
}/*}}}*/

function callOnce($url, $args=null, $method="post", $withCookie = false, $timeout = CURL_TIMEOUT, $headers=array())
{/*{{{*/
                     $ch = curl_init();
    if($method == "post")
    {
                     $data = convert($args);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
        curl_setopt($ch, CURLOPT_POST, 1);
    }
    else
    {
                     $data = convert($args);
        if($data)
        {
            if(stripos($url, "?") > 0)
            {
                     $url .= "&$data";
            }
            else
            {
                     $url .= "?$data";
            }
        }
    }
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    if(!empty($headers))
    {
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    }
    if($withCookie)
    {
        curl_setopt($ch, CURLOPT_COOKIEJAR, $_COOKIE);
    }
                     $r = curl_exec($ch);
    curl_close($ch);
    return $r;
}/*}}}*/

function convert(&$args)
{/*{{{*/
                     $data = '';
    if (is_array($args))
    {
        foreach ($args as $key=>$val)
        {
            if (is_array($val))
            {
                foreach ($val as $k=>$v)
                {
                     $data .= $key.'['.$k.']='.rawurlencode($v).'&';
                }
            }
            else
            {
                     $data .="$key=".rawurlencode($val)."&";
            }
        }
        return trim($data, "&");
    }
    return $args;
}/*}}}*/
                     $file="d:/en.wav";
                     $fp=fopen($file,"r") or die("Can't open file");
                     $q=chunk_split(base64_encode(fread($fp,filesize($file))));//base64编码
fclose($fp);
//调用asr
asr($q,"1","en","1",16000,'wav');
?>

简介

Hi,您好,欢迎使用有道智云实时语音识别API接口服务。

本文档主要针对需要集成API的技术开发工程师,详细描述实时语音识别能力相关的技术内容。

如果您有与我们商务合作的需求,可以通过一下方式联系我们:

商务邮箱: AIcloud_Business@corp.youdao.com

如果您对文档内容有任何疑问,可以通过以下几种方式联系我们:

客服QQ:1906538062

官方交流群:652880659

联系邮箱: zyservice@corp.youdao.com

下面是接口接入文档,接入测试需要应用ID和密钥,如果您还没有,请按照新手指南获取。

接口说明

接口地址:

wss://openapi.youdao.com/stream_asropenapi?{请求参数}

服务接口的调用分为认证、实时通信两阶段。
1 认证阶段

请求参数格式:
key1=value1&key2=value2&key3=value3&key4=value4

参数说明:

参数类型必填说明示例
appKeyString已申请的应用IDIDstream-asr-example
saltString随机数uuid
curtimeString时间戳,1970-1-01 00:00:00 至当前的秒数1522292849
signString加密数字签名。
signTypeString数字签名类型v4
langTypeString语言选择,接口目前支持中文和英文zh-CHS
formatString音频格式,支持wavwav
channelString声道,支持11
versionStringapi版本v1
rateString采样率16000

sign的生成规则:sha256(appKey + salt + curtime +appSecret),其中appSecret为应用密钥,可在应用管理-我的应用页,点击应用名称到应用详情页查看(仅API接入方式的应用有应用密钥)。

服务端通过 text message 返回 json字符串的认证结果,参数示例:

成功:

{
    "result": [],
    "action": "started",
    "errorCode": "0"
}

失败:

{
    "result": "[]",
    "action": "error",
    "errorCode": "202"
}

参数说明:

参数类型说明
errorCodeString状态码,详见状态码说明
actionString状态标识,started:握手,recognition:识别,error:错误
resultString识别结果数据

2 实时通信阶段

认证成功之后,进入实时通信阶段,此阶段客户端发送音频流和结束标识,并接收转写结果或错误。

2.1 发送音频流

此阶段客户端通过 binary message 发送音频流,内容为音频的二进制数据,此过程的发送频率将影响文字结果展示的实时性。

建议以 200ms 间隔发送音频数据,若间隔超时 15s 以上,服务端将停止识别。

2.2 发送结束标识

客户端完成所有音频数据的发送后,需发送一个特殊的 binary message 到服务端作为音频流
发送结束的标识,内容为:

{"end": "true"}

2.3 接收转写结果

交互过程中,服务端不断通过 text message 返回实时识别结果到客户端,响应结果是以json形式输出(为text message)。
识别结果示例:

{
    "result": [{
        "st": [{
            "bg": 30,
            "ed": 480,
            "ws": [{
                "w": "Have",
                "wb": 30,
                "we": 240
            }, {
                "w": "a",
                "wb": 240,
                "we": 270
            }, {
                "w": "good",
                "wb": 270,
                "we": 480
            }, {
                "w": "day.",
                "wb": 480,
                "we": 480
            }]
        }],
        "seg_id": 0
    }],
    "errorCode": "0",
    "action": "recognition"
}

识别结果 result 参数说明:

参数含义说明
bg分句开始时间单位毫秒/ms
ed分句结束时间单位毫秒/ms
w词(字)识别结果
wb词(字)开始时间单位毫秒/ms
we词(字)结束时间单位毫秒/ms
type识别结果类型0:最终结果,1:中间结果
seg_id分句 id从 0 开始递增

支持的语言表

支持中文和其他几种语言的互译。

语言代码
中文zh-CHS
英文en

语音支持

格式支持:wav(不压缩、pcm编码)

采样率:8k或者16k。推荐16k。

编码:16bit位深的单声道

格式代码
wavwav

状态码

errorCode意义
0成功
101缺少必填的参数
102不支持的语言类型
104不支持的接口版本
105不支持的签名类型
106不支持的返回格式
107不支持的传输加密类型
108appKey无效
110无相关服务的有效实例
111devId无效
112productId无效
201解密失败,可能为DES,BASE64,URLDecode的错误
202签名校验失败
203访问IP地址不在可访问IP列表
205请求的接口与应用的平台类型不一致
206时间戳无效导致签名校验失败
207重放请求
303服务端的其它异常
304 |   会话闲置太久超时    |

| 401 | 账户已经欠费停止 |
| 9001 | 不支持的语音格式 |
| 9002 | 不支持的语音采样率 |
| 9003 | 不支持的语音声道 |
| 9004 | 不支持的语音上传类型 |
| 9005 | 不支持的语音识别 Language类型 |
| 9301 | ASR识别失败 |
| 9303 | 服务器内部错误 |
| 9411 | 访问频率受限(超过最大调用次数) |
| 9412 | 超过最大处理语音长度 |

常见问题

  • 返回110

应用没有绑定服务实例,可以新建服务实例,绑定服务实例。

  • 返回108

appKey无效,注册账号, 登录后台创建应用和实例并完成绑定, 可获得应用ID和密钥等信息,其中应用ID就是appKey( 注意不是应用密钥)

  • 返回101

首先确保必填参数齐全,然后,确认参数书写是否正确。

  • 返回202

如果确认 appKeyappSecret 的正确性,仍返回202,一般是编码问题。请确保 q 为UTF-8编码.

版本记录

上线日期版本号更新内容
2018.11.07v1.0.0有道智云实时语音识别API上线

常见语言Demo

Java 示例
Python 示例
C# 示例
PHP 示例


import javax.websocket.ContainerProvider;
import javax.websocket.Session;
import javax.websocket.WebSocketContainer;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.URI;
import java.nio.ByteBuffer;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.UUID;

public class AsrliteDemo {

    public Session session;

    public static void main(String[] args) throws Exception {

        String filePath = "D:\\en.wav";
        String langType = "en";
        String appKey = "您的应用ID";
        String appSecret = "您的应用密钥";

        asrlite(appKey,appSecret,filePath,langType);
    }

    protected void start(String uri) {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();

        try {
            session = container.connectToServer(Websocket.class, URI.create(uri));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void doAsrWebSocketClient(String filePath, String uri, Integer step) {
        AsrliteDemo asrliteWebSocketClientApp = new AsrliteDemo();
        asrliteWebSocketClientApp.start(uri);
        try {
            InputStream inputStream = new FileInputStream(filePath);
            int read = 0;
            byte[] bytes = new byte[step];
            while ((read = inputStream.read(bytes)) != -1) {
                asrliteWebSocketClientApp.session.getBasicRemote().sendBinary(ByteBuffer.wrap(bytes));
                Thread.sleep(100);
            }
            byte[] closebytes = "{\"end\": \"true\"}".getBytes();
            asrliteWebSocketClientApp.session.getBasicRemote().sendBinary(ByteBuffer.wrap(closebytes));


        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private static void asrlite(String appKey,String appSecret,String filePath,String langType) throws NoSuchAlgorithmException {
        AsrliteDemo asrWebSocketClient = new AsrliteDemo();
        String nonce = UUID.randomUUID().toString();
        String curtime = String.valueOf(System.currentTimeMillis()/1000);
        String signStr = appKey + nonce +curtime + appSecret;
        String sign =  encrypt(signStr,null);

        String uri = "wss://openapi.youdao.com/stream_asropenapi?appKey="+appKey+"&salt="+nonce+"&curtime="+curtime+"&sign="+sign+"&version=v1&channel=1&format=wav&signType=v4&rate=16000&langType="+langType;
        asrWebSocketClient.doAsrWebSocketClient(filePath,uri,1600);
    }

    /**
     * 获取MessageDigest的加密结果
     * @param strSrc
     * @param encName
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static String encrypt(String strSrc, String encName) throws NoSuchAlgorithmException {
        byte[] bt = strSrc.getBytes();
        if (encName == null || "".equals(encName)) {
            encName = "SHA-256";
        }
        MessageDigest md = MessageDigest.getInstance(encName);
        md.update(bt);
        // to HexString
        return bytes2Hex(md.digest());
    }
    public static String bytes2Hex(byte[] bts) {
        String des = "";
        String tmp;
        for (int i = 0; i < bts.length; i++) {
            tmp = (Integer.toHexString(bts[i] & 0xFF));
            if (tmp.length() == 1) {
                des += "0";
            }
            des += tmp;
        }
        return des;
    }

}

import javax.websocket.*;
import java.io.IOException;

@ClientEndpoint
public class Websocket {

    private void print(Object obj) {
        System.out.println(obj.toString());
    }

    Session session;

    @OnOpen
    public void onOpen(Session session) {
        print("Connect to endpoint: " + session.getBasicRemote());
        this.session = session;
    }

    @OnMessage
    public void onMessage(String message) throws IOException {
        print(message);
        if (message.contains("\"errorCode\":\"304\"")) {
            onClose();
        }

    }

    @OnError
    public void onError(Throwable throwable) {
        throwable.printStackTrace();
    }

    @OnClose
    public void onClose() throws IOException {
        if(this.session.isOpen()){
            this.session.close();
        }
        print("session close");
        System.exit(0);
    }

}
# -*- coding: utf-8 -*-
import uuid
import time
import websocket
import hashlib

file_path = 'D:\\en.wav'
lang_type = 'en'
app_key = '您的应用ID'
app_secret = '您的应用密钥'


def initialize():
    nonce = str(uuid.uuid1())
    curtime = str(int(time.time()))
    signStr = app_key + nonce + curtime + app_secret
    print(signStr)
    sign = encrypt(signStr)

    uri = "wss://openapi.youdao.com/stream_asropenapi?appKey=" + app_key + "&salt=" + nonce + "&curtime=" + curtime + \
          "&sign=" + sign + "&version=v1&channel=1&format=wav&signType=v4&rate=16000&langType=" + lang_type
    print(uri)
    start(uri, 1600)


def encrypt(signStr):
    hash = hashlib.sha256()
    hash.update(signStr.encode('utf-8'))
    return hash.hexdigest()



def on_message(ws, message):
    print(message)


def on_error(ws, error):
    print(error)


def on_close(ws):
    print("### closed ###")


def on_open(ws):
    count = 0
    file_object = open(file_path, 'rb')
    while True:
        chunk_data = file_object.read(1600)
        ws.send(chunk_data, websocket.ABNF.OPCODE_BINARY)
        count = count + 1
        if not chunk_data:
            break
    print(count)
    ws.send('{\"end\": \"true\"}', websocket.ABNF.OPCODE_BINARY)



def start(uri, step):
    websocket.enableTrace(True)
    ws = websocket.WebSocketApp(uri,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.on_open = on_open
    ws.run_forever()


if __name__ == '__main__':
    initialize()



using System;
using System.IO;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Security.Cryptography;

namespace asrliteclient
{
    public class AsrDemoWebSocketClient
    {
        public void start(String filePath, String uri, int step)
        {
            var client = new ClientWebSocket();
            client.ConnectAsync(new Uri(uri), CancellationToken.None).Wait();
            startReceiving(client);
            int bufferSize = step; //每次读取的字节数
            byte[] buffer = new byte[bufferSize];
            FileStream stream = null;
            try
            {
                stream = new FileStream(filePath, FileMode.Open);
                long fileLength = stream.Length; //文件流的长度
                int readCount = (int) Math.Ceiling((double) (fileLength / bufferSize)); //需要对文件读取的次数
                int tempCount = 0; //当前已经读取的次数
                do
                {
                    stream.Read(buffer, 0,
                        bufferSize); //分readCount次读取这个文件流,每次从上次读取的结束位置开始读取bufferSize个字节
                    //这里加入接收和处理数据的逻辑-
                    var array = new ArraySegment<byte>(buffer);
                    client.SendAsync(array, WebSocketMessageType.Binary, true, CancellationToken.None);
                    tempCount++;
                } while (tempCount < readCount);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            finally
            {
                if (stream != null)
                    stream.Dispose();
            }

            try
            {
                byte[] closeBytes = Encoding.UTF8.GetBytes("{\"end\": \"true\"}");
                var closeArray = new ArraySegment<byte>(closeBytes);
                client.SendAsync(closeArray, WebSocketMessageType.Binary, true, CancellationToken.None);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            while (true)
            {
                Thread.Sleep(3000);
                break;
            }

            client.Dispose();
        }

        public async Task startReceiving(ClientWebSocket client)
        {
            while (true)
            {
                var array = new byte[4096];
                var result = await client.ReceiveAsync(new ArraySegment<byte>(array), CancellationToken.None);
                if (result.MessageType == WebSocketMessageType.Text)
                {
                    string msg = Encoding.UTF8.GetString(array, 0, result.Count);
                    Console.ForegroundColor = ConsoleColor.DarkBlue;
                    Console.WriteLine("--> {0}", msg);
                    Console.ForegroundColor = ConsoleColor.DarkGray;
                }
            }
        }

        public void doAscWebSocketClient(String filePath, String uri, int step)
        {
           start(filePath, uri, step);
        }

        public void init()
        {
            String filePath = "D:\\en.wav";
            String langType = "en";
            String appKey = "您的应用ID";
            String appSecret = "您的应用密钥";
            String nonce = Guid.NewGuid().ToString();
            TimeSpan ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc));
            long millis = (long) ts.TotalMilliseconds;
            String curtime = Convert.ToString(millis / 1000);
            String signStr = appKey + nonce + curtime + appSecret;
            String sign = encrypt(signStr, null);

            String uri = "wss:/openapi.youdao.com/stream_asropenapi?appKey=" + appKey + "&salt=" + nonce +
                         "&curtime=" + curtime + "&sign=" + sign +
                         "&version=v1&channel=1&format=wav&signType=v4&rate=16000&langType=" + langType;

            Console.WriteLine(uri);
            doAscWebSocketClient(filePath, uri, 1600);
        }

        //加密
        private String encrypt(String strSrc, String encName)
        {
            byte[] bt = Encoding.UTF8.GetBytes(strSrc);
            SHA256 sha256 = SHA256.Create();
            //暂时固定为SHA—256
            //暂时没发现内置的不同hash加密构造方法
            //可以自行编写代替
            if (encName == null || "".Equals(encName))
            {
                encName = "SHA-256";
            }

            byte[] HashData = sha256.ComputeHash(bt);
            StringBuilder oSb = new StringBuilder();

            for (int x = 0; x < HashData.Length; x++)
            {
                //hexadecimal string value
                oSb.Append(HashData[x].ToString("x2"));
            }

            return oSb.ToString();
        }

        public static void Main(string[] args)
        {

            AsrDemoWebSocketClient asrDemoWebSocketClient = new AsrDemoWebSocketClient();
            asrDemoWebSocketClient.init();
        }
    }
}

<?php
/**
 * Created by PhpStorm.
 * User: 谭上鸥
 * Date: 2018/11/2
 * Time: 11:58
 */

# 需要安装Workerman库或用其他websocket第三方库代替

use Workerman\Worker;
use Workerman\Connection\AsyncTcpConnection;
use Workerman\Protocols\Websocket;
require_once 'C:\Users\谭上鸥\PhpstormProjects\Workerman-master\Autoloader.php';

function start($filePath,$uri,$step){
                     $worker = new Worker();

                     $worker->onWorkerStart = function($worker) use($uri,$filePath,$step){

                     $con = new AsyncTcpConnection($uri);

                     $con->websocketType = Websocket::BINARY_TYPE_ARRAYBUFFER;

                     $con->onConnect = function($con) {
        };

                     $con->onMessage = function($con, $data) {
            echo $data."\n";
        };

                     $con->connect();

                     $handle = fopen($filePath, "rb");
        // 每次读取一定大小的文件
                     $readTime = ceil(filesize($filePath)/$step);
                     $read = 0;
        while($read<$readTime){
                     $content = stream_get_contents($handle,$step,0);
                     $con->send($content);
                     $read++;
        }
                     $con->send("{\"end\": \"true\"}");
    };

    Worker::runAll();
}

//uuid generator
function create_guid(){
                     $microTime = microtime();
    list($a_dec, $a_sec) = explode(" ", $microTime);
                     $dec_hex = dechex($a_dec* 1000000);
                     $sec_hex = dechex($a_sec);
    ensure_length($dec_hex, 5);
    ensure_length($sec_hex, 6);
                     $guid = "";
                     $guid .= $dec_hex;
                     $guid .= create_guid_section(3);
                     $guid .= '-';
                     $guid .= create_guid_section(4);
                     $guid .= '-';
                     $guid .= create_guid_section(4);
                     $guid .= '-';
                     $guid .= create_guid_section(4);
                     $guid .= '-';
                     $guid .= $sec_hex;
                     $guid .= create_guid_section(6);
    return $guid;
}
function ensure_length(&$string, $length){
                     $strlen = strlen($string);
    if($strlen < $length)
    {
                     $string = str_pad($string,$length,"0");
    }
    else if($strlen > $length)
    {
                     $string = substr($string, 0, $length);
    }
}
function create_guid_section($characters){
                     $return = "";
    for($i=0; $i<$characters; $i++)
    {
                     $return .= dechex(mt_rand(0,15));
    }
    return $return;
}

function init(){
                     $filePath = "D:\\en.wav";
                     $langType = "en";
                     $appKey = "您的应用ID";
                     $appSecret = "您的应用密钥";

                     $nonce = create_guid();
                     $curtime = strtotime("now");
                     $signStr = $appKey.$nonce.$curtime.$appSecret;
                     $sign = hash("sha256",$signStr);

                     $uri = "wss://openapi.youdao.com/stream_asropenapi?appKey=".$appKey."&salt=".$nonce."&curtime=".$curtime."&sign=".$sign."&version=v1&channel=1&format=wav&signType=v4&rate=16000&langType=".$langType;

    echo $uri;

    start($filePath,$uri,1600);
}

init();
文档是否有帮助解决问题?

如有其它疑问,可在此提交意见和反馈
详细描述(选填)
联系邮箱(选填)
 
有道智云平台介绍
网易有道旗下一个为开发者、企业和政府机构等提供自然语言翻译、文字识别OCR等服务以及行业解决方案的云服务平台,致力于提供安全、可靠和高效的云服务。
联系方式
联系电话:010-8255-8901
商务合作:
投诉反馈:
地址:北京市海淀区西北旺东路10号院 中关村软件园二期西区7号 网易(北京)公司
微信公众号
微信小程序
 
 
 
©2017 网易公司 京ICP证080268号