private void GetPCMData()
        {
            MTTSConfig config = new MTTSConfig();

            config.speed   = sld_Speed.Value;
            config.volume  = PublicFunction.intParse(sld_Volumn.Value);
            config.useSSML = 0;
            string ttsResConfig = JsonHelper.ToJson(manager.TTSResConfig);
            int    result       = DUILiteHelper.DUILiteNativeTTSNew(ttsResConfig);
            //string ttsstartparam = "{\"speed\":1.0,\"volume\":80,\"useSSML\":0}";
            string ttsConfig = JsonHelper.ToJson(config);

            result = DUILiteHelper.DUILiteNativeTTSStart(ttsConfig);
            string text = string.Empty;

            if (string.IsNullOrEmpty(tb_TTSText.Text))
            {
                text = "明天苏州的天气怎么样";
            }
            else
            {
                text = tb_TTSText.Text;
            }
            byte[] bytes = Encoding.UTF8.GetBytes(text);
            App.IsNewTTS = true;
            result       = DUILiteHelper.DUILiteNativeTTSFeed(bytes);
            result       = DUILiteHelper.DUILiteNativeTTSRelease();
        }
 private void ReleaseDUILite()
 {
     //DUILiteHelper.DUILiteWakeupStop();
     //DUILiteHelper.DUILiteWakeupRelease();
     //DUILiteHelper.DUILiteCloudASRStop();
     //DUILiteHelper.DUILiteCloudASRRelease();
     //DUILiteHelper.DUILiteNativeTTSRelease();
     DUILiteHelper.DUILiteAuthRelease();
 }
        private void tbtn_ASR_Unchecked(object sender, RoutedEventArgs e)
        {
            UpdateRelateStartUI(true);
            switch (manager.ASRNet)
            {
            case ENet.Cloud:
                switch (manager.ASRMode)
                {
                case EASRMode.Wakeup:
                    DUILiteHelper.DUILiteCloudASRStop();
                    DUILiteHelper.DUILiteCloudASRRelease();
                    DUILiteHelper.DUILiteWakeupStop();
                    DUILiteHelper.DUILiteWakeupRelease();
                    break;

                case EASRMode.UnWakeup:
                    DUILiteHelper.DUILiteCloudASRStop();
                    DUILiteHelper.DUILiteCloudASRRelease();
                    break;
                }
                break;

            case ENet.Native:
                switch (manager.ASRMode)
                {
                case EASRMode.Wakeup:
                    DUILiteHelper.DUILiteNativeASRStop();
                    DUILiteHelper.DUILiteNativeASRRelease();
                    DUILiteHelper.DUILiteWakeupStop();
                    DUILiteHelper.DUILiteWakeupRelease();
                    break;

                case EASRMode.UnWakeup:
                    DUILiteHelper.DUILiteNativeASRStop();
                    DUILiteHelper.DUILiteNativeASRRelease();
                    break;
                }
                break;
            }
        }
        public void DUILiteConfig()
        {
            string strconfig = JsonHelper.ToJson(Config);

            DUILiteHelper.DUILiteConfig(strconfig);
        }
        public void DUILiteLogInit()
        {
            string logConfig = JsonHelper.ToJson(LogConfig);

            DUILiteHelper.DUILiteLogInit(logConfig);
        }
        private void StartASR()
        {
            UpdateRelateStartUI(false);
            btn_Clear_Click(null, null);
            int result = -2;

            if (!Directory.Exists(PathHelper.DirAiSpeechDemo))
            {
                Directory.CreateDirectory(PathHelper.DirAiSpeechDemo);
            }
            using (FileStream fs = new FileStream(PathHelper.DirAiSpeechDemo + "local.net.bin", FileMode.OpenOrCreate))
            {
            };
            switch (manager.ASRNet)
            {
            case ENet.Cloud:
                switch (manager.ASRMode)
                {
                case EASRMode.Wakeup:
                    DUILiteHelper.DUILiteCloudASRNew();
                    DUILiteHelper.DUILiteCloudASRStart(null);
                    DUILiteHelper.DUILiteCloudASRStop();
                    string wakeupConfig = JsonHelper.ToJson(manager.WakeupConfig);
                    result = DUILiteHelper.DUILiteWakeupNew(wakeupConfig);
                    string wakeupParam = JsonHelper.ToJson(manager.WakeupParam);
                    result = DUILiteHelper.DUILiteWakeupStart(wakeupParam);
                    break;

                case EASRMode.UnWakeup:
                    DUILiteHelper.DUILiteCloudASRNew();
                    DUILiteHelper.DUILiteCloudASRStart(null);
                    break;
                }

                break;

            case ENet.Native:
                string gramcfg   = JsonHelper.ToJson(manager.NASRGramConfig);
                string gramparam = JsonHelper.ToJson(manager.NASRParam);
                string asrcfg    = JsonHelper.ToJson(manager.NASRConfig);

                //string gramcfg = "{\"resBinPath\":\"./res/nativeASR/gram/ebnfc.aicar.1.2.0.bin\"}";
                //string gramparam = "{\"outputPath\": \"./local.net.bin\", \"ebnfFile\": \"./res/nativeASR/gram/gram.xbnf\"}";
                //string asrcfg = "{\"resBinPath\":\"./res/nativeASR/gram/ngram.xinhangye.v0.1.bin\", \"netBinPath\": \"./local.net.bin\"}";
                switch (manager.ASRMode)
                {
                case EASRMode.Wakeup:

                    string wakeupConfig = JsonHelper.ToJson(manager.WakeupConfig);
                    result = DUILiteHelper.DUILiteWakeupNew(wakeupConfig);
                    string wakeupParam = JsonHelper.ToJson(manager.WakeupParam);
                    result = DUILiteHelper.DUILiteWakeupStart(wakeupParam);

                    if (!IsExistGram)
                    {
                        result = DUILiteHelper.DUILiteNativeASRNew(null, null, "{\"resBinPath\":\"./res/nativeASR/gram/ngram.xinhangye.v0.1.bin\"}");
                    }
                    else
                    {
                        result = DUILiteHelper.DUILiteNativeASRNew(gramcfg, gramparam, asrcfg);
                    }
                    if (App.DUIManager.ASRLanguage == EASRLanguage.English)
                    {
                        //string enConfig = JsonHelper.ToJson(manager.EnNASRConfig);
                        //string enConfig = "{\"env\": \"use_xbnf_rec=1;use_frame_split=1;hold_conf=1;\"}";
                        result = DUILiteHelper.DUILiteNativeASRStart(englishConfig);
                    }
                    else
                    {
                        result = DUILiteHelper.DUILiteNativeASRStart(JsonHelper.ToJson(manager.EnNASRConfig));
                    }
                    DUILiteHelper.DUILiteNativeASRStop();
                    tb_ARS.Clear();
                    break;

                case EASRMode.UnWakeup:
                    if (!IsExistGram)
                    {
                        result = DUILiteHelper.DUILiteNativeASRNew(null, null, "{\"resBinPath\":\"./res/nativeASR/gram/ngram.xinhangye.v0.1.bin\"}");
                    }
                    else
                    {
                        result = DUILiteHelper.DUILiteNativeASRNew(gramcfg, gramparam, asrcfg);
                    }

                    //result = DUILiteHelper.DUILiteNativeASRNew(gramcfg, gramparam, asrcfg);
                    if (App.DUIManager.ASRLanguage == EASRLanguage.English)
                    {
                        //string enConfig = JsonHelper.ToJson(manager.EnNASRConfig);
                        //string enConfig = "{\"env\": \"use_xbnf_rec=1;use_frame_split=1;hold_conf=1;\"}";
                        result = DUILiteHelper.DUILiteNativeASRStart(englishConfig);
                    }
                    else
                    {
                        var a = JsonHelper.ToJson(manager.EnNASRConfig);
                        result = DUILiteHelper.DUILiteNativeASRStart(JsonHelper.ToJson(manager.EnNASRConfig));
                    }
                    break;
                }
                break;
            }
        }
        private int engine_callback(string userdata, int type, IntPtr msg, int len)
        {
            EEventReturn etype = (EEventReturn)type;

            if (etype == EEventReturn.DUILITE_EV_OUT_AUTH_COMPLETE)
            {
                IsAuth = true;
                //auth_status = 1;
                //printf("%s, auth result: %.*s\n", tag, len, msg);
            }
            if (etype == EEventReturn.DUILITE_EV_OUT_CLOUD_ASR_FINAL_RESULT)
            {
                IsASRStop = true;

                byte[] managedArray = new byte[len];
                Marshal.Copy(msg, managedArray, 0, len);
                string result = Encoding.UTF8.GetString(managedArray);
                //OrginalString = manager.OutResult.ARSRealTimeOut;
                manager.OutResult.ARSRealTimeOut = OrginalString + result;
                this.Dispatcher.BeginInvoke((Action) delegate()
                {
                    if (App.DUIManager.ASRMode == EASRMode.UnWakeup)
                    {
                        tbtn_ASR.IsChecked = false;
                    }
                });
            }
            if (etype == EEventReturn.DUILITE_EV_OUT_CLOUD_ASR_REALBACK_RESULT)
            {
                byte[] managedArray = new byte[len];
                Marshal.Copy(msg, managedArray, 0, len);
                string strInTime = Encoding.UTF8.GetString(managedArray);
                if (manager.OutResult == null)
                {
                    manager.OutResult = new Model.DUI.MOut();
                }
                manager.OutResult.ARSRealTimeOut = OrginalString + strInTime;
                //manager.OutResult.ARSRealTimeOut = strInTime;
                //printf("%s, Cloud ASR result: %.*s\n", tag, len, msg);
                //cloud_asr_status = 1;
            }
            if (etype == EEventReturn.DUILITE_EV_OUT_NATIVE_VAD_AUDIO)
            {
                //    FILE* audio = NULL;
                //    int w_len = 0;

                //    int ret = 0;

                //    if (len == 0)
                //    {
                //        goto vadend;
                //    }

                //    audio = fopen("./vad.pcm", "ab+");
                //    if (NULL == audio)
                //    {
                //        printf("create file error!\n");
                //        goto vadend;
                //    }

                //    w_len = fwrite(msg, 1, len, audio);
                //    if (w_len != len)
                //    {
                //        printf("write audio file error!\n");
                //    }
                //    else
                //    {
                //        printf("write audio file!\n");
                //    }
                //    fclose(audio);
                //    audio = NULL;
                //vadend:
                //    return ret;
            }
            if (etype == EEventReturn.DUILITE_EV_OUT_NATIVE_VAD_BEGIN)
            {
                //printf("%s, native VAD begin: %.*s\n", tag, len, msg);
            }
            if (etype == EEventReturn.DUILITE_EV_OUT_NATIVE_VAD_END)
            {
                //printf("%s, native VAD end: %.*s\n", tag, len, msg);
            }

            if (etype == EEventReturn.DUILITE_EV_OUT_NATIVE_TTS_AUDIO)
            {
                using (FileStream fs = new FileStream("native_cntts.pcm", FileMode.OpenOrCreate))
                {
                }
                if (App.IsNewTTS)
                {
                    using (FileStream fs = new FileStream("native_cntts.pcm", FileMode.Truncate))
                    {
                        byte[] managedArray = new byte[len];
                        Marshal.Copy(msg, managedArray, 0, len);
                        foreach (byte b in managedArray)
                        {
                            fs.WriteByte(b);
                        }
                        App.IsNewTTS = false;
                        return(0);
                    }
                }
                else
                {
                    using (FileStream fs = new FileStream("native_cntts.pcm", FileMode.Append))
                    {
                        byte[] managedArray = new byte[len];
                        Marshal.Copy(msg, managedArray, 0, len);
                        foreach (byte b in managedArray)
                        {
                            fs.WriteByte(b);
                        }
                        return(0);
                    }
                }
            }
            if (etype == EEventReturn.DUILITE_EV_OUT_NATIVE_TTS_BEGIN)
            {
                //printf("%s, native TTS begin: %.*s\n", tag, len, msg);
            }
            if (etype == EEventReturn.DUILITE_EV_OUT_NATIVE_TTS_END)
            {
                //printf("%s, native TTS end: %.*s\n", tag, len, msg);
                //native_tts_status = 1;
            }

            if (etype == EEventReturn.DUILITE_EV_OUT_CLOUD_TTS_RESULT)
            {
                byte[] managedArray = new byte[len];
                Marshal.Copy(msg, managedArray, 0, len);
                string url = Encoding.UTF8.GetString(managedArray);
                PlayCloudAudio(url);
            }

            if (etype == EEventReturn.DUILITE_EV_OUT_ERROR)
            {
                //printf("%s, error: %.*s\n", tag, len, msg);
                //error_status = 1;
            }

            if (etype == EEventReturn.DUILITE_EV_OUT_WAKEUP_RESULT)
            {
                if (!IsASRStop)
                {
                    return(0);
                }
                IsWakeup = true;
                byte[] managedArray = new byte[len];
                Marshal.Copy(msg, managedArray, 0, len);
                string strwakeup   = Encoding.UTF8.GetString(managedArray);
                var    returnParam = JsonHelper.Parse <MWakeReturn>(strwakeup);
                if (manager.OutResult == null)
                {
                    manager.OutResult = new Model.DUI.MOut();
                }
                if (string.IsNullOrEmpty(manager.OutResult.ARSRealTimeOut))
                {
                    manager.OutResult.ARSRealTimeOut += returnParam.wakeupWord + "\r\n";
                }
                else
                {
                    manager.OutResult.ARSRealTimeOut += "\r\n" + returnParam.wakeupWord + "\r\n";
                }
                OrginalString = manager.OutResult.ARSRealTimeOut;
                switch (App.DUIManager.ASRNet)
                {
                case ENet.Cloud:
                    DUILiteHelper.DUILiteCloudASRStart(null);
                    break;

                case ENet.Native:
                    if (App.DUIManager.ASRLanguage == EASRLanguage.English)
                    {
                        //string enConfig = JsonHelper.ToJson(manager.EnNASRConfig);
                        var result = DUILiteHelper.DUILiteNativeASRStart(englishConfig);
                    }
                    else
                    {
                        string enConfig = JsonHelper.ToJson(manager.EnNASRConfig);
                        var    result   = DUILiteHelper.DUILiteNativeASRStart(JsonHelper.ToJson(manager.EnNASRConfig));
                    }
                    break;
                }
                IsASRStop = false;
                //printf("%s, wakeup result: %.*s,\nuserdata:%s\n", tag, len, msg, (char*)userdata);
                //wakeup_status = 1;
            }

            if (etype == EEventReturn.DUILITE_EV_OUT_NATIVE_ASR_FINAL_RESULT)
            {
                IsASRStop = true;
                string wakeupParam = JsonHelper.ToJson(manager.WakeupParam);
                if (App.DUIManager.ASRMode == EASRMode.Wakeup)
                {
                    var sresult = DUILiteHelper.DUILiteWakeupStart(wakeupParam);
                }
                byte[] managedArray = new byte[len];
                Marshal.Copy(msg, managedArray, 0, len);
                string result = Encoding.UTF8.GetString(managedArray);
                if (IsExistGram)
                {
                    var           data = JsonHelper.Parse <MNativeASRReturn>(result);
                    StringBuilder sb   = new StringBuilder();
                    sb.Append("gram:");
                    sb.AppendLine();
                    sb.Append("置信度:" + data.grammar.conf);
                    sb.AppendLine();
                    sb.Append("结果:" + data.grammar.rec);
                    sb.AppendLine();
                    sb.Append("ngram:");
                    sb.AppendLine();
                    sb.Append("置信度:" + data.ngram.conf);
                    sb.AppendLine();
                    sb.Append("结果:" + data.ngram.rec);

                    manager.OutResult.ARSRealTimeOut = OrginalString + sb.ToString();
                    //manager.OutResult.ARSRealTimeOut = OrginalString + data.grammar.rec;
                }
                else
                {
                    var data = JsonHelper.Parse <Ngram>(result);
                    manager.OutResult.ARSRealTimeOut = OrginalString + data.rec;
                }
                this.Dispatcher.BeginInvoke((Action) delegate()
                {
                    if (App.DUIManager.ASRMode == EASRMode.UnWakeup)
                    {
                        tbtn_ASR.IsChecked = false;
                    }
                });
            }

            if (etype == EEventReturn.DUILITE_EV_OUT_NATIVE_ASR_REALBACK_RESULT)
            {
                byte[] managedArray = new byte[len];
                Marshal.Copy(msg, managedArray, 0, len);
                string strInTime = Encoding.UTF8.GetString(managedArray);
                if (manager.OutResult == null)
                {
                    manager.OutResult = new Model.DUI.MOut();
                }
                var data = JsonHelper.Parse <MNativeASRReturn>(strInTime);
                //if (IsExistGram)
                //{
                //    if (data.grammar != null)
                //    {
                //        manager.OutResult.ARSRealTimeOut = OrginalString + data.grammar.rec;
                //    }
                //}
                //else
                //{
                if (data.ngram != null)
                {
                    manager.OutResult.ARSRealTimeOut = OrginalString + data.ngram.rec;
                }
                //}

                //manager.OutResult.ARSRealTimeOut = OrginalString + strInTime;
            }

            return(0);
        }