定义

• 非确定型有穷自动机（NFA），在某状态下，对于指定的输入，存在多个转移状态。一般情况下，通过某种算法可转换为 DFA

• 上下文无关文法 描述程序设计语言的结构以及相关集合的重要记号，用来构造编译器的语法分析部件。

• 字母表 符号的有穷非空集合。用$\Sigma$表示

• 串（有时候称为单词）是从某个字母表中选择的符号的有穷序列。例如 01101 是从二进制字母表$\Sigma = \lbrace 0,1\rbrace$中选出的串

• 空串 出现 0 次符号的串，记做$\varepsilon$

• 串的长度 这个串中的符号数，记做$\vert \omega \vert$，例如$\vert \varepsilon \vert = 0$

• 字母表的幂 定义$\Sigma^{k}$是长度为 k 的串的集合。串的每个符号都属于$\Sigma$。无论是什么字母表$\Sigma^{0}=\lbrace\varepsilon\rbrace$。字母表上所有的串的集合约定为$\Sigma^{*}$，排除空串的集合约定为$\Sigma^{+}$

• 串的连接 设定 x 和 y 都是串，于是 xy 表示 x 和 y 的连接

• 集合表示法 $\lbrace\omega\vert\omega$的语义描述$\rbrace$。比如$\lbrace\omega\vert\omega$包含相同个数的 0 或 1$\rbrace$，还可以把$\omega$换成某个带参数的表达式$\lbrace0^n1^n\vert n \ge1\rbrace$

• 当两个状态机交互时，当其状态处于$(i,x)$，对于一个合法的输入$Z$，可使$i \rightarrow j$，$x \rightarrow y$，那么我们可以认为$(i,x) \rightarrow (j,y)$是可达的

确定型有穷自动机（DFA）

确定型有穷自动机 包含若干个状态的集合，若干个输入符，当有输入时，控制权将由一个状态转移到另一个状态。在任意状态下，对于指定的输入，其转移是唯一的。

1. 一个有穷状态集合，记做$Q$，

2. 初始状态记做$q_0$,

3. 终止状态记做$F$

4. 一个有穷输入集合，记做$\Sigma$

5. 状态转移函数，记做$\delta$，以一个状态$q$和一个输入符号$a$作为参数，返回一个状态$p$。$\delta(q,a) = p;p\in Q$

6. 扩展状态转移函数，记做$\hat{\delta}$，以一个状态$q$和一个输入串$\omega$作为参数，返回一个状态$p$。
   • $\hat{\delta}(q,\varepsilon)=q$
   • 假定$\omega = xa$，a 是最后的输入，$\hat{\delta}(q,\omega)=\delta(\hat{\delta}(q,x),a)$

DFA 的定义: $A = (Q,\Sigma,\delta,q_0,F)$

对于所有 DFA，我们可以定义为 $L(A) = \lbrace \omega|\hat{\delta}(q_0,\omega) \in F\rbrace$

例如$\lbrace\omega|\omega$出现 01 字符串$\rbrace$可能出现三个状态

1. $q_0$ 未遇到 01，且最后一个不为 0，$\delta(q_0,0)=q_1,\delta(q_0,1)=q_0$
2. $q_1$ 未遇到 01，且最后一个为 0，$\delta(q_1,0)=q_1,\delta(q_0,1)=q_2$
3. $q_2$ 已遇到 01，可接受任意 0 或 1，$\delta(q_2,0)=q_2,\delta(q_2,1)=q_2$

其 DFA 表达式： $A = (\lbrace q_0,q_1,q_2\rbrace,\lbrace 0,1\rbrace,\delta,q_0,{q_2})$

对 DFA 的细节描述难以阅读，通常使用两种方式来更好的描述

1. 状态转移图

      graph LR;
   begin( )-->|Start|q0
   q0-->|0|q1
   q0-->|1|q0
   q1-->|0|q1
   q1-->|1|q2
   q2-->|0,1|q2
   style begin color:white,fill:white,stroke:white

2. 状态转移表，一个状态和输入组成的$\delta$的表

   	0	1
   $\rightarrow q_0$	$q_1$	$q_0$
   $q_1$	$q_1$	$q_2$
   $q_2$	$q_2$	$q_2$

使用扩展转移函数，对一个串 0011 进行计算

1. $\hat{\delta}(q_0,\varepsilon)=q_0$

2. $\hat{\delta}(q_0,0)=\delta(\hat{\delta}(q_0,\varepsilon),0) =\delta(q_0,0) = q_1$

3. $\hat{\delta}(q_0,00)=\delta(\hat{\delta}(q_0,0),0) =\delta(q_1,0) = q_1$

4. $\hat{\delta}(q_0,001)=\delta(\hat{\delta}(q_0,00),1) =\delta(q_1,1) = q_2$

5. $\hat{\delta}(q_0,0011)=\delta(\hat{\delta}(q_0,001),1) =\delta(q_2,1) = q_2$

这种方式的处理，非常适合我们用递归函数进行计算。

非确定型有穷自动机（NFA）

与确定型有穷自动机类似，包含若干个状态，若干个输入符，状态转移函数，终止状态。唯一不同的是，$\delta$的结果可能是零个、一个、或多个状态的集合。

1. 一个有穷状态集合，记做$Q$，

2. 初始状态记做$q_0$,

3. 终止状态记做$F$

4. 一个有穷输入集合，记做$\Sigma$

5. 状态转移函数，记做$\delta$，以一个状态$q$和一个输入符号$a$作为参数，返回一个状态$p$。$\delta(q,a) = \lbrace p1,p2,\cdots,p_k \rbrace;\lbrace p1,p2,\cdots,p_k \rbrace\in Q$

6. 扩展状态转移函数，记做$\hat{\delta}$，以一个状态$q$和一个输入串$\omega$作为参数，返回一个状态$p$。
   • $\hat{\delta}(q,\varepsilon)=q$
   • 假定$\omega = xa$，$\hat{\delta}(q,x)=\lbrace p_1,p_2,\cdots,p_k \rbrace$，那么$\hat{\delta}(q,\omega)=\displaystyle\bigcup_{i=1}^k\delta(p_i,a)=\lbrace r_1,r_2,\cdots,r_m \rbrace$

对于 NFA，可以定义为 $L(A) = \lbrace \omega|\hat{\delta}(q_0,\omega) \cap F\rbrace \ne \emptyset$

例如，$\lbrace \lbrace0,1\rbrace|$以 01 结尾$\rbrace$

其状态转移图如下

graph LR;
begin( )-->|Start|q0
q0-->|0|q1
q0-->|0,1|q0
q1-->|1|q2
style begin color:white,fill:white,stroke:white

当接受到 0 时，NFA 会猜测最后的 01 已经开始了，一条弧线从$q_0$指向$q_1$，我们可以看到 0 有两条弧线，另一条指向$q_0$。NFA 会同时走这两条线。当在$q_1$状态时，它会检查下一个符号是否为 1，如果是则会进入状态$q_2$。当在$q_2$状态时，如还有其他输入，这条路线就终结掉了。

00101 的处理过程如下

其状态转移表如下

使用扩展转移函数的处理过程如下

1. $\hat{\delta}(q_0,\varepsilon)=\lbrace q_0\rbrace$

2. $\hat{\delta}(q_0,0)=\delta(q_0,0) = \lbrace q_0,q_1\rbrace$

3. $\hat{\delta}(q_0,00)=\delta(q_0,0) \cup \delta(q_1,0)= \lbrace q_0\rbrace \cup \lbrace q_2\rbrace=\lbrace q_0,q_1\rbrace$

4. $\hat{\delta}(q_0,001)=\delta(q_0,1) \cup \delta(q_1,1)= \lbrace q_0\rbrace \cup \lbrace q_2\rbrace=\lbrace q_0,q_2\rbrace$

5. $\hat{\delta}(q_0,0010)=\delta(q_0,0) \cup \delta(q_2,0)= \lbrace q_0,q_1\rbrace \cup \emptyset=\lbrace q_0,q_1\rbrace$

6. $\hat{\delta}(q_0,00101)=\delta(q_0,1) \cup \delta(q_1,1)= \lbrace q_0\rbrace \cup \lbrace q_2\rbrace=\lbrace q_0,q_2\rbrace$

NFA 与 DFA 的转换

通常来说，构造 NFA 比构造 DFA 更容易，每一个用 NFA 描述的语言也能用 DFA 来描述。这个可以用子集构造来证明。

子集构造从一个 NFA $N = (Q_n,\Sigma,\delta_n,q_0,F_n)$开始，转换为 $D = (Q_d,\Sigma,\delta_d,\lbrace q_0 \rbrace,F_d)$

1. 两个自动机的输入字母表是相同的
2. D 的起始状态为仅包含 N 的起始状态的长度为 1 的集合
3. $Q_d$是$Q_n$子集的集合，即幂集合。假如$Q_n$有 n 个状态，那么$Q_d$有$2^n$状态，通常不是所有的状态都是从$q_0$可达的，这些状态可以丢弃，所以实际上$Q_d$的状态要远远小于$2^n$
4. $F_D$所有满足$S\cap F_n \neq \emptyset$的$Q_n$的子集的集合 S，也就是说，$F_D$是$Q_N$状态子集中至少包含一个$F_N$的集合。
5. 对于$S \subseteq Q_n$的集合 S 中每个状态来说，其对应的每个属于$\Sigma$的输入符号$a$的转移函数为： $\delta_D(S,a)= \bigcup_{p \in S} \delta_N(p,a)$

示例，我们以接受所有 01 结尾的串的 NFA 向 DFA 转换，由于$Q_n = \lbrace q_0,q_1,q_2\rbrace$，所以子集构造产生一个带有$2^3 = 8$(并非所有状态都是有意义的)种状态的 DFA

上述表格的详细证明如下（列举 2、5 两行）：

• $\delta_D(\lbrace q_0\rbrace,0) = \delta_N(q_0,0) = \lbrace q_0,q_1\rbrace$

• $\delta_D(\lbrace q_0\rbrace,1) = \delta_N(q_0,1) = \lbrace q_0\rbrace$

• $\delta_D(\lbrace q_0,q_1\rbrace,0) = \delta_N(q_0,0) \cup \delta_N(q_1,0) = \lbrace q_0,q_1\rbrace \cup \emptyset = \lbrace q_0,q_1\rbrace$

• $\delta_D(\lbrace q_0,q_1\rbrace,1) = \delta_N(q_0,1) \cup \delta_N(q_1,1) = \lbrace q_0\rbrace \cup \lbrace q_2\rbrace= \lbrace q_0,q_2\rbrace$

我们给这 8 中状态设计新的名字，如$A$表示$\emptyset$，$B$表示$\lbrace q_0 \rbrace$等。

从状态 B 开始，只能到达状态 B、E 和 F。其余五种状态都是从初始状态不可达的，也可以不出现在表中。如果向下面这样在子集合中执行惰性求值，通常就能避免以指数时间步骤为每个状态子集合构造转移表项目。一般情况下，我们可以从初始状态 A 开始计算可到达状态，若有新的可达状态，我们继续计算，直到没有新的可达状态。

graph LR;
begin( )-->|Start|B
B-->|0|E
B-->|1|B
E-->|0|E
E-->|1|F
F-->|0|E
F-->|1|B
style begin color:white,fill:white,stroke:white

我们需要证明这个子集构造是正确的。

在读入输入符号序列$\omega$后，所构造的 DFA 处于这样一个状态，这个状态时 NFA 在读$\omega$后所处的状态的集合。由于 DFA 的接受状态是至少包含一个 NFA 接受状态$F_n$的集合，因为包含 NFA 的可接受状态$F_n$，因此这个集合也是被 NFA 接受的。于是我们可以得出结论，这个 DFA 和 NFA 接受完全相同的语言。

我们来证明 若$D = (Q_d,\Sigma,\delta_d,\lbrace q_0 \rbrace,F_d)$是从$N = (Q_n,\Sigma,\delta_n,q_0,F_n)$子集构造出来的，那么$L(D) = L(N)$，这也就是证明，对于输入字母表$\omega$ ，$\hat{\delta}(\lbrace q_0\rbrace,\omega) = \hat{\delta}(q_0,\omega)$

1. 当$|\omega| =0$，即$\omega = \varepsilon$，根据$\hat{\delta}$的定义，$\hat{\delta}(\lbrace q_0\rbrace,\varepsilon)$ $\hat{\delta}(q_0,\varepsilon)$的结果都为$\lbrace q_0 \rbrace$

2. 假定$|\omega| = n + 1$ ，$\omega = xa$，$|x| = n$，$\hat{\delta}(\lbrace q_0\rbrace,x) = \hat{\delta}(q_0,x)$成立，两个集合状态 N 为$\lbrace p_1,p_2,\cdots,p_k\rbrace$。

   那么对于 NFA：

   $\hat{\delta}_N(q_0,\omega)=\displaystyle\bigcup_{i=1}^k\delta_N(p_i,a)$

   通过子集构造的定义我们可以得出

   $\delta_D(\lbrace p_1,p_2,\cdots,p_k\rbrace,a)=\displaystyle\bigcup_{i=1}^k\delta_N(p_i,a)$

   又因 $\delta_D(\lbrace q_0\rbrace,x)= \lbrace p_1,p_2,\cdots,p_k\rbrace$

   $\hat{\delta_D}(\lbrace q_0\rbrace,w) = \delta_D(\hat{\delta_D}(\lbrace q_0\rbrace,x),a) =\delta_D( \lbrace p_1,p_2,\cdots,p_k\rbrace,a)=\displaystyle\bigcup_{i=1}^k\delta_N(p_i,a)$

文本搜索

识别 web 和 ebay 出现

通过 NFA 来实现

对终止状态[4,8]增加了回到1的转移，以支持 web 和 ebay 出现在中间位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

//识别单词web和ebay出现的NFA

//状态转移函数
var delta = {
  1: (a) => {
    if (a == "w") return [1, 2];
    else if (a == "e") return [1, 5];
    else return [1];
  },
  2: (a) => (a === "e" ? [3] : []),
  3: (a) => (a === "b" ? [4] : []),
  4: (a) => [1, 4],
  5: (a) => (a === "b" ? [6] : []),
  6: (a) => (a === "a" ? [7] : []),
  7: (a) => (a === "y" ? [8] : []),
  8: (a) => [1, 8],
};

//所有状态
Qn = [1, 2, 3, 4, 5, 6, 7, 8];
//初始状态
q0 = 1;
//终止状态
F = [4, 8];

//扩展状态转移函数
function hat_delat(q0, w) {
  if (typeof w === "string") {
    w = w.split("");
  }
  //ε的总是返回当前状态
  if (w.length === 0) {
    return [q0];
  }
  let result = [];
  //ω=xa，将结果并集
  hat_delat(q0, w.slice(0, -1)).forEach((q) => {
    let a = w[w.length - 1];
    let next = delta[q](a);
    //去重合并
    next
      .filter((item) => !result.includes(item))
      .forEach((item) => result.push(item));
  });
  return result;
}

console.log(hat_delat(q0, "webay"));
console.log(hat_delat(q0, "aebay"));
console.log(hat_delat(q0, "abc"));

通过子集构造的方式来转换为 DFA，省略[4,8]的1出口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//状态转移函数
var delta = {
  1: (a) => {
    if (a == "w") return [1, 2];
    else if (a == "e") return [1, 5];
    else return [1];
  },
  2: (a) => (a === "e" ? [3] : []),
  3: (a) => (a === "b" ? [4] : []),
  4: (a) => [],
  5: (a) => (a === "b" ? [6] : []),
  6: (a) => (a === "a" ? [7] : []),
  7: (a) => (a === "y" ? [8] : []),
  8: (a) => [],
};

//所有状态
Qn = [1, 2, 3, 4, 5, 6, 7, 8];
//初始状态
q0 = 1;
//终止状态
F = [4, 8];

//由NFA状态子集构成的DFA状态集合
DFA = {};

//输入字母表为26个字母
E = "qwertyuiopasdfghjklzxcvbnm".split("");

//为Array添加equal方法，判断内部元素是否相同
Array.prototype.equal = function (other) {
  if (this.length == other.length) {
    let equal = true;
    for (let i = 0; i < other.length; i++) {
      if (this[i] !== other[i]) {
        equal = false;
        break;
      }
    }
    return equal;
  } else {
    return false;
  }
};
//为Array添加去重函数，若内部元素为数组，则根据内部数组元素是否完全相同来去重
Array.prototype.unique = function () {
  let temp = [];
  for (let i = 0; i < this.length; i++) {
    let insert = true;
    var item = this[i];
    if (Array.isArray(item)) {
      for (let j = 0; j < temp.length; j++) {
        if (temp[j].equal(item)) {
          insert = false;
        }
      }
    } else {
      insert = temp.indexOf(item) == -1;
    }
    if (insert) {
      temp.push(item);
    }
  }
  return temp;
};

//子集构造
function sub_construct(state_arr) {
  if (state_arr.length === 0) {
    return;
  }
  let trans = DFA[state_arr];
  //已经计算过的子集不在计算
  if (trans == undefined) {
    trans = [];
    E.forEach((a) => {
      //根据子集构造的定义，DFA子集构造的转移函数，对于特定输入，state_arr的所有状态的转移函数结构的集合

      let dfa_of_state_arr = [];
      state_arr.forEach((state) => {
        dfa_of_state_arr = dfa_of_state_arr.concat(delta[state](a));
      });
      trans.push(dfa_of_state_arr.sort().unique());
    });

    trans = trans.sort().unique();
    DFA[state_arr] = trans;
    //检查是否触发了新的DFA状态，如果有，则继续向前查找
    trans.forEach((dfa_of_state_arr) => {
      sub_construct(dfa_of_state_arr);
    });
  }
}

sub_construct([q0]);
console.log(DFA);

//子集构造完成后，我们就可以构建出扩展转移函数
function hal_delta(q_arr, w) {
  if (typeof w === "string") {
    w = w.split("");
  }
  if (w.length === 0) {
    return q_arr;
  }
  let result = [];
  //  ω=xa，将结果并集
  hal_delta(q_arr, w.slice(0, -1)).forEach((q) => {
    let a = w[w.length - 1];
    let next = delta[q](a);
    //去重合并
    next.forEach((item) => result.push(item));
  });
  return result.sort().unique();
}

console.log(hal_delta([q0], "webay"));

上述输出结果为，与例图完美对应

1
2
3
4
5
6
7
8
9
10
11
12
13

{
  "1": [[1], [1, 2], [1, 5]],
  "1,2": [[1], [1, 2], [1, 3, 5]],
  "1,3,5": [[1], [1, 2], [1, 4, 6], [1, 5]],
  "1,4,6": [[1], [1, 2], [1, 5], [1, 7]],
  "1,5": [[1], [1, 2], [1, 5], [1, 6]],
  "1,6": [[1], [1, 2], [1, 5], [1, 7]],
  "1,7": [[1], [1, 2], [1, 5], [1, 8]],
  "1,8": [[1], [1, 2], [1, 5]]
}

//扩展转移函数的输出
[(1, 8)]

凡涉及到内存共享、共享文件以及共享任何资源的情况都会引起竞争条件。我们需要阻止多个进程同时读写共享数据，换言之，我们需要的是互斥，即已某种手段确定当一个进程在使用一个共享变量或文件时，其他进程不能做同样的操作。

避免竞争条件的问题也可以用一种抽象的方式进行描述。一个进程的一部分时间做内部计算或另外一些不会引起竞争条件的操作，另一部分时间可能需要访问共享内存或共享文件，或执行另外一些可能导致竞争条件的操作。我们把对共享内存进行访问的程序片段称作临界区。如果我们能够适当的安排，使得两个进程不可能同时处于临界区，就能够避免竞争条件。

一个好的解决方案，需要满足以下四个条件：

1. 任何两个进程不能同时出去其临界区
2. 不应对 CPU 的速度和数量做任何假设
3. 临界区外运行的进程不得阻塞其他进程
4. 不得使进程无期限等待进入临界区

原子操作：是指一组相关联的操作要么都不间断地执行，要么都不执行。 信号量：使用一个整型变量来累计唤醒次数。对一信号量执行 down 操作，则是检查其值是否大于 0，若是则减一，否则进程将睡眠，检测数值、修改变量值以及可能的睡眠操作需要确保是原子操作。up 操作对信号量的值增 1。如果一个或多个进程在该信号上睡眠，无法完成一个先前的 down 操作，则有系统选择其中的一个并允许该进程完成它的 down 操作。于是，对一个有进程在其上睡眠的信号量执行了一次 up 操作之后，该信号量的值仍旧是 0，但在其上睡眠的进程却少了一个。信号量的值增 1 和唤醒其他进程操作也是不可分割的，是原子操作。 互斥量：一个可以处于两态之一的变量，解锁和加锁

wireshark 显示过滤器表达式是根据协议+.+属性来判断的。

基础使用的官方文档

全部的协议属性列表见官方文档

各种协议的wiki 地址

过滤器表达式基本语法

数字值可以使用十进制、八进制、十六进制

1
2
3

ip.len le 1500
ip.len le 02734
ip.len le 0x5dc

布尔类型的值可以使用1(true),0(false)

网络地址可以使用:,.,-分割

1
2
3
4

eth.dst == ff:ff:ff:ff:ff:ff
eth.dst == ff-ff-ff-ff-ff-ff
eth.dst == ffff.ffff.ffff
ip.addr == 192.168.0.1

可以比较字符串

1
2

http.request.uri == "https://www.wireshark.org/"
udp contains 81:60:03

过滤器表达式组合语法

一些示例

1
2
3
4
5
6
7
8
9
10

eth.src[0:3] == 00:00:83
eth.src[2] == 83

tcp.port in {80 443 8080}
# 等效于
tcp.port == 80 || tcp.port == 443 || tcp.port == 8080

tcp.port in {443 4430..4434}
#不等效于，因为port指代的可能是source，也可能是destination，而下述的每个判断是分别进行的
tcp.port == 443 || (tcp.port >= 4430 && tcp.port <= 4434)

概述

MRCP 是一个标准、统一、可扩展的媒体资源控制协议，主要用来语音识别、TTS 合成、录音、 声纹识别（确认是否为某一类群体），声纹认证。MRCP 是一个框架，同时也是一个协议。该框架定义了它的网络基本组件及相互关系。它使用 SIP 协议来控制会话管理，使用 RTP 进行媒体流传输。它的协议定义了它如何控制媒体资源的过程。 MRCP 是基于文本的协议，与 HTTP、SIP 的结构类似

结构

MRCP 允许客户端请求和控制网路上指定的媒体服务，使用媒体服务的客户端通常包括：

• IVR 平台
• 高级媒体网关
• 基于 IP 的媒体服务端

客户端一般需要有

1. 定位和发现媒体资源服务端
2. 与媒体资源服务建立消息 channel
3. 远程控制媒体资源

MRCP 通过 SIP URI 来确认媒体资源的 IP 地址，当找到合适的媒体资源服务，SIP 会在客户端和服务端建立两个消息管道，一个用来发送和接收音频流（又称媒体会话），另一个是客户端用来发送控制请求到媒体资源服务端、服务端响应并返回事件给客户端（又称控制会话，MRCP 协议建立在控制会话上）

媒体资源类型

报文

MRCP 消息分为三种类型，request、response、event。服务端接收到从客户端发送的 request 请求后，解析执行后返回一个 response 响应。response 包含一个三位数字的响应码（与 HTTP 的类似），另外还有包含当前 request 的状态（PENDING,IN-PROGRESS,COMPLETE）

• PENDING 表明客户端的 request 请求已经到达服务器，并添加到服务器的 FIFO 的处理队列中。
• IN-PROGRESS 表明客户端的 request 请求处于执行过程中。
• COMPLETE 表明客户端的 request 请求已经完成，没有后续消息

PENDING 和 IN-PROGRESS 都表明请求还未结束，还在等待其他 event 事件。通过 对特定 events 的响应服务端与客户端进行数据交互。

例如一个标准的 tts 播报过程

1
2
3
4
5
6
7
8
9
10
11
12

client                    TTS
  |                        |
  |        SPEAK           |
  |----------------------->|
  |                        |
  |    200(IN-PROGRESS)    |
  |<-----------------------|
  |                        |
  |SPEAK-COMPLETE(COMPLETE)|
  |<-----------------------|
  |                        |
  |                        |

其请求报文大致如下

1
2
3
4
5
6
7
8
9

MRCP/2.0 380 SPEAK 14321
Channel-Identifier: 43b9ae17@speechsynth
Content-Type: application/ssml+xml
Content-Length: 253

<?xml version="1.0" encoding="UTF-8"?>
<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis">
<emphasis>Good afternoon</emphasis> Anne.<break/> You have one voice message, two e-mails, and three faxes waiting for you.
</speak>

MRCP 的请求报文大体上可以分为三个部分

1. 请求行，每个字段以空格分隔，以换行（CRLF）结束，每个字段分别表示MRCP版本、请求报文长度、请求事件、请求id
2. 请求头 header-name:header-value CRLF格式，请求头结尾一定会有一个空行
3. 请求报文

1
2
3

MRCP/2.0 119 14321 200 IN-PROGRESS
Channel-Identifier: 43b9ae17@speechsynth
Speech-Marker: timestamp=857206027059

MRCP 的返回报文类似请求报文，返回行每个字段分别代表MRCP版本、返回报文长度、请求id、返回码、当前request状态。 IN-PROGRESS 状态一般表示 audio 流正在向客户端发送。

1
2
3
4

MRCP/2.0 157 SPEAK-COMPLETE 14321 COMPLETE
Channel-Identifier: 43b9ae17@speechsynth
Speech-Marker: timestamp=861500994355
Completion-Cause: 000 normal

当服务端执行到 COMPLETE 状态时，表明不在接收指定的 request 请求，则会返回一个包含 COMPLETE 的响应报文。此时返回行每个字段分别代表MRCP版本、返回事件、返回报文长度、请求id、当前request状态。

1
2
3

MRCP/2.0 111 START-OF-INPUT 32121 IN-PROGRESS
Channel-Identifier: 23af1e13@speechrecog
Input-Type: speech

其他有返回事件的返回行格式也是这样。

SIP in MRCP

MRCP 使用 SIP 协议在客户端与服务端进行通信。标准的三步INVITE-200 OK-ACK握手用来建立 media session 和 control session 连接。BYE-200 OK用来关闭连接。使用SDP offer/answer模型来进行协商

以下是 control channel 的一些 SDP 片段

1
2
3
4
5
6

c=IN IP4 10.0.0.1
m=application 9 TCP/MRCPv2
a=setup:active
a=connection:new
a=resource:speechsynth
a=cmid:1

SDP 是客户端请求服务端报文体重的一部分内容，比如包含在 INVITE 消息中。上述的例子，MRCP 向媒体服务器申请一个语音合成服务。

• c 行表示 IP 地址。
• m control session 包含一个或多个 m 行，其第一个字段为 application（对于 media session ，其值应为 audio）。每个 m 行代表一个 media 资源。TCP/MRCPv2表示使用 TCP 进行数据传输。端口号仅为0或9，0表示禁用，9表示暂未确定，将有服务端来确定。m 行下面的 a 行是对当前 m 行的属性进行设定。
• setup 客户端总是初始化为 active，服务端总是为 passive
• connection 是否新建 TCP 连接（new)，还是使用 已经存在的 TCP 连接（existing）
• resource 请求的媒体资源类型
• cmid control channel 到 media 流的一个标识，多个 contrl channel 可以使用同一个 cmid，这标识同一通会话可以多次使用同一个 media 流。

以下是 SIP 200 Ok 的响应报文的一些片段

1
2
3
4
5
6

c=IN IP4 10.0.0.22
m=application 43251 TCP/MRCPv2
a=setup:passive
a=connection:new
a=channel:43b9ae17@speechsynth
a=cmid:1

• m 这里就指定了将要使用的端口号

示例：

一个标准的单媒体资源请求服务

INVITE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

INVITE sip:mrcpv2@example.com SIP/2.0
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bKabc Max-Forwards: 70
To: <sip:mrcpv2@example.com>
From: <sip:client@example.com>;tag=12425
Call-ID: 43fb8aec@host1.example.com
CSeq: 1 INVITE
Contact: <sip:client@host1.example.com> Content-Type: application/sdp
Content-Length: 264

v=0
o=client 2890844527 2890844527 IN IP4 host1.example.com
s=-
c=IN IP4 host1.example.com
t=0 0
m=audio 5324 RTP/AVP 0
a=rtpmap:0 PCMU/8000
a=recvonly
a=mid:1
m=application 9 TCP/MRCPv2
a=setup:active
a=connection:new
a=resource:speechsynth
a=cmid:1

• 第一个 m 行建立 media 流
• 第二个 m 行连接 control session

200 OK

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

SIP/2.0 200 OK
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bKabc
;received=192.168.1.11
Max-Forwards: 70
To: <sip:mrcpv2@example.com>;tag=98452
From: <sip:client@example.com>;tag=12425
Call-ID: 43fb8aec@host1.example.com
CSeq: 1 INVITE
Contact: <sip:mrcpv2@host100.example.com>
Content-Type: application/sdp
Content-Length: 274

v=0
o=server 31412312 31412312 IN IP4 host100.example.com
s=-
c=IN IP4 host100.example.com
t=0 0
m=audio 4620 RTP/AVP 0
a=rtpmap:0 PCMU/8000
a=sendonly
a=mid:1
m=application 9001 TCP/MRCPv2
a=setup:passive
a=connection:new
a=channel:153af6@speechsynth
a=cmid:1

ACK

1
2
3
4
5
6
7
8

ACK sip:mrcpv2@host100.example.com SIP/2.0
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bK214 Max-Forwards: 70
To: <sip:mrcpv2@example.com>;tag=98452
From: <sip:client@example.com>;tag=12425
Call-ID: 43fb8aec@host1.example.com
CSeq: 1 ACK
Contact: <sip:mrcpv2@host1.example.com>
Content-Length: 0

添加和删除 media 资源

INVITE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

INVITE sip:mrcpv2@host100.example.com SIP/2.0
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bK452 Max-Forwards: 70
To: <sip:mrcpv2@example.com>;tag=98452
From: <sip:client@example.com>;tag=12425
Call-ID: 43fb8aec@host1.example.com CSeq: 2 INVITE
Contact: <sip:client@host1.example.com>
Content-Type: application/sdp
Content-Length: 367

v=0
o=client 2890844527 2890844528 IN IP4 host1.example.com
s=-
c=IN IP4 host1.example.com
t=0 0
m=audio 5324 RTP/AVP 0
a=rtpmap:0 PCMU/8000
a=sendrecv
a=mid:1
m=application 9 TCP/MRCPv2
a=setup:active
a=connection:existing
a=resource:speechsynth
a=cmid:1
m=application 9 TCP/MRCPv2
a=setup:active
a=connection:existing
a=resource:recorder
a=cmid:1

• 新申请一个 recorder 服务。SDP 全量更新 control session 和 media session 的，所以之前建立的 control session 是需要体现在当前的 SDP 内容中，当我们使用 recorder 服务，media 资源就需要保持双向连接（sendrecv），control session 的 connection 使用了现有的 control session 的 TCP 连接

200 OK

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

SIP/2.0 200 OK
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bK452;received=192.168.1.1
To: <sip:mrcpv2@example.com>;tag=98452
From: <sip:client@example.com>;tag=12425
Call-ID: 43fb8aec@host1.example.com CSeq: 2 INVITE
Contact: <sip:client@host1.example.com>
Content-Type: application/sdp
Content-Length: 387

v=0
o=client 31412312 31412313 IN IP4 host100.example.com
s=-
c=IN IP4 host100.example.com
t=0 0
m=audio 4620 RTP/AVP 0
a=rtpmap:0 PCMU/8000
a=sendrecv
a=mid:1
m=application 9001 TCP/MRCPv2
a=setup:passive
a=connection:existing
a=channel:153af6@speechsynth
a=cmid:1
m=application 9001 TCP/MRCPv2
a=setup:passive
a=connection:existing
a=channel: 153af6@recorder
a=cmid:1

ACK

1
2
3
4
5
6
7
8

ACK sip:mrcpv2@host100.example.com SIP/2.0
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bK554
Max-Forwards: 70
To: <sip:mrcpv2@example.com>;tag=98452
From: <sip:client@example.com>;tag=12425
Call-ID: 43fb8aec@host1.example.com
CSeq: 2 ACK
Contact: <sip:mrcpv2@host1.example.com> Content-Length: 0

INVITE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

INVITE sip:mrcpv2@host100.example.com SIP/2.0
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bK763 Max-Forwards: 70
To: <sip:mrcpv2@example.com>;tag=98452
From: <sip:client@example.com>;tag=12425
Call-ID: 43fb8aec@host1.example.com
CSeq: 3 INVITE
Contact: <sip:client@host1.example.com>
Content-Type: application/sdp
Content-Length: 367

v=0
o=client 2890844527 2890844529 IN IP4 host1.example.com
s=-
c=IN IP4 host1.example.com
t=0 0
m=audio 5324 RTP/AVP 0
a=rtpmap:0 PCMU/8000
a=recvonly
a=mid:1
m=application 9 TCP/MRCPv2
a=setup:active
a=connection:existing
a=resource:speechsynth
a=cmid:1
m=application 0 TCP/MRCPv2
a=setup:active
a=connection:existing
a=resource:recorder
a=cmid:1

• application 后的端口被设置 0，表示禁用

200 OK

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

SIP/2.0 200 OK
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bK763
;received=192.168.1.1
To: <sip:mrcpv2@example.com>;tag=98452 From: <sip:client@example.com>;tag=12425 Call-ID: 43fb8aec@host1.example.com CSeq: 3 INVITE
Contact: <sip:client@host1.example.com> Content-Type: application/sdp Content-Length: 384

v=0
o=client 31412312 31412314 IN IP4 host100.example.com s=-
c=IN IP4 host100.example.com
t=0 0
m=audio 4620 RTP/AVP 0
a=rtpmap:0 PCMU/8000
a=sendonly
a=mid:1
m=application 9001 TCP/MRCPv2
a=setup:passive
a=connection:existing
a=channel:153af6@speechsynth
a=cmid:1
m=application 0 TCP/MRCPv2
a=setup:passive
a=connection:existing
a=channel: 153af6@recorder
a=cmid:1

ACK

1
2
3
4
5
6
7
8

ACK sip:mrcpv2@host100.example.com SIP/2.0
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bK432
Max-Forwards: 70
To: <sip:mrcpv2@example.com>;tag=98452
From: <sip:client@example.com>;tag=12425
Call-ID: 43fb8aec@host1.example.com
CSeq: 3 ACK
Contact: <sip:mrcpv2@host1.example.com> Content-Length: 0

查询服务端支持的功能

OPTIONS

1
2
3
4
5
6
7
8
9
10

OPTIONS sip:mrcpv2@example.com SIP/2.0
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bKab3
Max-Forwards: 70
To: <sip:mrcpv2@example.com>
From: <sip:client@example.com>;tag=21342
Call-ID: 12fa3421@host1.example.com
CSeq: 21342 OPTIONS
Contact: <sip:client@host1.example.com>
Accept: application/sdp
Content-Length: 0

200 OK

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

SIP/2.0 200 OK
Via: SIP/2.0/UDP host1.example.com;branch=z9hG4bKab3
Max-Forwards: 70
To: <sip:mrcpv2@example.com>;tag=32421
From: <sip:client@example.com>;tag=21342
Call-ID: 12fa3421@host1.example.com
CSeq: 21342 OPTIONS
Contact: <sip:client@host99.example.com>
Allow: INVITE, BYE, OPTIONS, ACK, CANCEL
Content-Type: application/sdp
Content-Length: 288

v=0
o=Server 289123140 289123140 IN IP4 host99.example.com
s=-
t=0 0
m=application 0 TCP/MRCPv2
a=resource:speechsynth
a=resource:speechrecog
a=resource:recorder
m=audio 0 RTP/AVP 0 8 96
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
a=rtpmap:96 telephone-event/8000
a=fmtp:96 0-15

control session

MRCP 消息有三种：request、response、event。每种消息都含有一个起始行（各种类型的消息起始行有差异），一个或多个消息头，以 CRLF 间隔，格式为header-name:header-value，消息体报文一个有消息头定义长度和格式的报文。

request

起始行格式：MRCP/2.0 message-length method-name requestid

• 协议版本
• 整个报文的长度，包括起始行
• 请求的服务
  • SPEACK 语音合成服务
  • RECOGNIZE 语音识别服务
• 32 位自增 int 来区分不同的请求

示例

1
2
3
4
5
6
7
8

MRCP/2.0 267 SPEAK 10000
Channel-Identifier: 43b9ae17@speechsynth
Content-Type: application/ssml+xml
Content-Length: 150

<?xml version="1.0" encoding="UTF-8"?> <speak version="1.0"
xmlns="http://www.w3.org/2001/10/synthesis"> Hello world!
</speak>

Channel-Identifier 是所有 request 都必须的，与 SDP channel 的值是相同的

response

起始行格式为：MRCP/2.0 message-length request-id status-code request-state

• 协议版本号
• 整体报文长度，包括起始行
• 请求 ID
• 类似 HTTP 状态码
• 请求状态，PENDING、IN-PROGRESS、COMPLETE

示例

1

MRCP/2.0 79 10000 200 IN-PROGRESS Channel-Identifier: 43b9ae17@speechsynth

event

起始行格式：MRCP/2.0 message-length event-name request-id request-state

• 协议版本号
• 整体报文长度，包括起始行
• 事件
• 请求 ID
• 请求状态，PENDING、IN-PROGRESS、COMPLETE

不同的媒体资源支持不同的事件

示例

1
2
3

MRCP/2.0 109 START-OF-INPUT 10000 IN-PROGRESS
Channel-Identifier: 43b9ae17@speechrecog
Input-Type: dtmf

高亮代码块，官网文档

1

npm install -D -S highlight.js

1
2
3
4
5
6
7
8
9
10
11

import hljs from "highlight.js";
var obj = { a: 1, b: "2" };
//优化json格式
var json = JSON.stringify(obj, null, 4);

var lang = "json";
//得到高亮后的html文本
var html = hljs.highlight(lang, json).value;

//写入对应的dom元素上
document.getElementById("#id").innerHTML = html;

使用 mockjs 来模拟 api 接口返回报文

1
2

#安装
npm install -S -D mockjs

在项目目录下新建mock/index.js,并在main.js中引入

1
2
3
4
5
6
7
8
9
10
11
12

// main.js

require("./mock");

//mock/index.js

import Mock from "mockjs";

Mock.mock("/api", {
  name: "li",
  age: 12,
});

mockjs 代理地址支持正则表达式

1

Mock.mock(/\/api\/.*/, { foo: "bar" });

mockjs 支持使用一个函数来返回模拟数据

1
2
3
4
5
6

//options中包含请求url,type,请求body等信息
Mock.mock(/\/api\/.*/, function (options) {
 return {
    foo: "bar";
  }
});

安装

1

npm install --save axios

示例

官方文档

基础示例

1
2
3
4
5
6
7
8
9

const axios = require("axios");
axios({
  url: "http://localhost:5000",
  method: "post",
  data: "{}",
  headers: { "Content-tyle": "application/json" },
}).then((res) => {
  console.log(res);
});

其参数值可以为

• data 请求数据
• method 请求访问
• url 请求地址

post 请求

1
2
3
4
5
6
7
8
9
10
11
12

const axios = require("axios");

axios
  .post("http://localhost:5000", {
    name: 1,
  })
  .then((res) => {
    console.log(res);
  });
  .catch((err)=>{
    console.log(err)
  })

我们可以为请求设定一个具有指定配置项的实例

1
2
3
4
5

const instance = axios.create({
  url: "http://localhost:5000",
  timeout: 1000,
  headers: { "Content-tyle": "application/json" },
});

然后这个 instance 就可以直接调用下述方法

• axios#request(config)
• axios#get(url[, config])
• axios#delete(url[, config])
• axios#head(url[, config])
• axios#options(url[, config])
• axios#post(url[, data[, config]])
• axios#put(url[, data[, config]])
• axios#patch(url[, data[, config]])
• axios#getUri([config])

vue-cli2 中 axios 全局配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

//axios/index.js
import axios from "axios";

axios.defaults.baseURL =
  env === "development"
    ? "/api"
    : window.location.protocol + "//" + window.location.host; // 配置axios请求的地址
axios.defaults.headers.post["Content-Type"] = "application/json; charset=utf-8";
axios.defaults.crossDomain = true;
axios.defaults.withCredentials = true; //设置cross跨域 并设置访问权限 允许跨域携带cookie信息

//配置发送请求前的拦截器 可以设置token信息
axios.interceptors.request.use(
  (config) => {
    // 这里配置全局loading
    if (!/\.json/.test(config.url)) {
      $("#screen").show(); // 这个div控制loading动画，项目中有对json的请求，所以这里区分是否是json文件
    }
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

// 配置响应拦截器
axios.interceptors.response.use(
  (res) => {
    $("#screen").hide(); // loading结束
    return Promise.resolve(res.data); // 这里直接返回data, 即接口返回的所有数据
  },
  (error) => {
    $("#screen").hide();
    tooltip("", "连接错误！", "error");
    // 判断是否登录失效，按照实际项目的接口返回状态来判断
    if (error.toString().includes("776")) {
      window.location.href = window.location.origin + "/#/login";
    }
    return Promise.reject(error);
  }
);
export default axios;

最后在 main.js 里面引入

1
2
3
4

import VueAxios from "vue-axios"; // 报错的话则npm安装依赖
import axios from "./axios";

Vue.use(VueAxios, axios);

Webpack-dev-server 的 proxy 用法

在开发环境中，可以将 axios 的请求通过 proxy 进行转发

• 最简单的用法示例

  1 2 3 4 5 6 7

  copy mmodule.exports = { devServer: { proxy: { "/api": "http://localhost:3000", }, }, };

  请求到/api/xxx现在会被代理到请求http://localhost:3000/api/xxx

• 如果想要代理多个路径到同一个地址，可以使用一个或多个具有 context 属性的对象构成的数组

  1 2 3 4 5 6 7 8 9 10

  copy mmodule.exports = { devServer: { proxy: [ { context: ["/api", "/auth"], target: "http://localhost:3000", }, ], }, };

• 如果你不想传递/api，可以重写路径

  1 2 3 4 5 6 7 8 9 10 11

  copy mmodule.exports = { devServer: { proxy: [ '/api':{ target: "http://localhost:3000", pathRewrite:{'^/api',''},//原请求路径将被正则替换后加入到target地址后 secure:false,//默认情况下，不接受https，设置为false即可 }, ], }, };

  请求到/api/xxx现在会被代理到请求http://localhost:3000/xxx

• 使用 bypass 选项通过函数判断是否需要绕过代理，返回 false 或路径来跳过代理。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  copy mmodule.exports = { devServer: { proxy: [ '/api':{ target: "http://localhost:3000", bypass:function(req,res,proxyOptions){ if(req.header.accept.indexOfI('html')!== -1){ console.log('skipping proxy from browser request.') return '/index.html';//return false } } }, ], }, };

代理过程可能遇到的一些问题，对于有些 target 地址，可能需要登录，从而将页面重定向（302）到登录页面，那么我们就需要保证请求时带上对应的 token

提交 form 表单数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

var bodyFormData = new FormData();
bodyFormData.append("userName", "Fred");
axios({
  method: "post",
  url: "myurl",
  data: bodyFormData,
  headers: { "Content-Type": "multipart/form-data" },
})
  .then(function (response) {
    //handle success
    console.log(response);
  })
  .catch(function (response) {
    //handle error
    console.log(response);
  });

快速入门

官方入门文档

1
2
3
4
5

mkdir webpack-demo
cd webpack-demo
npm init -y
npm install webpack webpack-cli --save-dev
npm install --save lodash

新增两个文件

1
2
3
4
5
6

webpack-demo
  |- package.json
  |- /dist
   |- index.html
  |- /src
    |- index.js

1
2
3
4
5
6
7
8
9
10

<!DOCTYPE html>
<html>
  <head>
    <title>Getting Started</title>
  </head>

  <body>
    <script src="main.js"></script>
  </body>
</html>

1
2
3
4
5
6
7
8
9
10
11

import _ from "lodash";

function component() {
  const element = document.createElement("div");

  // Lodash, now imported by this script
  element.innerHTML = _.join(["Hello", "webpack"], " ");

  return element;
}
document.body.appendChild(component());

执行打包命令

1
2

# npx 类似package.json中的scripts，可直接运行
npx webpack

也可以在 package.json 中新增 script，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

{
  "name": "webpack-demo",
  "version": "1.0.0",
  "description": "",
  "private": true,
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "webpack"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "webpack": "^5.3.0",
    "webpack-cli": "^4.1.0"
  },
  "dependencies": {
    "lodash": "^4.17.20"
  }
}

那么我们可以直接使用如下命令进行打包

1

npm run build

当不指定配置文件时，就使用了默认的配置(npx webpack --config webpack.config.js)

1
2
3
4
5
6
7
8
9

const path = require("path");

module.exports = {
  entry: "./src/index.js",
  output: {
    filename: "main.js",
    path: path.resolve(__dirname, "dist"),
  },
};

如需要指定配置文件，可在 package.json 中指定相关配置文件

命令成功执行后，就会将所有文件打包到 dist 目录，我们打开 index.html，如果一切正常的话，我们可以在浏览器上看到Hello webpack字样

我们可以使用npx webpack serve启动 web 服务，默认会在 8080 端口上启动

1
2

npm i webpack-dev-server -S -D
npx webpack serve