devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

百度语音识别结合云知声离线TTSDemo（AS）_百度离线tts语音包

作者：从前慢现在也慢 | 2024-04-23 02:15:44

赞

踩

百度离线tts语音包

       最近项目需要，需要调研几家语音识别（离线/在线），语义理解，TTS（在线/离线）,离线命令词，甚至百度的UNIT上下文使用等，虽然看的不怎么深入，但是也确实调研的不是，主要有百度，科大讯飞，搜狗，云知声，奇梦者等几家，还有包括硬件（科大的四麦直线麦克风，五麦环绕麦克风，最后升级的六麦环绕麦克风；奇梦者的四麦环绕麦克风+柱形麦克风阵列等）。也写了很多Demo，每一家的特色都不同。这里就不一一列举了。以后有机会在慢慢写下来，这里就简单给一个百度在线ASR和云知声离线TTS结合的案列，实现一个复读机的功能。

       因为现在比较晚了，我先上代码，后面会补充几点注意事项。

1，准备工作：

（1）百度SDK的JAR包bdasr_V3_xxx_xxx.jar与云知声的JAR包usc.jar：

百度SDK下载

云知声SDK下载

（先注册登录，选择服务再下载）

解压找到工程libs中的对应的jar（不在详说），添加在自己新建的工程的libs目录下，添加为library。

（2） so文件：同理，在刚刚下载的SDK中找到对应的so文件，然后早项目新建一个jniLibs目录（../src/main/）

（3）云知声离线TTS需要语音包（发不同音色使用的）：使用时，需要先运行自己编写的工程，然后在对应设备的app安装的目录下新建tts文件夹，把下面三个文件放进去：

backend_female

backend_lzl

frontend_model

 

2，代码环节：

（1）AndroidManifest.xml：主要就是注意几个权限和百度的APP_ID,API_KEY,SECRET_KEY,这个需要自己创建应用，获取这三个值；这步不在累述。

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="aoto.com.baidurecongdemo">
  4.  
  5.     <!-- begin: baidu speech sdk  权限 -->
  6.     <uses-permission android:name="android.permission.RECORD_AUDIO" />
  7.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  8.     <uses-permission android:name="android.permission.INTERNET" />
  9.     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  10.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  11.  
  12.     <application
  13.         android:allowBackup="true"
  14.         android:icon="@mipmap/talk"
  15.         android:label="@string/app_name"
  16.         android:roundIcon="@mipmap/talk"
  17.         android:supportsRtl="true"
  18.         android:theme="@style/AppTheme">
  19.         <activity android:name=".MainActivity">
  20.             <intent-filter>
  21.                 <action android:name="android.intent.action.MAIN" />
  22.  
  23.                 <category android:name="android.intent.category.LAUNCHER" />
  24.             </intent-filter>
  25.         </activity>
  26.  
  27.         <meta-data
  28.             android:name="com.baidu.speech.APP_ID"
  29.             android:value="XXXXXXX" />
  30.         <meta-data
  31.             android:name="com.baidu.speech.API_KEY"
  32.             android:value="XXXXXXXXXXX..." />
  33.         <meta-data
  34.             android:name="com.baidu.speech.SECRET_KEY"
  35.             android:value="XXXXXXXXXXXX...." />
  36.  
  37.         <service
  38.             android:name=".ASRService"
  39.             android:enabled="true"
  40.             android:exported="true">
  41.             <intent-filter>
  42.                 <action android:name="aoto.com.ASRService" />
  43.             </intent-filter>
  44.         </service>
  45.     </application>
  46.  
  47. </manifest>

 

（2）ASRService：这里我把百度语音识别写成了服务的形式，并开放了AIDL接口，别的应用可以直接调用即可（里面的方法未完善，学习者可以自行添加和修改）

  1. package aoto.com.baidurecongdemo;
  2.  
  3.  
  4. import android.app.Service;
  5. import android.content.Intent;
  6. import android.os.IBinder;
  7. import android.os.Message;
  8. import android.os.RemoteCallbackList;
  9. import android.os.RemoteException;
  10. import android.util.Log;
  11. import com.baidu.speech.EventListener;
  12. import com.baidu.speech.EventManager;
  13. import com.baidu.speech.EventManagerFactory;
  14. import com.baidu.speech.asr.SpeechConstant;
  15. import com.unisound.client.SpeechConstants;
  16. import com.unisound.client.SpeechSynthesizer;
  17. import com.unisound.client.SpeechSynthesizerListener;
  18.  
  19. import org.json.JSONObject;
  20.  
  21. import java.io.File;
  22. import java.util.LinkedHashMap;
  23. import java.util.Map;
  24.  
  25.  
  26. public class ASRService extends Service implements EventListener {
  27.     private EventManager asr;
  28.     public static String result;
  29.     private boolean logTime = true;
  30.     private String language;
  31.     long startTime = 0;
  32.     long endTime = 0;
  33.     private MainActivity mainActivity = new MainActivity();
  34.  
  35.  
  36.     private SpeechSynthesizer mTTSPlayer;
  37.     private final String mFrontendModel= "/sdcard/unisound/tts/frontend_model";
  38.     private final String mBackendModel = "/sdcard/unisound/tts/backend_lzl";
  39.  
  40.     //主动发数据
  41.     final RemoteCallbackList<IRemoteServiceCallback> mCallbacks
  42.             = new RemoteCallbackList<IRemoteServiceCallback>();
  43.     private int mValue = 0;
  44.     private static final int REPORT_MSG = 1;
  45.  
  46.     @Override
  47.     public void onCreate() {
  48.         System.out.println("服务创建了：" + "onCreate");
  49.         asr = EventManagerFactory.create(this, "asr");
  50.         asr.registerListener(this);
  51.         super.onCreate();
  52.         //初始化离线引擎
  53.         initTts();
  54.     }
  55.  
  56.     @Override
  57.     public void onStart(Intent intent, int startId) {
  58.         System.out.println("服务开启了：" + "onStart");
  59.         super.onStart(intent, startId);
  60.     }
  61.  
  62.     /**
  63.      * 测试参数填在这里
  64.      */
  65.     public void start() {
  66.         Map<String, Object> params = new LinkedHashMap<String, Object>();
  67.         String event = null;
  68.         event = SpeechConstant.ASR_START; // 替换成测试的event
  69.         params.put(SpeechConstant.ACCEPT_AUDIO_VOLUME, false);
  70.         //判断调用者传过来的语言类型
  71.         if (MainActivity.languge_id == 1) {
  72.             params.put(SpeechConstant.PID, 1736);
  73.         } else if (MainActivity.languge_id == 2) {
  74.             params.put(SpeechConstant.PID, 1836);
  75.         } else if (MainActivity.languge_id == 3) {
  76.             params.put(SpeechConstant.PID, 1636);
  77.         } else {
  78.             params.put(SpeechConstant.PID, 1536);
  79.         }
  80.         System.out.println("MMMMMMMMMMMMMMMMMMLanguage:" + MainActivity.languge_id);
  81.         // 请先使用如‘在线识别’界面测试和生成识别参数。 params同ActivityRecog类中myRecognizer.start(params);
  82.         String json = null; //可以替换成自己的json
  83.         json = new JSONObject(params).toString(); // 这里可以替换成你需要测试的json
  84.         asr.send(event, json, null, 0, 0);
  85.         printLog("输入参数：" + json);
  86.     }
  87.  
  88.     private void stop() {
  89.         asr.send(SpeechConstant.ASR_STOP, null, null, 0, 0); //
  90.     }
  91.  
  92.     //   EventListener  回调方法
  93.     /**
  94.      * @param name   :当前asr状态
  95.      * @param params ：解析结果字符串
  96.      * @author why
  97.      */
  98.     @Override
  99.     public void onEvent(String name, String params, byte[] data, int offset, int length) {
  100.         String logTxt = "name: " + name;
  101.         if (params != null && !params.isEmpty()) {
  102.             logTxt += " ;params :" + params;
  103.             //通过name来确定当前状态，从而获取解析结果显示
  104.             if (name.equals("asr.partial")) {
  105.                 String start = "[";
  106.                 String end = "]";
  107.                 //截取解析json字符串中结果显示
  108.                 result = StringTools.SubStringTwoChar(params, start, end);
  109.                 startTime = System.currentTimeMillis();
  110.             }
  111.         }
  112.  
  113.         if (name.equals("asr.finish")) {
  114.             //识别结束
  115.             if(MainActivity.btn.getText().toString().equals("停止")){
  116.                 if (result.equals("")||result==null){
  117.                     result="没有识别到声音";
  118.                 }
  119.                 MainActivity.btn.setText("开始");
  120.             }
  121.             else{
  122.                 if (result.equals("")||result==null){
  123.                     result="No sound at all";
  124.                 }
  125.                 MainActivity.btn.setText("start");
  126.             }
  127.             MainActivity.txtResult.setText(result);
  128.  
  129.             //TTS语音合成
  130.             mTTSPlayer.playText(result);
  131.  
  132.         }
  133.  
  134.         //会话结束标识，发送广播传数据
  135.         if (name.equals("asr.exit")) {
  136.             mainActivity.test(result);
  137.         }
  138.  
  139.         if (name.equals(SpeechConstant.CALLBACK_EVENT_ASR_PARTIAL)) {
  140.             if (params.contains("\"nlu_result\"")) {
  141.                 if (length > 0 && data.length > 0) {
  142.                     logTxt += ", 语义解析结果：" + new String(data, offset, length);
  143.                 }
  144.             }
  145.         } else if (data != null) {
  146.             logTxt += " ;data length=" + data.length;
  147.         }
  148.         //打印识别日志
  149.         printLog(logTxt);
  150.     }
  151.  
  152.     //打印识别日志实现
  153.     private void printLog(String text) {
  154.         if (logTime) {
  155.             text += "  ;time=" + System.currentTimeMillis();
  156.         }
  157.         text += "\n";
  158.         Log.i(getClass().getName(), text);
  159.     }
  160.  
  161.  
  162.     //返回可调用服务方法的接口
  163.     @Override
  164.     public IBinder onBind(Intent intent) {
  165.         System.out.println("MMMMMMMMMMMMMMMMM" + "服务绑定了！");
  166.         return new MyASRresultAIDL();
  167.     }
  168.  
  169.     //百度语音识别
  170.     class MyASRresultAIDL extends ASRresultAIDL.Stub {
  171.         @Override
  172.         public String getASRResult() throws RemoteException {
  173.             return result;
  174.         }
  175.  
  176.         @Override
  177.         public void callStart() throws RemoteException {
  178.             start();
  179.         }
  180.  
  181.         @Override
  182.         public void callStop() throws RemoteException {
  183.             stop();
  184.         }
  185.     }
  186.  
  187.     //初始化离线语音合成引擎实现
  188.     private void initTts() {
  189.         // 初始化语音合成对象
  190.         //mTTSPlayer = new SpeechSynthesizer(this, Config.appKey, Config.secret);
  191.         mTTSPlayer = new SpeechSynthesizer(this, "", "");
  192.         System.out.println("TTTTTTTTTTTTTTTTTTS:"+mTTSPlayer);
  193.         // 设置本地合成
  194.         mTTSPlayer.setOption(SpeechConstants.TTS_SERVICE_MODE, SpeechConstants.TTS_SERVICE_MODE_LOCAL);
  195.         File _FrontendModelFile = new File(mFrontendModel);
  196.         if (!_FrontendModelFile.exists()) {
  197.             System.out.println("文件：" + mFrontendModel + "不存在，请将assets下相关文件拷贝到SD卡指定目录！");
  198.         }
  199.         File _BackendModelFile = new File(mBackendModel);
  200.         if (!_BackendModelFile.exists()) {
  201.             System.out.println("文件：" + mBackendModel + "不存在，请将assets下相关文件拷贝到SD卡指定目录！");
  202.         }
  203.         // 设置前端模型
  204.         mTTSPlayer.setOption(SpeechConstants.TTS_KEY_FRONTEND_MODEL_PATH, mFrontendModel);
  205.         // 设置后端模型
  206.         mTTSPlayer.setOption(SpeechConstants.TTS_KEY_BACKEND_MODEL_PATH, mBackendModel);
  207.         // 设置回调监听
  208.         mTTSPlayer.setTTSListener(new SpeechSynthesizerListener() {
  209.             @Override
  210.             public void onEvent(int type) {
  211.                 switch (type) {
  212.                     case SpeechConstants.TTS_EVENT_INIT:
  213.                         // 初始化成功回调
  214.                         Log.i("", "回调成功 ");
  215.                         break;
  216.                     case SpeechConstants.TTS_EVENT_SYNTHESIZER_START:
  217.                         // 开始合成回调
  218.                         Log.i("", "开始同步");
  219.                         break;
  220.                     case SpeechConstants.TTS_EVENT_SYNTHESIZER_END:
  221.                         // 合成结束回调
  222.                         Log.i("", "结束同步");
  223.                         break;
  224.                     case SpeechConstants.TTS_EVENT_BUFFER_BEGIN:
  225.                         // 开始缓存回调
  226.                         Log.i("", "开始缓存 ");
  227.                         break;
  228.                     case SpeechConstants.TTS_EVENT_BUFFER_READY:
  229.                         // 缓存完毕回调
  230.                         Log.i("", "准备缓存 ");
  231.                         break;
  232.                     case SpeechConstants.TTS_EVENT_PLAYING_START:
  233.                         // 开始播放回调
  234.                         Log.i("", "播放开始 ");
  235.                         break;
  236.                     case SpeechConstants.TTS_EVENT_PLAYING_END:
  237.                         // 播放完成回调
  238.                         Log.i("", "播放结束 ");
  239.                         break;
  240.                     case SpeechConstants.TTS_EVENT_PAUSE:
  241.                         // 暂停回调
  242.                         Log.i("", "暂停 ");
  243.                         break;
  244.                     case SpeechConstants.TTS_EVENT_RESUME:
  245.                         // 恢复回调
  246.                         //log_i("resume");
  247.                         break;
  248.                     case SpeechConstants.TTS_EVENT_STOP:
  249.                         // 停止回调
  250.                         Log.i("", "停止");
  251.                         break;
  252.                     case SpeechConstants.TTS_EVENT_RELEASE:
  253.                         // 释放资源回调
  254.                         Log.i("", "释放资源");
  255.                         break;
  256.                     default:
  257.                         break;
  258.                 }
  259.  
  260.             }
  261.  
  262.             @Override
  263.             public void onError(int type, String errorMSG) {
  264.                 // 语音合成错误回调
  265.                 Log.e("","Error");
  266.             }
  267.         });
  268.  
  269.         // 初始化合成引擎
  270.         int returnvalue= mTTSPlayer.init("");
  271.         System.out.println("EEEEEEEEEEE:"+"初始化引擎"+returnvalue);
  272.     }
  273.  
  274. }

（3）StringUtils : ASRService中使用的一个工具类

  1. package aoto.com.baidurecongdemo;
  2.  
  3. /**
  4.  * author:why
  5.  * created on: 2018/1/31 15:25
  6.  * description:
  7.  */
  8. public class StringTools {
  9.  
  10.     //截取固定字符床中指定两个字符或者字符串之间的子字符串
  11.  
  12.     /**
  13.      *
  14.      * @param target :要处理字符串
  15.      * @param start ：起始字符串/字符
  16.      * @param end ：结束字符串/字符
  17.      * @return
  18.      */
  19.     public static String SubStringTwoChar(String target, String start, String end) {
  20.         int startIndex = target.indexOf(start);
  21.         int endIndex = target.indexOf(end);
  22.         return target.substring(startIndex, endIndex).substring(start.length());
  23.     }
  24.  
  25. }

（4）MainActivity：调用服务，演示效果

  1. package aoto.com.baidurecongdemo;
  2.  
  3. import android.Manifest;
  4. import android.content.ComponentName;
  5. import android.content.Intent;
  6. import android.content.ServiceConnection;
  7. import android.content.pm.PackageManager;
  8. import android.os.IBinder;
  9. import android.os.RemoteException;
  10. import android.support.v4.app.ActivityCompat;
  11. import android.support.v4.content.ContextCompat;
  12. import android.support.v7.app.AppCompatActivity;
  13. import android.os.Bundle;
  14. import android.util.Log;
  15. import android.view.View;
  16. import android.widget.AbsSpinner;
  17. import android.widget.AdapterView;
  18. import android.widget.ArrayAdapter;
  19. import android.widget.Button;
  20. import android.widget.Spinner;
  21. import android.widget.TextView;
  22.  
  23. import com.baidu.speech.asr.SpeechConstant;
  24.  
  25. /**
  26.  * @author why
  27.  */
  28. public class MainActivity extends AppCompatActivity implements InterfaceTest{
  29.  
  30.     protected TextView txtLog;
  31.     public static TextView txtResult;
  32.     public static Button btn;
  33.     private String result;
  34.     private static String DESC_TEXT = "在线识别日志";
  35.     public static int languge_id = 0;
  36.     private Intent intent;
  37.     private MyServiceConnection connection;
  38.     private ASRresultAIDL asRresultAIDL;
  39.     private Spinner spinner;
  40.     private String butContext;
  41.  
  42.     /**
  43.      * 测试参数填在这里
  44.      */
  45.     @Override
  46.     protected void onCreate(Bundle savedInstanceState) {
  47.         super.onCreate(savedInstanceState);
  48.         setContentView(R.layout.common_mini);
  49.         initView();
  50.         intent = new Intent(this, ASRService.class);
  51.         connection = new MyServiceConnection();
  52.         bindService(intent, connection, BIND_AUTO_CREATE);
  53.  
  54.     }
  55.  
  56.     //触发语音识别开始与停止
  57.     public void startOrEnd(View view) {
  58.          butContext = btn.getText().toString();
  59.         System.out.println("BBBBBBBBBBBBBBBBBBBBBB"+butContext);
  60.         //先判断选择的语言
  61.         if (butContext.equals("开始") || butContext.equals("start")) {
  62.             //识别结果制空
  63.             try {
  64.                 asRresultAIDL.callStart();
  65.             } catch (RemoteException e) {
  66.                 e.printStackTrace();
  67.             }
  68.             if (butContext.equals("开始")) {
  69.                 ASRService.result="没有识别到声音";
  70.                 txtResult.setText("请说，我在听");
  71.                 btn.setText("停止");
  72.             } else {
  73.                 ASRService.result="No sound at all";
  74.                 txtResult.setText("Please say,I am listening");
  75.                 btn.setText("stop");
  76.             }
  77.         } else {
  78.             if (butContext.equals("停止")) {
  79.                 btn.setText("开始");
  80.                 try {
  81.                     txtResult.setText("识别结果：" + asRresultAIDL.getASRResult());
  82.                 } catch (RemoteException e) {
  83.                     e.printStackTrace();
  84.                 }
  85.             } else {
  86.                 btn.setText("start");
  87.                 try {
  88.                     txtResult.setText("ASR result：" + asRresultAIDL.getASRResult());
  89.                 } catch (RemoteException e) {
  90.                     e.printStackTrace();
  91.                 }
  92.             }
  93.             try {
  94.                 asRresultAIDL.callStop();
  95.             } catch (RemoteException e) {
  96.                 e.printStackTrace();
  97.             }
  98.         }
  99.     }
  100.  
  101.  
  102.     @Override
  103.     protected void onDestroy() {
  104.         unbindService(connection);
  105.         super.onDestroy();
  106.     }
  107.  
  108.     private void initView() {
  109.         txtResult = (TextView) findViewById(R.id.txtResult);
  110.         txtLog = (TextView) findViewById(R.id.txtLog);
  111.         btn = (Button) findViewById(R.id.btn);
  112.         txtLog.setText(DESC_TEXT + "\n");
  113.         spinner = findViewById(R.id.languge_list);
  114.         //下拉框实现
  115.         ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this, R.array.Data, android.R.layout.simple_spinner_item);
  116.         adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  117.         spinner.setAdapter(adapter);
  118.         spinner.setPrompt("选择语言");
  119.         //设置下拉框监听
  120.         spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
  121.             @Override
  122.             public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
  123.                 languge_id = position;
  124.                 System.out.println("QQQQQQQQQQQQQQQQQQQQQ"+languge_id);
  125.                 switch (languge_id) {
  126.                     //普通话
  127.                     case 0:
  128.                         txtResult.setText("点击‘开始’");
  129.                         btn.setText("开始");
  130.                         break;
  131.                     //英语
  132.                     case 1:
  133.                         //interfaceBaiduParams.setLanguage("English");
  134.                         txtResult.setText("click 'start'");
  135.                         btn.setText("start");
  136.                         break;
  137.                     // 四川话
  138.                     case 2:
  139.                         //interfaceBaiduParams.setLanguage("SiChuanHua");
  140.                         txtResult.setText("点击‘开始’");
  141.                         btn.setText("开始");
  142.                         break;
  143.                     //粤语
  144.                     case 3:
  145.                         //interfaceBaiduParams.setLanguage("YueYu");
  146.                         txtResult.setText("点击‘开始’");
  147.                         btn.setText("开始");
  148.                         break;
  149.                 }
  150.             }
  151.  
  152.             @Override
  153.             public void onNothingSelected(AdapterView<?> parent) {
  154.  
  155.             }
  156.         });
  157.     }
  158.  
  159.     @Override
  160.     public void test(String str) {
  161.  
  162.     }
  163.  
  164.     private class MyServiceConnection implements ServiceConnection {
  165.         @Override
  166.         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
  167.  
  168.             asRresultAIDL = ASRresultAIDL.Stub.asInterface(iBinder);
  169.             System.out.println("绑定服务成功了");
  170.         }
  171.  
  172.         @Override
  173.         public void onServiceDisconnected(ComponentName componentName) {
  174.             System.out.println("解绑服务成功了");
  175.  
  176.         }
  177.     }
  178.  
  179. }

（5）ASRresultAIDL.aidl：开放服务里面的方法，供其他应用调用

  1. // ASRresultAIDL.aidl
  2. package aoto.com.baidurecongdemo;
  3.  
  4. // Declare any non-default types here with import statements
  5. interface ASRresultAIDL {
  6.  String getASRResult();
  7.  void callStart();
  8.  void callStop();
  9. }

（6）build.gradle：

  1. apply plugin: 'com.android.application'
  2.  
  3. android {
  4.     compileSdkVersion 26
  5.     defaultConfig {
  6.         applicationId "aoto.com.baidurecongdemo"
  7.         minSdkVersion 21
  8.         targetSdkVersion 26
  9.         versionCode 1
  10.         versionName "1.0"
  11.         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
  12.         //加载对应so文件
  13.         ndk{
  14.             abiFilters 'armeabi'
  15.         }
  16.     }
  17.     buildTypes {
  18.         release {
  19.             minifyEnabled false
  20.             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
  21.         }
  22.     }
  23. }
  24.  
  25. dependencies {
  26.     implementation fileTree(include: ['*.jar'], dir: 'libs')
  27.     implementation 'com.android.support:appcompat-v7:26.1.0'
  28.     implementation 'com.android.support.constraint:constraint-layout:1.0.2'
  29.     testImplementation 'junit:junit:4.12'
  30.     androidTestImplementation 'com.android.support.test:runner:1.0.1'
  31.     androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'
  32.     implementation files('libs/bdasr_V3_20171108_9800a2a.jar')
  33.     implementation files('libs/usc.jar')
  34.  
  35. }

3，注意事项：

（1）云知声离线TTSso文件不是X86的，所以window下的x86模拟器是用不了的，但是在window系统下运行arm的模拟器很卡，所以建议真机调试

（2）我这里在百度语音识别的地方只是实现了最简单的语音识别调用流程，很多的参数没有使用，学习者可以自己完善和添加

（3）我这里只添加了百度armeabi下的so文件，所以在gradle文件用ndk指定了（ndk已经安装），也可以什么都不加

（4）我这里主要是实现了一个复读机的功能，你说什么，那边会把识别文本语音合成播放出来，可以自己选择音色

（5）我这里百度开发了四种语言语音识别

注：欢迎扫码关注

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/471667
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号