~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.2.1/pjmedia/src/test/mips_test.c

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-01-07 14:51:16 UTC
  • mfrom: (4.3.5 sid)
  • Revision ID: package-import@ubuntu.com-20150107145116-yxnafinf4lrdvrmx
Tags: 1.4.1-0.1ubuntu1
* Merge with Debian, remaining changes:
 - Drop soprano, nepomuk build-dep
* Drop ubuntu patches, now upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* $Id: mips_test.c 4335 2013-01-29 08:09:15Z ming $ */
 
2
/* 
 
3
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
 
4
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 
19
 */
 
20
#include "test.h"
 
21
#include <pjmedia-codec.h>
 
22
 
 
23
/* Define your CPU MIPS here!! */
 
24
 
 
25
#ifndef CPU_IPS
 
26
    /*
 
27
    For complete table see:
 
28
    http://en.wikipedia.org/wiki/Million_instructions_per_second
 
29
 
 
30
    Processor                       IPS/MHz
 
31
    -------------------------------------------
 
32
    PowerPC G3                      2.253 MIPS/MHz
 
33
    Intel Pentium III               2.708 MIPS/MHz
 
34
    AMD Athlon                      2.967 MIPS/MHz
 
35
    Pentium 4 Extreme Edition       3.039 MIPS/MHz
 
36
    AMD Athlon FX-57                4.285 MIPS/MHz
 
37
 
 
38
 
 
39
    From: http://en.wikipedia.org/wiki/ARM_architecture
 
40
 
 
41
    Family      Arch            Core        IPS/MHz
 
42
    -------------------------------------------------------
 
43
    ARM7TDMI    ARMv4T          ARM7TDMI    0.892 MIPS/MHz
 
44
                                ARM710T     0.900 MIPS/MHz
 
45
                                ARM720T     1.003 MIPS/MHz
 
46
    ARM9TDMI    ARMv4T          ARM920T     1.111 MIPS/MHz
 
47
    ARM9E       ARMv5TEJ        ARM926EJ-S  1.100 MIPS/MHz
 
48
    XScale      ARMv5TE         PXA255      1.000 MIPS/MHz (?)
 
49
                                PXA27x      1.282 MIPS/MHz
 
50
    Cortex      ARMv7-A         Cortex-A8   2.000 MIPS/MHz
 
51
                                Cortex-A9   2.000 MIPS/MHz
 
52
                ARMv7-M         Cortex-M3   1.250 MIPS/MHz
 
53
    */
 
54
 
 
55
#   define CPU_MHZ          (2666)
 
56
#   define CPU_IPS          (3.039 * CPU_MHZ * MEGA)    /* P4 2.6GHz    */
 
57
 
 
58
//#   define CPU_MHZ        700
 
59
//#   define CPU_IPS        (700 * MEGA * 2.708)        /* P3 700Mhz    */
 
60
 
 
61
//#   define CPU_MHZ        180
 
62
//#   define CPU_IPS        (CPU_MHZ * MEGA * 1.1)      /* ARM926EJ-S */
 
63
 
 
64
//#   define CPU_MHZ        312
 
65
//#   define CPU_IPS        (CPU_MHZ * MEGA * 1.282)    /* Dell Axim PDA */
 
66
 
 
67
#endif
 
68
 
 
69
 
 
70
 
 
71
/* Sample speech data, 360ms length, encoded at 8Khz */
 
72
static const pj_int16_t ref_signal[] = {
 
73
         0,    -4,     0,     0,     1,     8,     8,     7,    12,    16,
 
74
        20,    29,    28,    48,    40,    48,    56,    76,    68,    76,
 
75
        96,   100,   104,   124,   117,   120,   144,   120,   136,   168,
 
76
       184,   188,   176,   216,   237,   235,   268,   301,   312,   316,
 
77
       367,   356,   384,   400,   344,   409,   392,   416,   380,   432,
 
78
       404,   444,   457,   456,   453,   512,   499,   512,   584,   584,
 
79
       544,   584,   608,   596,   552,   628,   600,   667,   728,   672,
 
80
       681,   755,   736,   764,   752,   764,   724,   769,   792,   840,
 
81
       820,   895,   841,   856,   852,   867,   944,   944,   939,   944,
 
82
       907,   928,   920,   960,   833,   881,  1004,  1007,  1000,  1057,
 
83
      1032,  1056,  1016,  1056,  1072,  1080,  1108,  1028,  1076,  1072,
 
84
       956,  1020,  1080,  1008,  1095,   992,  1056,  1028,   940,   976,
 
85
      1008,   940,   916,   968,   849,   868,   956,   940,   852,   892,
 
86
       968,   860,   777,   904,   825,   716,   764,   708,   635,   728,
 
87
       620,   648,   472,   724,   548,   448,   472,   372,   272,   437,
 
88
       419,   260,   237,   371,   196,   136,   177,   264,    49,   120,
 
89
        40,   124,    32,   136,    71,   120,   -95,   -20,   -76,  -140,
 
90
      -304,    12,  -148,  -168,  -192,   -63,  -212,   -36,  -288,  -232,
 
91
      -352,  -128,  -397,  -308,  -431,  -280,  -675,  -497,  -761,  -336,
 
92
      -760,  -471, -1088,  3013, -1596, -2000,   412,  -968,   213,  -668,
 
93
     -1096, -1048, -1039,  -825,  -580,  -612, -1056,  -888, -1324, -1064,
 
94
     -1164,  -819,  -940,  -780, -1236,  -688, -1931,    -1,  -464, -1804,
 
95
      1088, -1605, -1208,  -664,  -912,  -905,  -832, -1167,  -512,  1832,
 
96
      -924,   -60,   660, -2143,   248, -1660,  1496, -3464,  -164,  2072,
 
97
     -3040,   539,  2904,  2040, -3488,  2600,  2412,   820,  -551, -1401,
 
98
      1068,  -385,   397, -2112,  -980,  1064, -1244,  -736, -1335,   332,
 
99
     -1232, -1852,   -12, -1073, -1747, -3328,  -796, -2241, -4901, -3248,
 
100
     -3124, -3432, -5892, -3840, -3968, -4752, -5668, -4796, -3580, -5909,
 
101
     -5412, -6144, -5800, -5908, -6696, -6460, -8609, -3804, -5668, -8499,
 
102
     -4636, -5744, -2377, -7132, -3712, -7221, -6608,  1656,-11728, -6656,
 
103
     -3736,  -204, -8580, -4808,  -591, -5752,  -472,-10308, -2116,  -257,
 
104
     -4720, -7640, -1279,  6412,-16404, -1495,  6204, -8072,  -335, -3877,
 
105
     -2363,   464,   441, -6872,  1447,  7884,-13197,   936,  5009, -4416,
 
106
     -4445,  3956,  2280, -2844,  2036, -4285,   744,  4161, -7216,  5548,
 
107
       172,  -964, -2873,  3296,  2184, -7424,  4300,  1855,  1453,   -32,
 
108
      1585,  2160, -3440,   448,  4084, -1617,  1928,  3944, -3728,  4699,
 
109
      4556, -5556,  4096, 12928, -8287, -4320, 10739,  3172, -6068,  3684,
 
110
      6484,  1652, -1104, -1820, 11964, -1567, -4117,  7197,  5112, -2608,
 
111
     -2363,  7379,   936,  1596,   217,  6508,  3284,  3960,     0,  2691,
 
112
     11324, -6140,  6720,  6188,  3596, -1120,  5319,  9420, -9360,  5780,
 
113
      5135,   623, -1844,  3473,  8488, -4532,  2844,  8368,  4387, -8628,
 
114
     14180,  3196, -4852,  9092,  5540,  -600,  3088,  9864, -4992, 13984,
 
115
      2536, -5932, 10584,  7044, -2548,   388, 12597, -4776,  -247,  7728,
 
116
      6048, -6152,  6449,  9644, -8924,  8993,  6319,   877,  1108,  9804,
 
117
      -696,  2584,  9097, -3236,  4308,  5444, -2660,  -365, 11427, -6900,
 
118
      -803,  9388, -2444, -1068,  9160,   703, -5632, 12088, -2964, -1077,
 
119
      9804, -1263, -3679, 10161,  3337, -9755, 11601,  -160, -6421, 11008,
 
120
     -1952, -3411,  6792, -1665, -1344,  9116, -2545, -4100, 11577,   240,
 
121
     -3612,  5140,   603, -2100,  4284,  -784,   108,   968, -1244,  3500,
 
122
      3696,  -108,  3780,  3836,   -16,  4035,  2772,  1300,  -688,  1544,
 
123
      2268, -2144,  1156,  -564,   628, -1040,  -168,   491,   -72,  -408,
 
124
     -1812,  3460, -2083,   -72,   797,  1436, -3824,  1200,   308, -3512,
 
125
       572, -4060,   540,   -84, -4492, -1808,  4644, -4340, -3224,  5832,
 
126
     -2180, -2544,  1475,  2224, -2588,  1312,  1452, -1676,  -428, -1596,
 
127
      -860,  -116, -4000,  -364,   148, -3680, -2229, -1632,   236, -3004,
 
128
     -1917,   124, -1748, -2991,  -644,  -752, -3691, -1945, -3236, -2005,
 
129
     -4388, -2084, -2052, -3788, -3100,  -824, -2432, -3419, -1905, -2520,
 
130
     -2120, -2904, -2200, -1712, -2500, -2796, -1140, -2460, -2955,  -984,
 
131
     -1519,  -400,  -412,   356,    97,  -389,  1708,  -115,   452,  1140,
 
132
      -820,  1912,  1421, -1604,   556,  -632, -1991, -1409, -1904, -3604,
 
133
     -3292, -3405, -5584, -4891, -5436, -8940, -6280, -6604,-11764, -6389,
 
134
     -9081,-10928, -7784, -8492,-11263, -8292, -8829, -9632, -7828, -8920,
 
135
    -10224, -8912, -9836, -7313, -2916,-10240, -3748,  2860, -3308, -1236,
 
136
      6816,  4580,  1585,  9808,  7484,  5612,  6868,  7399,  6244,  5064,
 
137
      3823,  5159,  4940,   316,  4496,  4864,  1020,  3997,  6236,  3316,
 
138
      5712,  7032,  5568,  7329,  6135,  6904,  6431,  3768,  2580,  3724,
 
139
       504, -2213,  -661, -3320, -6660, -6696, -7971,-11208,-11316,-11784,
 
140
    -14212,-13651,-16312,-15876,-15984,-20283,-15168,  2073,-23888, -5839,
 
141
     13360, -8568,  1240, 18480, 11440,  4236, 23916, 15388, 14072, 15960,
 
142
     15064, 14840,  9395,  6981,  8584,  6540, -5453,  3568,   928, -7741,
 
143
     -5260,   -12, -5692, -7608,  1408,  2136,   776,  1775, 13568, 10992,
 
144
      8445, 17527, 21084, 14851, 15820, 23060, 15988, 11560, 15088, 14164,
 
145
      3376,  4059,  5212, -2520, -5891, -3596, -5080,-11752, -8861, -8124,
 
146
    -12104,-12076,-10028,-12333,-14180,-12516,-16036,-15559,-20416, -4240,
 
147
     -1077,-31052, 14840,  7405,-12660, 11896, 23572,  2829, 10932, 28444,
 
148
     10268, 15412, 13896, 16976, 10161,  6172,  5336,  9639, -2208, -7160,
 
149
      6544, -7188,-11280, -3308, -2428,-13447, -4880,  -824, -6664, -1436,
 
150
      4608,  7473,  2688, 14275, 14921, 13564, 15960, 20393, 16976, 14832,
 
151
     17540, 13524, 10744,  6876,  7328,  1772, -2340, -3528, -4516, -9576,
 
152
    -10872, -8640,-13092,-12825,-14076,-12192,-16620,-16207,-17004,-17548,
 
153
    -22088,-21700,-20320,  2836,-29576,-15860, 25811,-22555, -1868, 23624,
 
154
      9872, -4044, 29472, 16037,  7433, 16640, 14577, 13119,  3120,  7072,
 
155
      5828,  2285,-12087,  3180, -4031,-17840, -6349, -5300,-15452,-13852,
 
156
     -2659,-12079, -8568, -4492,  -672,   660,  5424,  3040, 16488, 11408,
 
157
      8996, 24976, 15120,  9940, 21400, 16885,  2624, 13939,  8644, -2815,
 
158
       332,  -160, -9312,-10172, -8320,-14033,-13056,-16200,-14113,-15712,
 
159
    -18153,-18664,-15937,-21692,-23500,-18597,-25948, -8597,-10368,-32768,
 
160
     16916, -4469,-17121, 18448, 14791, -4252, 18880, 22312,  4347, 17672,
 
161
     12672, 12964,  7384,  5404,  5176,  5668, -7692, -2356,  1148,-14872,
 
162
     -8920, -5593,-12753,-14600, -6429,-10608,-10372, -6757, -4857, -2044,
 
163
     -2720,  8995,  5088,  6516, 18384, 12853, 14952, 18048, 17439, 13920,
 
164
     15512, 10960, 10268,  5136,  2888,  1184, -4271, -7104, -7376, -9688,
 
165
    -14691,-11336,-14073,-17056,-14268,-16776,-17957,-19460,-18068,-23056,
 
166
    -20512,-24004, -3396,-19239,-27272, 22283,-16439, -7300, 19484,  9020,
 
167
     -1088, 22895, 15868,  9640, 17344, 11443, 17912,  6084,  6712,  9988,
 
168
      6104, -8559,  6403, -1196,-13152, -3632, -5388,-11924,-11973, -5748,
 
169
    -10292, -8420, -8468, -2256, -2829, -4132,  6344,  8785,  7444,  9508,
 
170
     22152, 15108, 13151, 22536, 20725, 10672, 17028, 17052,  5536,  6192,
 
171
      7484,   403, -5520, -2132, -5532,-11527,-10644, -9572,-13316,-16124,
 
172
    -10883,-15965,-17335,-17316,-16064,-20436,-21660, -8547, -3732,-32768,
 
173
     14672,  2213,-17200, 17964, 14387,  4232, 14800, 24296, 11288, 21368,
 
174
     11144, 22992, 13599,  6973, 14444, 12312, -2340,  4436,  8060, -9008,
 
175
     -2188, -2164, -5756,-10268, -5076, -6292, -6472, -7916, -2336,   327,
 
176
     -4492,  7144,  7696,  5691, 16352, 14244, 17764, 19852, 17296, 23160,
 
177
     18496, 14197, 19564, 13356,  5779, 10559,  4576, -2736,  -528, -3211,
 
178
     -8796, -8428, -9153,-10928,-13296,-12101,-12528,-14985,-16036,-14600,
 
179
    -15888,-18792,-19604, -3176, -8887,-29240, 21405, -6999, -9568, 19052,
 
180
     11952,  3037, 20055, 18376, 14501, 18672, 11023, 24776,  9488,  7921,
 
181
     15896, 11068, -4484,  9667,  4328, -7544, -1240, -1456, -7204, -9192,
 
182
     -5084, -5816, -6864, -9444,   276, -2316, -2852,  4640,  9600,  4412,
 
183
     13300, 16856, 12836, 18892, 17632, 18336, 16031, 14808, 13860, 12052,
 
184
      4284,  7372,  2623, -4284, -2172, -5036,-10163, -9788,-10384,-13205,
 
185
    -13180,-13453,-14460,-15540,-16580,-15472,-17961,-19148,-18824, -8063,
 
186
     -8620,-28300, 14323, -6748,-10204, 13100, 10548,   956, 16056, 14640,
 
187
     12680, 14171,  9672, 19741,  7524,  6615, 11825,  8788, -5080,  7224,
 
188
      1112, -6024, -4176, -1912, -7968, -8576, -7184, -5640, -8200, -9388,
 
189
     -1980, -2064, -4040,   240,  9327,  2192,  8451, 13604, 13124, 10057,
 
190
     16505, 15099, 11008, 10344, 12405,  7244,  1948,  4420,   132, -5312,
 
191
     -6072, -5772,-11608,-11756,-11660,-12684,-14335,-14548,-12400,-15268,
 
192
    -15277,-14949,-14889,-17376,-16640,-15656, -1128,-23476, -6084,  7268,
 
193
    -13880,   400, 10984,  1468,  4388, 14156,  6600, 13684,  5428, 12240,
 
194
     11815,  5460,  3663, 13164, -1269,   772,  3884,  -788, -5536, -1652,
 
195
     -4857, -4596, -7912, -6152, -4132, -7201, -6288, -1196, -1332, -4236,
 
196
      5020,  5020,  1648,  8572, 10224,  6256,  9816,  9404,  8124,  6644,
 
197
      4380,  4707,   636, -3300, -3208, -4395, -9716, -7540, -8175, -9980,
 
198
    -10237, -7680,-12172, -9981,-10459, -9712, -8451,-13008,-10196, -9308,
 
199
    -13109,-11700,-11636, -6143, -9472,-12117,   985, -3627, -6120,  2828,
 
200
      5268,    33,  6984,  6488,  7803,  6265,  6992,  8032,  7892,  3408,
 
201
      6021,  6224,  1016,  2053,  2632,  -648, -1936, -1796, -2504, -2865,
 
202
     -4400, -2524, -2388, -2524, -1432,   283,   696,  1180,  2912,  3996,
 
203
      3328,  3948,  5101,  4905,  3396,  3500,  3323,  2472,  -152,  1580,
 
204
      -860, -2109, -1331, -2460, -2960, -3396, -3476, -2616, -5172, -3352,
 
205
     -4036, -4440, -5480, -4028, -4220, -5876, -4656, -5233, -4621, -5465,
 
206
     -6417, -4936, -5092, -1860, -5651, -2699,  1273,  -920,  -888,  4279,
 
207
      3260,  2952,  5861,  5584,  5980,  6428,  5732,  6516,  6825,  4156,
 
208
      5000,  5071,  2669,  1764,  3273,  1148,  1312,   880,  1788,  1457,
 
209
      1299,   648,  3172,  2004,  1060,  3544,  1963,  2516,  3192,  3057,
 
210
      2936,  2892,  2896,  2224,  3188,  1524,  1541,  3120,   624,   917,
 
211
      1472,  1128,  -317,   687,   400, -1131,   164,  -812, -1232, -1120,
 
212
     -1311, -1364, -1500, -1660, -2380, -1835, -2456, -2468, -2168, -2785,
 
213
     -2824, -2408, -3316,  -552, -1204, -3153,  1188,  1572,  -752,  1756,
 
214
      4108,  2344,  3595,  4504,  4152,  4556,  4224,  3568,  4801,  3165,
 
215
      2776,  2808,  3233,  1300,  2411,  1536,  1828,  1424,  1576,  1412,
 
216
      1880,   895,  1601,  1916,  1763,   944,  2599,  1349,  1873,  1988,
 
217
      1744,  1956,  1667,  1548,  1812,  1048,  1528,   488,  1428,   832,
 
218
       232,   207,   632,  -152,  -520,    20,    15, -1580,  -841,  -948,
 
219
     -1120, -1455, -2004, -1244, -1344, -2236, -1312, -1344, -2156, -1420,
 
220
     -1856, -1637, -1847, -1460, -1780, -1372,  -508, -1256,  -752,     0,
 
221
       600,   859,  1156,  1532,  2364,  2204,  2059,  2269,  2240,  1928,
 
222
      1889,  2055,  1205,  1068,  1268,   892,  1371,  1036,   413,  1552,
 
223
       572,   -84,  1364,   260,   624,   820,  -160,  1492,   188,   204,
 
224
       796,   468,   552,   945,  -504,   697,  -936,   284, -1116,  -204,
 
225
     -1052,  -700, -1637,  -673, -2744,   -25, -2163, -1728, -1704, -1260,
 
226
     -2228, -2512,  -496, -3992,  -824, -2699, -2172, -2196, -1684, -3376,
 
227
      -540, -3047, -2220,  -376, -3416,     8, -2424,  -428, -1111,  -927,
 
228
        68, -1152,   640, -1308,   276,   536,   592,  -292,  2256,  -368,
 
229
       680,  2532,  -536,  1548,   780,   -92,  1596,    56,   444,   348,
 
230
       356,   500, -2168,  1527, -1632,  -677,  -980,  -904,  -868,   480,
 
231
     -1476,  -804, -1515,  -335, -2472, -1533, -1007,  -644, -2308, -1592,
 
232
      -104, -3860,  -984, -2364,     0, -1372, -2500, -2548,  1280, -3767,
 
233
     -2228,  -440, -2168, -2691,   628, -2013, -3773, -4292,  3796, -6452,
 
234
     -1268,  -156, -1320, -3779,  2612, -2924,  -864,  -619,  1227, -3408,
 
235
      3016,  -200, -1432,  2219,   -45, -1356,  5744, -2069,  4396,   488,
 
236
      3048,  -801,  3876,   857,  2064,    80,  4240,  -700,  1928,  1568,
 
237
     -1992,  3431,   600,  2221,   657, -3116,  5888, -2668,  4871, -7963,
 
238
      8016, -4907,  1264, -1969,  3688, -4396, -1276,  2448, -3760,  2156,
 
239
     -3039, -3064,   940,  2384, -7907,  4520, -2876,  2384, -5784,  4484,
 
240
     -5487,  1907, -4064,  1991, -3496,  1304, -4521,  5255, -4189,  1136,
 
241
     -2397,  -152,   768, -1671,  2084, -2709,  6413, -1460,  1952,   448,
 
242
      7064,  -444,  6256,   600,  8872,  2115,  4672,  7628,  6264,  2993,
 
243
      8920,  2876,  7744,  3956,  4848,  7236,   804,  7684,  5201,  2216,
 
244
      6360,  4900,  -340,  6885,  1307,  2468,  1884,  4812, -1376,  4740,
 
245
      1751,   135,  1124,  3284, -3228,  3968,  1748, -4453,  1587, -1515,
 
246
      3084, -3300, -2548,  -544,  -296,   396, -7808,  4956, -5164,  -292,
 
247
     -4947,   212, -4055,  -108, -4301, -2088, -2912,  3016,   952, -1888,
 
248
      4972,  4441,  6136,  1464,  9387,  4137,  6812,  6281,  2440,  6940,
 
249
      3928,  2704, -1204,  4260, -2289,  -712, -1768,  -383, -1195,   920,
 
250
     -1200,  -336,  4372,   720,  4392,  1291,  5819,  4528,  7532,   992,
 
251
      8176,  5588,  2760,  2836,  3412,  1132,   531,  2236, -5044,   621,
 
252
     -2916, -3964, -5849,  -864, -6300,-10019, -3964, -5524, -7004, -6833,
 
253
     -7236, -9484, -2528,-10112,-12900, -4199, -8580,-12427,-10924, -8604,
 
254
    -11520, -9636, -6560, -1647, -6948,  -460,  1752,  2952,  4196,  4360,
 
255
      4215,  8156,  4528,  2464,  2500,  3299, -2224, -3812, -2568, -5875,
 
256
     -5556, -7728, -8288, -5765, -6448, -7620, -5288, -2680, -4368,  -972,
 
257
       472,  1716,  2467,  4408,  5141,  4724,  7316,  4132,  3493,  5935,
 
258
      3564,    96,  1068,   868, -2160, -2736, -3449, -5428, -3339, -5200,
 
259
     -7156, -4189, -7928, -8064, -7532, -7999,-12124, -8509, -9888,-12420,
 
260
    -13568,-13187,-15384,-14996,-15152,-15284,-17059,-15292,-11792, -1160,
 
261
     -7300, -8284,  7237,  7241,  1616,  6327, 12064,  7920,  9564,  3556,
 
262
      4612,  6980,   261, -6365, -2028, -1701,-10136, -9573, -6901, -7747,
 
263
     -7868, -8076, -6123, -1508,  -100, -3048,  2004,  6704,  4507,  3256,
 
264
      9432,  8672,  7673,  6804,  7632,  8777,  6908,  3332,  3771,  6552,
 
265
      3153,   400,  3029,  4388,  1328,   160,  2304,  2023,  1325, -2640,
 
266
     -2356, -1544, -3436, -8584, -6939, -7180,-10455,-12928,-12296,-14653,
 
267
    -15243,-16436,-15240,-16672,-15476,-14628,  7004, -1360,-10100, 16344,
 
268
     18300,  9108, 12869, 22541, 16119, 17856, 10697,  6720, 12128,  6904,
 
269
     -8184, -3440,  2592,-10440,-11735, -4739, -4455, -5457, -2432, -1476,
 
270
      4520, 10045,  5512,  7988, 17032, 15052,  9211, 13309, 14624, 10324,
 
271
     10488,  7809,  6908,  9896,  5861,  3284,  8348, 10505,  5189,  8144,
 
272
     13280, 11732, 10035, 12559, 12104, 12456, 10148,  6520,  5944,  5603,
 
273
     -1848, -4196, -2544, -5876,-11416,-10032,-10248,-12753,-13344,-14900,
 
274
    -14320,-11265,-14220,-17067, -1440, 20120, -9884,  2783, 32220, 22208,
 
275
      9032, 22661, 26820, 19916, 17747,  5288,  8628, 14293, -3331,-15672,
 
276
      1252,  -324,-18236,-11592, -1172, -3384, -3864,  1052,  3640, 13099,
 
277
     13691,  6520, 14320, 22856, 12887,  7152, 14764, 13276,  4060,  2568,
 
278
      2268,  2224,  3312, -3336,  -875,  9000,  6180,  1872, 10851, 17464,
 
279
     12312, 11197, 15388, 17816, 12024,  8332,  7119,  8096,  1608, -5611,
 
280
     -5964, -4729,-11317,-14784,-12833,-11272,-14888,-16128,-15012,-12028,
 
281
    -14472,-16227,-15356,-14484,-15056, 11496,   352,-14108, 19216, 24616,
 
282
      3724,  7872, 25948, 13832,  9680,  7492,  2052,  5220,  1188,-16112,
 
283
    -11340,   703,-15400,-21572, -5816, -3320,-12072, -5664,  2296,  3101,
 
284
      6708,  5396,  5735, 13601, 12040,  1924,  6071, 10420,   984, -4904,
 
285
      -204, -1945, -6229, -7460, -5636,  2864,  -476, -2832,  6104, 13160,
 
286
      7151,  7148, 13063, 13596,  8796,  5092,  5976,  5668,  -431, -7624,
 
287
     -6741, -5676,-14332,-18700,-13396,-12387,-18576,-17516,-14184,-14124,
 
288
    -15972,-17456,-16323,-14712,-18056,-23213,-10744, 12016,-14824,-12636,
 
289
     21656, 14112, -4085,  9255, 20864,  8196,  6384,  1223,  2244,  5304,
 
290
     -6660,-19192, -4961, -2875,-22564,-18400, -3220, -8488,-14544, -5040,
 
291
      -324,   820,  2732,   628,  5484, 11924,  4813,  -852,  8656,  7160,
 
292
     -3924, -2955,  1337, -3268, -7359, -2552, -2528,  -532,   128,   411,
 
293
      5324,  9301,  5601,  6200, 11684, 10072,  4924,  5508,  6660,  1568,
 
294
     -2332, -4268, -5628, -7987,-12004,-13760,-11567,-12104,-16539,-14437,
 
295
    -12012,-14309,-16736,-14573,-13604,-15468,-18204,-19103, -9140, 10132,
 
296
    -13631, -9568, 22580, 13756, -3548, 12112, 23891,  8144,  5964,  7240,
 
297
      7216,  4284, -4800,-11761, -1308, -3044,-19584,-13808,  -759, -7968,
 
298
    -14524, -1503,  3072,  -396,  1936,  5900,  9264, 10769,  7240,  5961,
 
299
     13112,  8788,   660,  2807,  7980,  -449, -2477,  3940,  2792,  1584,
 
300
      2791,  5603,  7528,  9692,  5924,  9123, 15240,  9636,  4924, 11044,
 
301
     11113,   956,   756,  2812, -1832, -6920, -7120, -7192, -7711, -9717,
 
302
    -12704, -8736, -7508,-12067,-13176, -8133, -9304,-13160,-13437,-13268,
 
303
     -4084, 11400,-12785,  -700, 24992, 12168, -1268, 19404, 25183,  8373,
 
304
     10256, 13664, 11200,  5879,   -60, -3656,  4556, -2972,-14688, -4932,
 
305
      2432, -9279,-10691,  4280,  3180, -2444,  4088,  9992,  9176,  9156,
 
306
      9520, 11164, 14484,  8608,  4919, 10556,  9792,  2740,  3456,  8840,
 
307
      6424,  2348,  5696,  9420,  6596,  5380,  8364, 10952,  8499,  6800,
 
308
      8728,  9641,  5412,  2340,  3596,  2039, -2864, -5489, -3616, -5596,
 
309
     -9232, -8744, -7788, -9860,-11104, -9356, -9464,-11188,-11312,-11036,
 
310
    -11736,-13564, -6016,  8744,-11784, -1196, 18972,  9512,  -572, 17407,
 
311
     20316,  7472,  9784, 13369,  8952,  5092,  1003, -2004,  2755, -3952,
 
312
    -12761, -4648,  -744,-11667,-10240,  1556, -1572, -5872,  2196,  6011,
 
313
      3900,  5384,  7529,  8924,  9629,  6324,  5744,  9484,  7829,  3420,
 
314
      4384,  8644,  4360,  1500,  5248,  5921,  2200,  2564,  5212,  5037,
 
315
      2849,  2836,  3985,  3952,   875,  -560,   416, -1052, -5228, -5185,
 
316
     -4996, -7820, -9616, -9076,-10644,-11239,-11816,-12360,-12228,-12420,
 
317
    -13560,-12940,-13044,-15648,-11664,  1945, -9676, -9088,  9676,  6708,
 
318
     -3048,  8185, 15520,  4620,  5764, 10716,  6584,  2684,  2276, -1436,
 
319
       -56, -2948, -9140, -6611, -2868, -9897,-10565, -2012, -3948, -7916,
 
320
     -1440,  2420,  -241,  1164,  4428,  4932,  5461,  3884,  4476,  6620,
 
321
      7724,  1779,  3172,  8256,  3132,  -749,  5192,  4300, -1388,  1192,
 
322
      3575,   789,  -228,  1185,   995,   937,  -952, -2624,  -449, -1992,
 
323
     -6204, -4648, -3000, -7604, -8536, -5868, -9024,-10507,-10064, -9296,
 
324
    -12896,-11120,-11776,-13288,-14137,-12668,-15780,-14157, -8392, -7444,
 
325
    -11156, -2300,  2828, -1747,  1164,  8152,  6280,  4876,  7912,  7604,
 
326
      5609,  5164,  2600,  1620,  1592, -3237, -4441, -2068, -5052, -8268,
 
327
     -4503, -3304, -6332, -4460,  -388,  -297,  -319,  1911,  4071,  4272,
 
328
      4659,  8368,  6933,  6720,  8764,  8640,  6412,  6384,  5927,  3820,
 
329
      3488,  2648,  1104,  1220,   884,  -692,   327,   616,  -972,  -160,
 
330
       713,  -593,  -652,   179,  -651, -2005,  -656, -1536, -2968, -3748,
 
331
     -2640, -5052, -5548, -3476, -6151, -6388, -5168, -6099, -7416, -5752,
 
332
     -7579, -8220, -8312, -8472, -5287, -8056, -3527, -2356, -1704,  1892,
 
333
      2408,  2893,  5965,  8121,  5136,  8480,  8928,  7364,  6408,  7960,
 
334
      4315,  4392,  3864,  1353,   928,  1436, -1480,  -488,  1640,  -380,
 
335
       -36,  3420,  4044,  4432,  5185,  8044,  8740,  7983,  7912,  9588,
 
336
      8588,  6804,  6944,  6700,  4308,  2852,  3252,  2192,  -136,   876,
 
337
      1008,   244,   160,   205,   992,  1684,  -136,   984,  3312,   853,
 
338
      -772,  2372,   436, -3008, -1024,  -136, -3800, -2263, -3212, -2749,
 
339
     -3688, -2424, -5372, -2136, -3288, -4952, -3596, -2028, -4640, -5797,
 
340
     -2696, -4040, -7152, -4055, -2568, -6460, -4228, -1092, -2780, -2492,
 
341
       468,  -235,  1620,  3500,  2040,  2840,  6300,  4488,  2488,  5707,
 
342
      5576,  3537,  2291,  4301,  2844,  3364,  1153,  2500,  3340,  3160,
 
343
      1224,  3220,  4016,  2228,  1788,  4199,  3604,  2096,  1763,  3237,
 
344
      2044,  -564,  1280,   876,  -584, -1904,    24,   -60, -2948, -1440,
 
345
     -1228, -1824, -2092, -1945, -3912,  -227, -2411, -3219, -2252, -1808,
 
346
     -3044, -1035, -3092, -1456, -3724, -2284, -3149, -3028, -2788, -1804,
 
347
     -3360, -1276, -4097, -2531, -2248, -1635, -3215, -2376, -2468, -2596,
 
348
     -2825, -2792, -1980, -4036, -1721, -2059, -4117,   364, -1452, -2772,
 
349
     -1336,   480, -1043,   244, -2904,   924, -1329,   968, -1891,   523,
 
350
      -624,  -464,  -564,   187,  -852,   584,  -764,  -260,  -147,   160,
 
351
       339,   -32,   936,  -896,   288,   136,    56,   -36,  -736,  -683,
 
352
      -332,   696, -2319,  -259,   564, -2196,  -860,  1108, -2177,  -728,
 
353
      1344, -2520,  -440,  1080,  -780, -3513,  3272, -1635, -1597,  -188,
 
354
       744, -1944,   140,  -636, -1644,  -141,  -596, -1132,  -816,  1168,
 
355
     -2836,   196,   312,   136, -1381,   628,  -223,  -368,  -425,   604,
 
356
      -776,   595,  -628,  -128,  -884,   960, -1092,    76,   144,     8,
 
357
       161,  -504,   760,  -808,   336,   185,   100,   404,   120,   236,
 
358
        68,  -148,   -64,   312,   320,  -560,   117,   -28,   236,  -231,
 
359
       -92,    60,   356,  -176,   176,   212,   124,   -57,   -76,   168,
 
360
        88,  -140,   -37,   160,     0,   -92,    96,    24,   -84,     0,
 
361
};
 
362
 
 
363
#define THIS_FILE           "mips_test.c"
 
364
#define DURATION            5000
 
365
#define PTIME               20  /* MUST be 20! */
 
366
#define MEGA                1000000
 
367
#define GIGA                1000000000
 
368
 
 
369
enum op
 
370
{
 
371
    OP_GET  = 1,
 
372
    OP_PUT  = 2,
 
373
    OP_GET_PUT = 4,
 
374
    OP_PUT_GET = 8
 
375
};
 
376
 
 
377
enum clock_rate
 
378
{
 
379
    K8  = 1,
 
380
    K16 = 2,
 
381
    K32 = 4,
 
382
};
 
383
 
 
384
 
 
385
struct test_entry
 
386
{
 
387
    const char      *title;
 
388
    unsigned         valid_op;
 
389
    unsigned         valid_clock_rate;
 
390
 
 
391
    pjmedia_port*  (*init)(pj_pool_t *pool,
 
392
                          unsigned clock_rate,
 
393
                          unsigned channel_count,
 
394
                          unsigned samples_per_frame,
 
395
                          unsigned flags,
 
396
                          struct test_entry *);
 
397
    void           (*custom_run)(struct test_entry*);
 
398
    void           (*custom_deinit)(struct test_entry*);
 
399
 
 
400
    void            *pdata[4];
 
401
    unsigned         idata[4];
 
402
};
 
403
 
 
404
 
 
405
/***************************************************************************/
 
406
/* pjmedia_port to supply with continuous frames */
 
407
static pjmedia_port* create_gen_port(pj_pool_t *pool,
 
408
                                     unsigned clock_rate,
 
409
                                     unsigned channel_count,
 
410
                                     unsigned samples_per_frame,
 
411
                                     unsigned pct_level)
 
412
{
 
413
    pjmedia_port *port;
 
414
    pj_status_t status;
 
415
 
 
416
    if (pct_level == 100 && channel_count==1) {
 
417
        status = pjmedia_mem_player_create(pool, ref_signal, 
 
418
                                           sizeof(ref_signal), clock_rate, 
 
419
                                           channel_count, samples_per_frame,
 
420
                                           16, 0, &port);
 
421
    } else {
 
422
        pj_int16_t *buf;
 
423
        unsigned c;
 
424
 
 
425
        buf = (pj_int16_t*)
 
426
              pj_pool_alloc(pool, sizeof(ref_signal)*channel_count);
 
427
        for (c=0; c<channel_count; ++c) {
 
428
            unsigned i;
 
429
            pj_int16_t *p;
 
430
 
 
431
            p = buf+c;
 
432
            for (i=0; i<PJ_ARRAY_SIZE(ref_signal); ++i) {
 
433
                *p = (pj_int16_t)(ref_signal[i] * pct_level / 100);
 
434
                p += channel_count;
 
435
            }
 
436
        }
 
437
        status = pjmedia_mem_player_create(pool, buf, 
 
438
                                           sizeof(ref_signal)*channel_count, 
 
439
                                           clock_rate,  channel_count, 
 
440
                                           samples_per_frame,
 
441
                                           16, 0, &port);
 
442
    }
 
443
 
 
444
    return status==PJ_SUCCESS? port : NULL;
 
445
}
 
446
 
 
447
/***************************************************************************/
 
448
static pjmedia_port* gen_port_test_init(pj_pool_t *pool,
 
449
                                        unsigned clock_rate,
 
450
                                        unsigned channel_count,
 
451
                                        unsigned samples_per_frame,
 
452
                                        unsigned flags,
 
453
                                        struct test_entry *te)
 
454
{
 
455
    PJ_UNUSED_ARG(flags);
 
456
    PJ_UNUSED_ARG(te);
 
457
    return create_gen_port(pool, clock_rate, channel_count, samples_per_frame,
 
458
                           100);
 
459
}
 
460
 
 
461
 
 
462
/***************************************************************************/
 
463
static pjmedia_port* init_conf_port(unsigned nb_participant,
 
464
                                    pj_pool_t *pool,
 
465
                                    unsigned clock_rate,
 
466
                                    unsigned channel_count,
 
467
                                    unsigned samples_per_frame,
 
468
                                    unsigned flags,
 
469
                                    struct test_entry *te)
 
470
{
 
471
    pjmedia_conf *conf;
 
472
    unsigned i;
 
473
    pj_status_t status;
 
474
 
 
475
    PJ_UNUSED_ARG(flags);
 
476
    PJ_UNUSED_ARG(te);
 
477
 
 
478
    /* Create conf */
 
479
    status = pjmedia_conf_create(pool, 2+nb_participant*2, clock_rate, 
 
480
                                 channel_count, samples_per_frame, 16, 
 
481
                                 PJMEDIA_CONF_NO_DEVICE, &conf);
 
482
    if (status != PJ_SUCCESS)
 
483
        return NULL;
 
484
 
 
485
    for (i=0; i<nb_participant; ++i) {
 
486
        pjmedia_port *gen_port, *null_port;
 
487
        unsigned slot1, slot2;
 
488
 
 
489
        /* Create gen_port for source audio */
 
490
        gen_port = create_gen_port(pool, clock_rate, channel_count,
 
491
                                   samples_per_frame, 100 / nb_participant);
 
492
        if (!gen_port)
 
493
            return NULL;
 
494
 
 
495
        /* Add port */
 
496
        status = pjmedia_conf_add_port(conf, pool, gen_port, NULL, &slot1);
 
497
        if (status != PJ_SUCCESS)
 
498
            return NULL;
 
499
 
 
500
        /* Connect gen_port to sound dev */
 
501
        status = pjmedia_conf_connect_port(conf, slot1, 0, 0);
 
502
        if (status != PJ_SUCCESS)
 
503
            return NULL;
 
504
 
 
505
        /* Create null sink frame */
 
506
        status = pjmedia_null_port_create(pool, clock_rate, channel_count,
 
507
                                          samples_per_frame, 16, &null_port);
 
508
        if (status != PJ_SUCCESS)
 
509
            return NULL;
 
510
 
 
511
        /* add null port */
 
512
        status = pjmedia_conf_add_port(conf, pool, null_port, NULL, &slot2);
 
513
        if (status != PJ_SUCCESS)
 
514
            return NULL;
 
515
 
 
516
        /* connect sound to null sink port */
 
517
        status = pjmedia_conf_connect_port(conf, 0, slot2, 0);
 
518
        if (status != PJ_SUCCESS)
 
519
            return NULL;
 
520
 
 
521
        /* connect gen_port to null sink port */
 
522
#if 0
 
523
        status = pjmedia_conf_connect_port(conf, slot1, slot2, 0);
 
524
        if (status != PJ_SUCCESS)
 
525
            return NULL;
 
526
#endif  
 
527
    }
 
528
 
 
529
    return pjmedia_conf_get_master_port(conf);
 
530
}
 
531
 
 
532
 
 
533
/***************************************************************************/
 
534
/* Benchmark conf with 1 participant, no mixing */
 
535
static pjmedia_port* conf1_test_init(pj_pool_t *pool,
 
536
                                     unsigned clock_rate,
 
537
                                     unsigned channel_count,
 
538
                                     unsigned samples_per_frame,
 
539
                                     unsigned flags,
 
540
                                     struct test_entry *te)
 
541
{
 
542
    return init_conf_port(1, pool, clock_rate, channel_count, 
 
543
                          samples_per_frame, flags, te);
 
544
}
 
545
 
 
546
 
 
547
/***************************************************************************/
 
548
/* Benchmark conf with 2 participants, mixing to/from snd dev */
 
549
static pjmedia_port* conf2_test_init(pj_pool_t *pool,
 
550
                                     unsigned clock_rate,
 
551
                                     unsigned channel_count,
 
552
                                     unsigned samples_per_frame,
 
553
                                     unsigned flags,
 
554
                                     struct test_entry *te)
 
555
{
 
556
    return init_conf_port(2, pool, clock_rate, channel_count, 
 
557
                          samples_per_frame, flags, te);
 
558
}
 
559
 
 
560
/***************************************************************************/
 
561
/* Benchmark conf with 4 participants, mixing to/from snd dev */
 
562
static pjmedia_port* conf4_test_init(pj_pool_t *pool,
 
563
                                     unsigned clock_rate,
 
564
                                     unsigned channel_count,
 
565
                                     unsigned samples_per_frame,
 
566
                                     unsigned flags,
 
567
                                     struct test_entry *te)
 
568
{
 
569
    return init_conf_port(4, pool, clock_rate, channel_count, 
 
570
                          samples_per_frame, flags, te);
 
571
}
 
572
 
 
573
/***************************************************************************/
 
574
/* Benchmark conf with 8 participants, mixing to/from snd dev */
 
575
static pjmedia_port* conf8_test_init(pj_pool_t *pool,
 
576
                                     unsigned clock_rate,
 
577
                                     unsigned channel_count,
 
578
                                     unsigned samples_per_frame,
 
579
                                     unsigned flags,
 
580
                                     struct test_entry *te)
 
581
{
 
582
    return init_conf_port(8, pool, clock_rate, channel_count, 
 
583
                          samples_per_frame, flags, te);
 
584
}
 
585
 
 
586
/***************************************************************************/
 
587
/* Benchmark conf with 16 participants, mixing to/from snd dev */
 
588
static pjmedia_port* conf16_test_init(pj_pool_t *pool,
 
589
                                      unsigned clock_rate,
 
590
                                      unsigned channel_count,
 
591
                                      unsigned samples_per_frame,
 
592
                                      unsigned flags,
 
593
                                      struct test_entry *te)
 
594
{
 
595
    PJ_UNUSED_ARG(flags);
 
596
    return init_conf_port(16, pool, clock_rate, channel_count, 
 
597
                          samples_per_frame, flags, te);
 
598
}
 
599
 
 
600
/***************************************************************************/
 
601
/* Up and downsample */
 
602
static pjmedia_port* updown_resample_get(pj_pool_t *pool,
 
603
                                         pj_bool_t high_quality,
 
604
                                         pj_bool_t large_filter,
 
605
                                         unsigned clock_rate,
 
606
                                         unsigned channel_count,
 
607
                                         unsigned samples_per_frame,
 
608
                                         unsigned flags,
 
609
                                         struct test_entry *te)
 
610
{
 
611
    pjmedia_port *gen_port, *up, *down;
 
612
    unsigned opt = 0;
 
613
    pj_status_t status;
 
614
 
 
615
    PJ_UNUSED_ARG(flags);
 
616
    PJ_UNUSED_ARG(te);
 
617
 
 
618
    if (!high_quality)
 
619
        opt |= PJMEDIA_RESAMPLE_USE_LINEAR;
 
620
    if (!large_filter)
 
621
        opt |= PJMEDIA_RESAMPLE_USE_SMALL_FILTER;
 
622
 
 
623
    gen_port = create_gen_port(pool, clock_rate, channel_count,
 
624
                               samples_per_frame, 100);
 
625
    status = pjmedia_resample_port_create(pool, gen_port, clock_rate*2, opt, &up);
 
626
    if (status != PJ_SUCCESS)
 
627
        return NULL;
 
628
    status = pjmedia_resample_port_create(pool, up, clock_rate, opt, &down);
 
629
    if (status != PJ_SUCCESS)
 
630
        return NULL;
 
631
 
 
632
    return down;
 
633
}
 
634
 
 
635
/* Linear resampling */
 
636
static pjmedia_port* linear_resample( pj_pool_t *pool,
 
637
                                      unsigned clock_rate,
 
638
                                      unsigned channel_count,
 
639
                                      unsigned samples_per_frame,
 
640
                                      unsigned flags,
 
641
                                      struct test_entry *te)
 
642
{
 
643
    return updown_resample_get(pool, PJ_FALSE, PJ_FALSE, clock_rate,
 
644
                               channel_count, samples_per_frame, flags, te);
 
645
}
 
646
 
 
647
/* Small filter resampling */
 
648
static pjmedia_port* small_filt_resample( pj_pool_t *pool,
 
649
                                          unsigned clock_rate,
 
650
                                          unsigned channel_count,
 
651
                                          unsigned samples_per_frame,
 
652
                                          unsigned flags,
 
653
                                          struct test_entry *te)
 
654
{
 
655
    return updown_resample_get(pool, PJ_TRUE, PJ_FALSE, clock_rate,
 
656
                               channel_count, samples_per_frame, flags, te);
 
657
}
 
658
 
 
659
/* Larger filter resampling */
 
660
static pjmedia_port* large_filt_resample( pj_pool_t *pool,
 
661
                                          unsigned clock_rate,
 
662
                                          unsigned channel_count,
 
663
                                          unsigned samples_per_frame,
 
664
                                          unsigned flags,
 
665
                                          struct test_entry *te)
 
666
{
 
667
    return updown_resample_get(pool, PJ_TRUE, PJ_TRUE, clock_rate,
 
668
                               channel_count, samples_per_frame, flags, te);
 
669
}
 
670
 
 
671
 
 
672
/***************************************************************************/
 
673
/* Codec encode/decode */
 
674
 
 
675
struct codec_port
 
676
{
 
677
    pjmedia_port     base;
 
678
    pjmedia_endpt   *endpt;
 
679
    pjmedia_codec   *codec;
 
680
    pj_status_t    (*codec_deinit)();
 
681
    pj_uint8_t       pkt[640];
 
682
    pj_uint16_t      pcm[32000 * PTIME / 1000];
 
683
};
 
684
 
 
685
#if PJMEDIA_HAS_L16_CODEC || \
 
686
    PJMEDIA_HAS_OPENCORE_AMRWB_CODEC || PJMEDIA_HAS_OPENCORE_AMRNB_CODEC || \
 
687
    PJMEDIA_HAS_G7221_CODEC || PJMEDIA_HAS_G722_CODEC || PJMEDIA_HAS_G711_CODEC || \
 
688
    PJMEDIA_HAS_SPEEX_CODEC || PJMEDIA_HAS_ILBC_CODEC || PJMEDIA_HAS_GSM_CODEC
 
689
static pj_status_t codec_put_frame(struct pjmedia_port *this_port, 
 
690
                                   pjmedia_frame *frame)
 
691
{
 
692
    struct codec_port *cp = (struct codec_port*)this_port;
 
693
    pjmedia_frame out_frame;
 
694
    pj_status_t status;
 
695
 
 
696
    out_frame.buf = cp->pkt;
 
697
    out_frame.size = sizeof(cp->pkt);
 
698
    status = pjmedia_codec_encode(cp->codec, frame, sizeof(cp->pkt),
 
699
                                  &out_frame);
 
700
    pj_assert(status == PJ_SUCCESS);
 
701
 
 
702
    if (out_frame.size != 0) {
 
703
        pjmedia_frame parsed_frm[2], pcm_frm;
 
704
        unsigned frame_cnt = PJ_ARRAY_SIZE(parsed_frm);
 
705
        unsigned i;
 
706
 
 
707
        status = pjmedia_codec_parse(cp->codec, out_frame.buf, 
 
708
                                     out_frame.size, &out_frame.timestamp,
 
709
                                     &frame_cnt, parsed_frm);
 
710
        pj_assert(status == PJ_SUCCESS);
 
711
        
 
712
        for (i=0; i<frame_cnt; ++i) {
 
713
            pcm_frm.buf = cp->pcm;
 
714
            pcm_frm.size = sizeof(cp->pkt);
 
715
            status = pjmedia_codec_decode(cp->codec, &parsed_frm[i], 
 
716
                                          sizeof(cp->pcm), &pcm_frm);
 
717
            pj_assert(status == PJ_SUCCESS);
 
718
        }
 
719
    }
 
720
 
 
721
    return PJ_SUCCESS;
 
722
}
 
723
 
 
724
static pj_status_t codec_on_destroy(struct pjmedia_port *this_port)
 
725
{
 
726
    struct codec_port *cp = (struct codec_port*)this_port;
 
727
 
 
728
    pjmedia_codec_close(cp->codec);
 
729
    pjmedia_codec_mgr_dealloc_codec(pjmedia_endpt_get_codec_mgr(cp->endpt),
 
730
                                    cp->codec);
 
731
    cp->codec_deinit();
 
732
    pjmedia_endpt_destroy(cp->endpt);
 
733
    return PJ_SUCCESS;
 
734
}
 
735
 
 
736
static pjmedia_port* codec_encode_decode( pj_pool_t *pool,
 
737
                                          const char *codec,
 
738
                                          pj_status_t (*codec_init)(pjmedia_endpt*),
 
739
                                          pj_status_t (*codec_deinit)(),
 
740
                                          unsigned clock_rate,
 
741
                                          unsigned channel_count,
 
742
                                          unsigned samples_per_frame,
 
743
                                          unsigned flags,
 
744
                                          struct test_entry *te)
 
745
{
 
746
    struct codec_port *cp;
 
747
    pj_str_t codec_id;
 
748
    const pjmedia_codec_info *ci[1];
 
749
    unsigned count;
 
750
    pjmedia_codec_param codec_param;
 
751
    pj_status_t status;
 
752
 
 
753
    PJ_UNUSED_ARG(flags);
 
754
    PJ_UNUSED_ARG(te);
 
755
 
 
756
    codec_id = pj_str((char*)codec);
 
757
    cp = PJ_POOL_ZALLOC_T(pool, struct codec_port);
 
758
    pjmedia_port_info_init(&cp->base.info, &codec_id, 0x123456, clock_rate,
 
759
                           channel_count, 16, samples_per_frame);
 
760
    cp->base.put_frame = &codec_put_frame;
 
761
    cp->base.on_destroy = &codec_on_destroy;
 
762
    cp->codec_deinit = codec_deinit;
 
763
 
 
764
    status = pjmedia_endpt_create(mem, NULL, 0, &cp->endpt);
 
765
    if (status != PJ_SUCCESS)
 
766
        return NULL;
 
767
 
 
768
    status = codec_init(cp->endpt);
 
769
    if (status != PJ_SUCCESS)
 
770
        return NULL;
 
771
 
 
772
    count = 1;
 
773
    status = pjmedia_codec_mgr_find_codecs_by_id(pjmedia_endpt_get_codec_mgr(cp->endpt),
 
774
                                                 &codec_id, &count, ci, NULL);
 
775
    if (status != PJ_SUCCESS)
 
776
        return NULL;
 
777
 
 
778
    status = pjmedia_codec_mgr_alloc_codec(pjmedia_endpt_get_codec_mgr(cp->endpt),
 
779
                                           ci[0], &cp->codec);
 
780
    if (status != PJ_SUCCESS)
 
781
        return NULL;
 
782
 
 
783
    status = pjmedia_codec_mgr_get_default_param(pjmedia_endpt_get_codec_mgr(cp->endpt),
 
784
                                                 ci[0], &codec_param);
 
785
    if (status != PJ_SUCCESS)
 
786
        return NULL;
 
787
 
 
788
    status = pjmedia_codec_init(cp->codec, pool);
 
789
    if (status != PJ_SUCCESS)
 
790
        return NULL;
 
791
 
 
792
    status = pjmedia_codec_open(cp->codec, &codec_param);
 
793
    if (status != PJ_SUCCESS)
 
794
        return NULL;
 
795
 
 
796
    return &cp->base;
 
797
}
 
798
#endif
 
799
 
 
800
#if PJMEDIA_HAS_G711_CODEC
 
801
/* G.711 benchmark */
 
802
static pjmedia_port* g711_encode_decode(  pj_pool_t *pool,
 
803
                                          unsigned clock_rate,
 
804
                                          unsigned channel_count,
 
805
                                          unsigned samples_per_frame,
 
806
                                          unsigned flags,
 
807
                                          struct test_entry *te)
 
808
{
 
809
    return codec_encode_decode(pool, "pcmu", &pjmedia_codec_g711_init, 
 
810
                               &pjmedia_codec_g711_deinit,
 
811
                               clock_rate, channel_count,
 
812
                               samples_per_frame, flags, te);
 
813
}
 
814
#endif
 
815
 
 
816
/* GSM benchmark */
 
817
#if PJMEDIA_HAS_GSM_CODEC
 
818
static pjmedia_port* gsm_encode_decode(  pj_pool_t *pool,
 
819
                                         unsigned clock_rate,
 
820
                                         unsigned channel_count,
 
821
                                         unsigned samples_per_frame,
 
822
                                         unsigned flags,
 
823
                                         struct test_entry *te)
 
824
{
 
825
    return codec_encode_decode(pool, "gsm", &pjmedia_codec_gsm_init, 
 
826
                               &pjmedia_codec_gsm_deinit, 
 
827
                               clock_rate, channel_count,
 
828
                               samples_per_frame, flags, te);
 
829
}
 
830
#endif
 
831
 
 
832
#if PJMEDIA_HAS_ILBC_CODEC
 
833
static pj_status_t ilbc_init(pjmedia_endpt *endpt)
 
834
{
 
835
    return pjmedia_codec_ilbc_init(endpt, 20);
 
836
}
 
837
 
 
838
/* iLBC benchmark */
 
839
static pjmedia_port* ilbc_encode_decode( pj_pool_t *pool,
 
840
                                         unsigned clock_rate,
 
841
                                         unsigned channel_count,
 
842
                                         unsigned samples_per_frame,
 
843
                                         unsigned flags,
 
844
                                         struct test_entry *te)
 
845
{
 
846
    samples_per_frame = 30 * clock_rate / 1000;
 
847
    return codec_encode_decode(pool, "ilbc", &ilbc_init, 
 
848
                               &pjmedia_codec_ilbc_deinit, clock_rate, 
 
849
                               channel_count, samples_per_frame, flags, te);
 
850
}
 
851
#endif
 
852
 
 
853
#if PJMEDIA_HAS_SPEEX_CODEC
 
854
/* Speex narrowband benchmark */
 
855
static pjmedia_port* speex8_encode_decode(pj_pool_t *pool,
 
856
                                          unsigned clock_rate,
 
857
                                          unsigned channel_count,
 
858
                                          unsigned samples_per_frame,
 
859
                                          unsigned flags,
 
860
                                          struct test_entry *te)
 
861
{
 
862
    return codec_encode_decode(pool, "speex/8000", 
 
863
                               &pjmedia_codec_speex_init_default, 
 
864
                               &pjmedia_codec_speex_deinit, 
 
865
                               clock_rate, channel_count,
 
866
                               samples_per_frame, flags, te);
 
867
}
 
868
 
 
869
/* Speex wideband benchmark */
 
870
static pjmedia_port* speex16_encode_decode(pj_pool_t *pool,
 
871
                                           unsigned clock_rate,
 
872
                                           unsigned channel_count,
 
873
                                           unsigned samples_per_frame,
 
874
                                           unsigned flags,
 
875
                                           struct test_entry *te)
 
876
{
 
877
    return codec_encode_decode(pool, "speex/16000", 
 
878
                               &pjmedia_codec_speex_init_default, 
 
879
                               &pjmedia_codec_speex_deinit, 
 
880
                               clock_rate, channel_count,
 
881
                               samples_per_frame, flags, te);
 
882
}
 
883
#endif
 
884
 
 
885
#if PJMEDIA_HAS_G722_CODEC
 
886
/* G.722 benchmark benchmark */
 
887
static pjmedia_port* g722_encode_decode(pj_pool_t *pool,
 
888
                                        unsigned clock_rate,
 
889
                                        unsigned channel_count,
 
890
                                        unsigned samples_per_frame,
 
891
                                        unsigned flags,
 
892
                                        struct test_entry *te)
 
893
{
 
894
    return codec_encode_decode(pool, "g722", &pjmedia_codec_g722_init, 
 
895
                               &pjmedia_codec_g722_deinit, 
 
896
                               clock_rate, channel_count,
 
897
                               samples_per_frame, flags, te);
 
898
}
 
899
#endif
 
900
 
 
901
#if PJMEDIA_HAS_G7221_CODEC
 
902
/* G.722.1 benchmark benchmark */
 
903
static pjmedia_port* g7221_encode_decode(pj_pool_t *pool,
 
904
                                         unsigned clock_rate,
 
905
                                         unsigned channel_count,
 
906
                                         unsigned samples_per_frame,
 
907
                                         unsigned flags,
 
908
                                         struct test_entry *te)
 
909
{
 
910
    return codec_encode_decode(pool, "g7221/16000", 
 
911
                               &pjmedia_codec_g7221_init,
 
912
                               &pjmedia_codec_g7221_deinit,
 
913
                               clock_rate, channel_count,
 
914
                               samples_per_frame, flags, te);
 
915
}
 
916
 
 
917
/* G.722.1 Annex C benchmark benchmark */
 
918
static pjmedia_port* g7221c_encode_decode(pj_pool_t *pool,
 
919
                                          unsigned clock_rate,
 
920
                                          unsigned channel_count,
 
921
                                          unsigned samples_per_frame,
 
922
                                          unsigned flags,
 
923
                                          struct test_entry *te)
 
924
{
 
925
    return codec_encode_decode(pool, "g7221/32000", 
 
926
                               &pjmedia_codec_g7221_init,
 
927
                               &pjmedia_codec_g7221_deinit,
 
928
                               clock_rate, channel_count,
 
929
                               samples_per_frame, flags, te);
 
930
}
 
931
#endif  /* PJMEDIA_HAS_G7221_CODEC */
 
932
 
 
933
#if PJMEDIA_HAS_OPENCORE_AMRNB_CODEC
 
934
/* AMR-NB benchmark benchmark */
 
935
static pjmedia_port* amr_encode_decode(pj_pool_t *pool,
 
936
                                       unsigned clock_rate,
 
937
                                       unsigned channel_count,
 
938
                                       unsigned samples_per_frame,
 
939
                                       unsigned flags,
 
940
                                       struct test_entry *te)
 
941
{
 
942
    return codec_encode_decode(pool, "AMR/8000", 
 
943
                               &pjmedia_codec_opencore_amrnb_init,
 
944
                               &pjmedia_codec_opencore_amrnb_deinit,
 
945
                               clock_rate, channel_count,
 
946
                               samples_per_frame, flags, te);
 
947
}
 
948
#endif  /* PJMEDIA_HAS_OPENCORE_AMRNB_CODEC */
 
949
 
 
950
#if PJMEDIA_HAS_OPENCORE_AMRWB_CODEC
 
951
/* AMR-WB benchmark benchmark */
 
952
static pjmedia_port* amrwb_encode_decode(pj_pool_t *pool,
 
953
                                         unsigned clock_rate,
 
954
                                         unsigned channel_count,
 
955
                                         unsigned samples_per_frame,
 
956
                                         unsigned flags,
 
957
                                         struct test_entry *te)
 
958
{
 
959
    return codec_encode_decode(pool, "AMR/16000",
 
960
                               &pjmedia_codec_opencore_amr_init_default,
 
961
                               &pjmedia_codec_opencore_amr_deinit,
 
962
                               clock_rate, channel_count,
 
963
                               samples_per_frame, flags, te);
 
964
}
 
965
#endif  /* PJMEDIA_HAS_OPENCORE_AMRWB_CODEC */
 
966
 
 
967
#if defined(PJMEDIA_HAS_L16_CODEC) && PJMEDIA_HAS_L16_CODEC!=0
 
968
static pj_status_t init_l16_default(pjmedia_endpt *endpt)
 
969
{
 
970
    return pjmedia_codec_l16_init(endpt, 0);
 
971
}
 
972
 
 
973
/* L16/8000/1 benchmark */
 
974
static pjmedia_port* l16_8_encode_decode(pj_pool_t *pool,
 
975
                                         unsigned clock_rate,
 
976
                                         unsigned channel_count,
 
977
                                         unsigned samples_per_frame,
 
978
                                         unsigned flags,
 
979
                                         struct test_entry *te)
 
980
{
 
981
    return codec_encode_decode(pool, "L16/8000/1", &init_l16_default, 
 
982
                               &pjmedia_codec_l16_deinit, 
 
983
                               clock_rate, channel_count,
 
984
                               samples_per_frame, flags, te);
 
985
}
 
986
 
 
987
/* L16/16000/1 benchmark */
 
988
static pjmedia_port* l16_16_encode_decode(pj_pool_t *pool,
 
989
                                          unsigned clock_rate,
 
990
                                          unsigned channel_count,
 
991
                                          unsigned samples_per_frame,
 
992
                                          unsigned flags,
 
993
                                          struct test_entry *te)
 
994
{
 
995
    return codec_encode_decode(pool, "L16/16000/1", &init_l16_default, 
 
996
                               &pjmedia_codec_l16_deinit, 
 
997
                               clock_rate, channel_count,
 
998
                               samples_per_frame, flags, te);
 
999
}
 
1000
#endif
 
1001
 
 
1002
/***************************************************************************/
 
1003
/* WSOLA PLC mode */
 
1004
 
 
1005
struct wsola_plc_port
 
1006
{
 
1007
    pjmedia_port     base;
 
1008
    pjmedia_wsola   *wsola;
 
1009
    pjmedia_port    *gen_port;
 
1010
    int              loss_pct;
 
1011
    pj_bool_t        prev_lost;
 
1012
};
 
1013
 
 
1014
 
 
1015
static pj_status_t wsola_plc_get_frame(struct pjmedia_port *this_port, 
 
1016
                                       pjmedia_frame *frame)
 
1017
{
 
1018
    struct wsola_plc_port *wp = (struct wsola_plc_port*)this_port;
 
1019
    pj_status_t status;
 
1020
 
 
1021
 
 
1022
    if ((pj_rand() % 100) > wp->loss_pct) {
 
1023
        status = pjmedia_port_get_frame(wp->gen_port, frame);
 
1024
        pj_assert(status == PJ_SUCCESS);
 
1025
 
 
1026
        status = pjmedia_wsola_save(wp->wsola, (short*)frame->buf, 
 
1027
                                    wp->prev_lost);
 
1028
        pj_assert(status == PJ_SUCCESS);
 
1029
 
 
1030
        wp->prev_lost = PJ_FALSE;
 
1031
    } else {
 
1032
        status = pjmedia_wsola_generate(wp->wsola, (short*)frame->buf);
 
1033
        wp->prev_lost = PJ_TRUE;
 
1034
    }
 
1035
 
 
1036
    return PJ_SUCCESS;
 
1037
}
 
1038
 
 
1039
static pj_status_t wsola_plc_on_destroy(struct pjmedia_port *this_port)
 
1040
{
 
1041
    struct wsola_plc_port *wp = (struct wsola_plc_port*)this_port;
 
1042
    pjmedia_port_destroy(wp->gen_port);
 
1043
    pjmedia_wsola_destroy(wp->wsola);
 
1044
    return PJ_SUCCESS;
 
1045
}
 
1046
 
 
1047
static pjmedia_port* create_wsola_plc(unsigned loss_pct,
 
1048
                                      pj_pool_t *pool,
 
1049
                                      unsigned clock_rate,
 
1050
                                      unsigned channel_count,
 
1051
                                      unsigned samples_per_frame,
 
1052
                                      unsigned flags,
 
1053
                                      struct test_entry *te)
 
1054
{
 
1055
    struct wsola_plc_port *wp;
 
1056
    pj_str_t name = pj_str("wsola");
 
1057
    unsigned opt = 0;
 
1058
    pj_status_t status;
 
1059
 
 
1060
    PJ_UNUSED_ARG(flags);
 
1061
    PJ_UNUSED_ARG(te);
 
1062
 
 
1063
    wp = PJ_POOL_ZALLOC_T(pool, struct wsola_plc_port);
 
1064
    wp->loss_pct = loss_pct;
 
1065
    wp->base.get_frame = &wsola_plc_get_frame;
 
1066
    wp->base.on_destroy = &wsola_plc_on_destroy;
 
1067
    pjmedia_port_info_init(&wp->base.info, &name, 0x4123, clock_rate, 
 
1068
                           channel_count, 16, samples_per_frame);
 
1069
 
 
1070
    if (loss_pct == 0)
 
1071
        opt |= PJMEDIA_WSOLA_NO_PLC;
 
1072
 
 
1073
    status = pjmedia_wsola_create(pool, clock_rate, samples_per_frame,
 
1074
                                  channel_count, 0, &wp->wsola);
 
1075
    if (status != PJ_SUCCESS)
 
1076
        return NULL;
 
1077
 
 
1078
    wp->gen_port = create_gen_port(pool, clock_rate, channel_count, 
 
1079
                                   samples_per_frame, 100);
 
1080
    if (wp->gen_port == NULL)
 
1081
        return NULL;
 
1082
 
 
1083
    return &wp->base;
 
1084
}
 
1085
 
 
1086
 
 
1087
/* WSOLA PLC with 0% packet loss */
 
1088
static pjmedia_port* wsola_plc_0( pj_pool_t *pool,
 
1089
                                  unsigned clock_rate,
 
1090
                                  unsigned channel_count,
 
1091
                                  unsigned samples_per_frame,
 
1092
                                  unsigned flags,
 
1093
                                  struct test_entry *te)
 
1094
{
 
1095
    return create_wsola_plc(0, pool, clock_rate, channel_count, 
 
1096
                            samples_per_frame, flags, te);
 
1097
}
 
1098
 
 
1099
 
 
1100
/* WSOLA PLC with 2% packet loss */
 
1101
static pjmedia_port* wsola_plc_2( pj_pool_t *pool,
 
1102
                                  unsigned clock_rate,
 
1103
                                  unsigned channel_count,
 
1104
                                  unsigned samples_per_frame,
 
1105
                                  unsigned flags,
 
1106
                                  struct test_entry *te)
 
1107
{
 
1108
    return create_wsola_plc(2, pool, clock_rate, channel_count, 
 
1109
                            samples_per_frame, flags, te);
 
1110
}
 
1111
 
 
1112
/* WSOLA PLC with 5% packet loss */
 
1113
static pjmedia_port* wsola_plc_5( pj_pool_t *pool,
 
1114
                                  unsigned clock_rate,
 
1115
                                  unsigned channel_count,
 
1116
                                  unsigned samples_per_frame,
 
1117
                                  unsigned flags,
 
1118
                                  struct test_entry *te)
 
1119
{
 
1120
    return create_wsola_plc(5, pool, clock_rate, channel_count, 
 
1121
                            samples_per_frame, flags, te);
 
1122
}
 
1123
 
 
1124
/* WSOLA PLC with 10% packet loss */
 
1125
static pjmedia_port* wsola_plc_10(pj_pool_t *pool,
 
1126
                                  unsigned clock_rate,
 
1127
                                  unsigned channel_count,
 
1128
                                  unsigned samples_per_frame,
 
1129
                                  unsigned flags,
 
1130
                                  struct test_entry *te)
 
1131
{
 
1132
    return create_wsola_plc(10, pool, clock_rate, channel_count, 
 
1133
                            samples_per_frame, flags, te);
 
1134
}
 
1135
 
 
1136
/* WSOLA PLC with 20% packet loss */
 
1137
static pjmedia_port* wsola_plc_20(pj_pool_t *pool,
 
1138
                                  unsigned clock_rate,
 
1139
                                  unsigned channel_count,
 
1140
                                  unsigned samples_per_frame,
 
1141
                                  unsigned flags,
 
1142
                                  struct test_entry *te)
 
1143
{
 
1144
    return create_wsola_plc(20, pool, clock_rate, channel_count, 
 
1145
                            samples_per_frame, flags, te);
 
1146
}
 
1147
 
 
1148
/* WSOLA PLC with 50% packet loss */
 
1149
static pjmedia_port* wsola_plc_50(pj_pool_t *pool,
 
1150
                                  unsigned clock_rate,
 
1151
                                  unsigned channel_count,
 
1152
                                  unsigned samples_per_frame,
 
1153
                                  unsigned flags,
 
1154
                                  struct test_entry *te)
 
1155
{
 
1156
    return create_wsola_plc(50, pool, clock_rate, channel_count, 
 
1157
                            samples_per_frame, flags, te);
 
1158
}
 
1159
 
 
1160
 
 
1161
 
 
1162
/***************************************************************************/
 
1163
/* WSOLA discard mode */
 
1164
enum { CIRC_BUF_FRAME_CNT = 4 };
 
1165
struct wsola_discard_port
 
1166
{
 
1167
    pjmedia_port         base;
 
1168
    pjmedia_port        *gen_port;
 
1169
    pjmedia_wsola       *wsola;
 
1170
    pjmedia_circ_buf    *circbuf;
 
1171
    unsigned             discard_pct;
 
1172
};
 
1173
 
 
1174
 
 
1175
static pj_status_t wsola_discard_get_frame(struct pjmedia_port *this_port, 
 
1176
                                           pjmedia_frame *frame)
 
1177
{
 
1178
    struct wsola_discard_port *wp = (struct wsola_discard_port*)this_port;
 
1179
    pj_status_t status;
 
1180
 
 
1181
    while (pjmedia_circ_buf_get_len(wp->circbuf) <
 
1182
                PJMEDIA_PIA_SPF(&wp->base.info) * (CIRC_BUF_FRAME_CNT-1))
 
1183
    {
 
1184
        status = pjmedia_port_get_frame(wp->gen_port, frame);
 
1185
        pj_assert(status==PJ_SUCCESS);
 
1186
 
 
1187
        status = pjmedia_circ_buf_write(wp->circbuf, (short*)frame->buf, 
 
1188
                                        PJMEDIA_PIA_SPF(&wp->base.info));
 
1189
        pj_assert(status==PJ_SUCCESS);
 
1190
    }
 
1191
    
 
1192
    if ((pj_rand() % 100) < (int)wp->discard_pct) {
 
1193
        pj_int16_t *reg1, *reg2;
 
1194
        unsigned reg1_len, reg2_len;
 
1195
        unsigned del_cnt;
 
1196
 
 
1197
        pjmedia_circ_buf_get_read_regions(wp->circbuf, &reg1, &reg1_len,
 
1198
                                          &reg2, &reg2_len);
 
1199
 
 
1200
        del_cnt = PJMEDIA_PIA_SPF(&wp->base.info);
 
1201
        status = pjmedia_wsola_discard(wp->wsola, reg1, reg1_len, reg2, 
 
1202
                                       reg2_len, &del_cnt);
 
1203
        pj_assert(status==PJ_SUCCESS);
 
1204
 
 
1205
        status = pjmedia_circ_buf_adv_read_ptr(wp->circbuf, del_cnt);
 
1206
        pj_assert(status==PJ_SUCCESS);
 
1207
    }
 
1208
 
 
1209
    return PJ_SUCCESS;
 
1210
}
 
1211
 
 
1212
static pj_status_t wsola_discard_on_destroy(struct pjmedia_port *this_port)
 
1213
{
 
1214
    struct wsola_discard_port *wp = (struct wsola_discard_port*)this_port;
 
1215
    pjmedia_port_destroy(wp->gen_port);
 
1216
    pjmedia_wsola_destroy(wp->wsola);
 
1217
    return PJ_SUCCESS;
 
1218
}
 
1219
 
 
1220
 
 
1221
static pjmedia_port* create_wsola_discard(unsigned discard_pct,
 
1222
                                          pj_pool_t *pool,
 
1223
                                          unsigned clock_rate,
 
1224
                                          unsigned channel_count,
 
1225
                                          unsigned samples_per_frame,
 
1226
                                          unsigned flags,
 
1227
                                          struct test_entry *te)
 
1228
{
 
1229
    struct wsola_discard_port *wp;
 
1230
    pj_str_t name = pj_str("wsola");
 
1231
    unsigned i, opt = 0;
 
1232
    pj_status_t status;
 
1233
 
 
1234
    PJ_UNUSED_ARG(flags);
 
1235
    PJ_UNUSED_ARG(te);
 
1236
 
 
1237
    wp = PJ_POOL_ZALLOC_T(pool, struct wsola_discard_port);
 
1238
    wp->discard_pct = discard_pct;
 
1239
    wp->base.get_frame = &wsola_discard_get_frame;
 
1240
    wp->base.on_destroy = &wsola_discard_on_destroy;
 
1241
    pjmedia_port_info_init(&wp->base.info, &name, 0x4123, clock_rate, 
 
1242
                           channel_count, 16, samples_per_frame);
 
1243
 
 
1244
    if (discard_pct == 0)
 
1245
        opt |= PJMEDIA_WSOLA_NO_DISCARD;
 
1246
 
 
1247
    status = pjmedia_wsola_create(pool, clock_rate, samples_per_frame,
 
1248
                                  channel_count, 0, &wp->wsola);
 
1249
    if (status != PJ_SUCCESS)
 
1250
        return NULL;
 
1251
 
 
1252
    wp->gen_port = create_gen_port(pool, clock_rate, channel_count, 
 
1253
                                   samples_per_frame, 100);
 
1254
    if (wp->gen_port == NULL)
 
1255
        return NULL;
 
1256
 
 
1257
    status = pjmedia_circ_buf_create(pool, samples_per_frame * CIRC_BUF_FRAME_CNT, 
 
1258
                                     &wp->circbuf);
 
1259
    if (status != PJ_SUCCESS)
 
1260
        return NULL;
 
1261
 
 
1262
    /* fill up the circbuf */
 
1263
    for (i=0; i<CIRC_BUF_FRAME_CNT; ++i) {
 
1264
        short pcm[320];
 
1265
        pjmedia_frame frm;
 
1266
 
 
1267
        pj_assert(PJ_ARRAY_SIZE(pcm) >= samples_per_frame);
 
1268
        frm.buf = pcm;
 
1269
        frm.size = samples_per_frame * 2;
 
1270
 
 
1271
        status = pjmedia_port_get_frame(wp->gen_port, &frm);
 
1272
        pj_assert(status==PJ_SUCCESS);
 
1273
 
 
1274
        status = pjmedia_circ_buf_write(wp->circbuf, pcm, samples_per_frame);
 
1275
        pj_assert(status==PJ_SUCCESS);
 
1276
    }
 
1277
 
 
1278
    return &wp->base;
 
1279
}
 
1280
 
 
1281
 
 
1282
/* WSOLA with 2% discard rate */
 
1283
static pjmedia_port* wsola_discard_2( pj_pool_t *pool,
 
1284
                                      unsigned clock_rate,
 
1285
                                      unsigned channel_count,
 
1286
                                      unsigned samples_per_frame,
 
1287
                                      unsigned flags,
 
1288
                                      struct test_entry *te)
 
1289
{
 
1290
    return create_wsola_discard(2, pool, clock_rate, channel_count, 
 
1291
                                samples_per_frame, flags, te);
 
1292
}
 
1293
 
 
1294
/* WSOLA with 5% discard rate */
 
1295
static pjmedia_port* wsola_discard_5( pj_pool_t *pool,
 
1296
                                      unsigned clock_rate,
 
1297
                                      unsigned channel_count,
 
1298
                                      unsigned samples_per_frame,
 
1299
                                      unsigned flags,
 
1300
                                      struct test_entry *te)
 
1301
{
 
1302
    return create_wsola_discard(5, pool, clock_rate, channel_count, 
 
1303
                                samples_per_frame, flags, te);
 
1304
}
 
1305
 
 
1306
/* WSOLA with 10% discard rate */
 
1307
static pjmedia_port* wsola_discard_10(pj_pool_t *pool,
 
1308
                                      unsigned clock_rate,
 
1309
                                      unsigned channel_count,
 
1310
                                      unsigned samples_per_frame,
 
1311
                                      unsigned flags,
 
1312
                                      struct test_entry *te)
 
1313
{
 
1314
    return create_wsola_discard(10, pool, clock_rate, channel_count, 
 
1315
                                samples_per_frame, flags, te);
 
1316
}
 
1317
 
 
1318
/* WSOLA with 20% discard rate */
 
1319
static pjmedia_port* wsola_discard_20(pj_pool_t *pool,
 
1320
                                      unsigned clock_rate,
 
1321
                                      unsigned channel_count,
 
1322
                                      unsigned samples_per_frame,
 
1323
                                      unsigned flags,
 
1324
                                      struct test_entry *te)
 
1325
{
 
1326
    return create_wsola_discard(20, pool, clock_rate, channel_count, 
 
1327
                                samples_per_frame, flags, te);
 
1328
}
 
1329
 
 
1330
/* WSOLA with 50% discard rate */
 
1331
static pjmedia_port* wsola_discard_50(pj_pool_t *pool,
 
1332
                                      unsigned clock_rate,
 
1333
                                      unsigned channel_count,
 
1334
                                      unsigned samples_per_frame,
 
1335
                                      unsigned flags,
 
1336
                                      struct test_entry *te)
 
1337
{
 
1338
    return create_wsola_discard(50, pool, clock_rate, channel_count, 
 
1339
                                samples_per_frame, flags, te);
 
1340
}
 
1341
 
 
1342
 
 
1343
 
 
1344
/***************************************************************************/
 
1345
 
 
1346
static pjmedia_port* ec_create(unsigned ec_tail_msec,
 
1347
                               pj_pool_t *pool,
 
1348
                               unsigned clock_rate,
 
1349
                               unsigned channel_count,
 
1350
                               unsigned samples_per_frame,
 
1351
                               unsigned flags,
 
1352
                               struct test_entry *te)
 
1353
{
 
1354
    pjmedia_port *gen_port, *ec_port;
 
1355
    pj_status_t status;
 
1356
 
 
1357
    PJ_UNUSED_ARG(te);
 
1358
 
 
1359
    gen_port = create_gen_port(pool, clock_rate, channel_count, 
 
1360
                               samples_per_frame, 100);
 
1361
    if (gen_port == NULL)
 
1362
        return NULL;
 
1363
 
 
1364
    status = pjmedia_echo_port_create(pool, gen_port, ec_tail_msec, 0,
 
1365
                                      flags, &ec_port);
 
1366
    if (status != PJ_SUCCESS)
 
1367
        return NULL;
 
1368
 
 
1369
    return ec_port;
 
1370
}
 
1371
 
 
1372
/* EC with 100ms tail length */
 
1373
static pjmedia_port* ec_create_100(pj_pool_t *pool,
 
1374
                                   unsigned clock_rate,
 
1375
                                   unsigned channel_count,
 
1376
                                   unsigned samples_per_frame,
 
1377
                                   unsigned flags,
 
1378
                                   struct test_entry *te)
 
1379
{
 
1380
    flags = 0;
 
1381
    return ec_create(100, pool, clock_rate, channel_count, samples_per_frame,
 
1382
                     flags, te);
 
1383
}
 
1384
 
 
1385
/* EC with 128ms tail length */
 
1386
static pjmedia_port* ec_create_128(pj_pool_t *pool,
 
1387
                                   unsigned clock_rate,
 
1388
                                   unsigned channel_count,
 
1389
                                   unsigned samples_per_frame,
 
1390
                                   unsigned flags,
 
1391
                                   struct test_entry *te)
 
1392
{
 
1393
    flags = 0;
 
1394
    return ec_create(128, pool, clock_rate, channel_count, samples_per_frame,
 
1395
                     flags, te);
 
1396
}
 
1397
 
 
1398
/* EC with 200ms tail length */
 
1399
static pjmedia_port* ec_create_200(pj_pool_t *pool,
 
1400
                                   unsigned clock_rate,
 
1401
                                   unsigned channel_count,
 
1402
                                   unsigned samples_per_frame,
 
1403
                                   unsigned flags,
 
1404
                                   struct test_entry *te)
 
1405
{
 
1406
    flags = 0;
 
1407
    return ec_create(200, pool, clock_rate, channel_count, samples_per_frame,
 
1408
                     flags, te);
 
1409
}
 
1410
 
 
1411
/* EC with 256ms tail length */
 
1412
static pjmedia_port* ec_create_256(pj_pool_t *pool,
 
1413
                                   unsigned clock_rate,
 
1414
                                   unsigned channel_count,
 
1415
                                   unsigned samples_per_frame,
 
1416
                                   unsigned flags,
 
1417
                                   struct test_entry *te)
 
1418
{
 
1419
    flags = 0;
 
1420
    return ec_create(256, pool, clock_rate, channel_count, samples_per_frame,
 
1421
                     flags, te);
 
1422
}
 
1423
 
 
1424
 
 
1425
/* EC with 400ms tail length */
 
1426
static pjmedia_port* ec_create_400(pj_pool_t *pool,
 
1427
                                   unsigned clock_rate,
 
1428
                                   unsigned channel_count,
 
1429
                                   unsigned samples_per_frame,
 
1430
                                   unsigned flags,
 
1431
                                   struct test_entry *te)
 
1432
{
 
1433
    flags = 0;
 
1434
    return ec_create(400, pool, clock_rate, channel_count, samples_per_frame,
 
1435
                     flags, te);
 
1436
}
 
1437
 
 
1438
/* EC with 500ms tail length */
 
1439
static pjmedia_port* ec_create_500(pj_pool_t *pool,
 
1440
                                   unsigned clock_rate,
 
1441
                                   unsigned channel_count,
 
1442
                                   unsigned samples_per_frame,
 
1443
                                   unsigned flags,
 
1444
                                   struct test_entry *te)
 
1445
{
 
1446
    flags = 0;
 
1447
    return ec_create(500, pool, clock_rate, channel_count, samples_per_frame,
 
1448
                     flags, te);
 
1449
}
 
1450
 
 
1451
/* EC with 512ms tail length */
 
1452
static pjmedia_port* ec_create_512(pj_pool_t *pool,
 
1453
                                   unsigned clock_rate,
 
1454
                                   unsigned channel_count,
 
1455
                                   unsigned samples_per_frame,
 
1456
                                   unsigned flags,
 
1457
                                   struct test_entry *te)
 
1458
{
 
1459
    flags = 0;
 
1460
    return ec_create(512, pool, clock_rate, channel_count, samples_per_frame,
 
1461
                     flags, te);
 
1462
}
 
1463
 
 
1464
/* EC with 600ms tail length */
 
1465
static pjmedia_port* ec_create_600(pj_pool_t *pool,
 
1466
                                   unsigned clock_rate,
 
1467
                                   unsigned channel_count,
 
1468
                                   unsigned samples_per_frame,
 
1469
                                   unsigned flags,
 
1470
                                   struct test_entry *te)
 
1471
{
 
1472
    flags = 0;
 
1473
    return ec_create(600, pool, clock_rate, channel_count, samples_per_frame,
 
1474
                     flags, te);
 
1475
}
 
1476
 
 
1477
/* EC with 800ms tail length */
 
1478
static pjmedia_port* ec_create_800(pj_pool_t *pool,
 
1479
                                   unsigned clock_rate,
 
1480
                                   unsigned channel_count,
 
1481
                                   unsigned samples_per_frame,
 
1482
                                   unsigned flags,
 
1483
                                   struct test_entry *te)
 
1484
{
 
1485
    flags = 0;
 
1486
    return ec_create(800, pool, clock_rate, channel_count, samples_per_frame,
 
1487
                     flags, te);
 
1488
}
 
1489
 
 
1490
 
 
1491
 
 
1492
/* Echo suppressor with 100ms tail length */
 
1493
static pjmedia_port* es_create_100(pj_pool_t *pool,
 
1494
                                   unsigned clock_rate,
 
1495
                                   unsigned channel_count,
 
1496
                                   unsigned samples_per_frame,
 
1497
                                   unsigned flags,
 
1498
                                   struct test_entry *te)
 
1499
{
 
1500
    flags = PJMEDIA_ECHO_SIMPLE;
 
1501
    return ec_create(100, pool, clock_rate, channel_count, samples_per_frame,
 
1502
                     flags, te);
 
1503
}
 
1504
 
 
1505
/* Echo suppressor with 128ms tail length */
 
1506
static pjmedia_port* es_create_128(pj_pool_t *pool,
 
1507
                                   unsigned clock_rate,
 
1508
                                   unsigned channel_count,
 
1509
                                   unsigned samples_per_frame,
 
1510
                                   unsigned flags,
 
1511
                                   struct test_entry *te)
 
1512
{
 
1513
    flags = PJMEDIA_ECHO_SIMPLE;
 
1514
    return ec_create(128, pool, clock_rate, channel_count, samples_per_frame,
 
1515
                     flags, te);
 
1516
}
 
1517
 
 
1518
/* Echo suppressor with 200ms tail length */
 
1519
static pjmedia_port* es_create_200(pj_pool_t *pool,
 
1520
                                   unsigned clock_rate,
 
1521
                                   unsigned channel_count,
 
1522
                                   unsigned samples_per_frame,
 
1523
                                   unsigned flags,
 
1524
                                   struct test_entry *te)
 
1525
{
 
1526
    flags = PJMEDIA_ECHO_SIMPLE;
 
1527
    return ec_create(200, pool, clock_rate, channel_count, samples_per_frame,
 
1528
                     flags, te);
 
1529
}
 
1530
 
 
1531
/* Echo suppressor with 256ms tail length */
 
1532
static pjmedia_port* es_create_256(pj_pool_t *pool,
 
1533
                                   unsigned clock_rate,
 
1534
                                   unsigned channel_count,
 
1535
                                   unsigned samples_per_frame,
 
1536
                                   unsigned flags,
 
1537
                                   struct test_entry *te)
 
1538
{
 
1539
    flags = PJMEDIA_ECHO_SIMPLE;
 
1540
    return ec_create(256, pool, clock_rate, channel_count, samples_per_frame,
 
1541
                     flags, te);
 
1542
}
 
1543
 
 
1544
 
 
1545
/* Echo suppressor with 400ms tail length */
 
1546
static pjmedia_port* es_create_400(pj_pool_t *pool,
 
1547
                                   unsigned clock_rate,
 
1548
                                   unsigned channel_count,
 
1549
                                   unsigned samples_per_frame,
 
1550
                                   unsigned flags,
 
1551
                                   struct test_entry *te)
 
1552
{
 
1553
    flags = PJMEDIA_ECHO_SIMPLE;
 
1554
    return ec_create(400, pool, clock_rate, channel_count, samples_per_frame,
 
1555
                     flags, te);
 
1556
}
 
1557
 
 
1558
/* Echo suppressor with 500ms tail length */
 
1559
static pjmedia_port* es_create_500(pj_pool_t *pool,
 
1560
                                   unsigned clock_rate,
 
1561
                                   unsigned channel_count,
 
1562
                                   unsigned samples_per_frame,
 
1563
                                   unsigned flags,
 
1564
                                   struct test_entry *te)
 
1565
{
 
1566
    flags = PJMEDIA_ECHO_SIMPLE;
 
1567
    return ec_create(500, pool, clock_rate, channel_count, samples_per_frame,
 
1568
                     flags, te);
 
1569
}
 
1570
 
 
1571
/* Echo suppressor with 512ms tail length */
 
1572
static pjmedia_port* es_create_512(pj_pool_t *pool,
 
1573
                                   unsigned clock_rate,
 
1574
                                   unsigned channel_count,
 
1575
                                   unsigned samples_per_frame,
 
1576
                                   unsigned flags,
 
1577
                                   struct test_entry *te)
 
1578
{
 
1579
    flags = PJMEDIA_ECHO_SIMPLE;
 
1580
    return ec_create(512, pool, clock_rate, channel_count, samples_per_frame,
 
1581
                     flags, te);
 
1582
}
 
1583
 
 
1584
/* Echo suppressor with 600ms tail length */
 
1585
static pjmedia_port* es_create_600(pj_pool_t *pool,
 
1586
                                   unsigned clock_rate,
 
1587
                                   unsigned channel_count,
 
1588
                                   unsigned samples_per_frame,
 
1589
                                   unsigned flags,
 
1590
                                   struct test_entry *te)
 
1591
{
 
1592
    flags = PJMEDIA_ECHO_SIMPLE;
 
1593
    return ec_create(600, pool, clock_rate, channel_count, samples_per_frame,
 
1594
                     flags, te);
 
1595
}
 
1596
 
 
1597
/* Echo suppressor with 800ms tail length */
 
1598
static pjmedia_port* es_create_800(pj_pool_t *pool,
 
1599
                                   unsigned clock_rate,
 
1600
                                   unsigned channel_count,
 
1601
                                   unsigned samples_per_frame,
 
1602
                                   unsigned flags,
 
1603
                                   struct test_entry *te)
 
1604
{
 
1605
    flags = PJMEDIA_ECHO_SIMPLE;
 
1606
    return ec_create(800, pool, clock_rate, channel_count, samples_per_frame,
 
1607
                     flags, te);
 
1608
}
 
1609
 
 
1610
 
 
1611
/***************************************************************************/
 
1612
/* Tone generator, single frequency */
 
1613
static pjmedia_port* create_tonegen(unsigned freq1,
 
1614
                                    unsigned freq2,
 
1615
                                    pj_pool_t *pool,
 
1616
                                    unsigned clock_rate,
 
1617
                                    unsigned channel_count,
 
1618
                                    unsigned samples_per_frame,
 
1619
                                    unsigned flags,
 
1620
                                    struct test_entry *te)
 
1621
{
 
1622
    pjmedia_port *tonegen;
 
1623
    pjmedia_tone_desc tones[2];
 
1624
    pj_status_t status;
 
1625
 
 
1626
    PJ_UNUSED_ARG(flags);
 
1627
    PJ_UNUSED_ARG(te);
 
1628
 
 
1629
    status = pjmedia_tonegen_create(pool, clock_rate, channel_count,
 
1630
                                    samples_per_frame, 16, 
 
1631
                                    PJMEDIA_TONEGEN_LOOP, &tonegen);
 
1632
    if (status != PJ_SUCCESS)
 
1633
        return NULL;
 
1634
 
 
1635
    pj_bzero(tones, sizeof(tones));
 
1636
    tones[0].freq1 = (short)freq1;
 
1637
    tones[0].freq2 = (short)freq2;
 
1638
    tones[0].on_msec = 400;
 
1639
    tones[0].off_msec = 0;
 
1640
    tones[1].freq1 = (short)freq1;
 
1641
    tones[1].freq2 = (short)freq2;
 
1642
    tones[1].on_msec = 400;
 
1643
    tones[1].off_msec = 100;
 
1644
 
 
1645
    status = pjmedia_tonegen_play(tonegen, PJ_ARRAY_SIZE(tones), tones, 
 
1646
                                  PJMEDIA_TONEGEN_LOOP);
 
1647
    if (status != PJ_SUCCESS)
 
1648
        return NULL;
 
1649
 
 
1650
    return tonegen;
 
1651
}
 
1652
 
 
1653
/* Tonegen with single frequency */
 
1654
static pjmedia_port* create_tonegen1(pj_pool_t *pool,
 
1655
                                     unsigned clock_rate,
 
1656
                                     unsigned channel_count,
 
1657
                                     unsigned samples_per_frame,
 
1658
                                     unsigned flags,
 
1659
                                     struct test_entry *te)
 
1660
{
 
1661
    return create_tonegen(400, 0, pool, clock_rate, channel_count,
 
1662
                          samples_per_frame, flags, te);
 
1663
}
 
1664
 
 
1665
/* Tonegen with dual frequency */
 
1666
static pjmedia_port* create_tonegen2(pj_pool_t *pool,
 
1667
                                     unsigned clock_rate,
 
1668
                                     unsigned channel_count,
 
1669
                                     unsigned samples_per_frame,
 
1670
                                     unsigned flags,
 
1671
                                     struct test_entry *te)
 
1672
{
 
1673
    return create_tonegen(400, 440, pool, clock_rate, channel_count,
 
1674
                          samples_per_frame, flags, te);
 
1675
}
 
1676
 
 
1677
 
 
1678
 
 
1679
/***************************************************************************/
 
1680
/* Stream */
 
1681
 
 
1682
struct stream_port
 
1683
{
 
1684
    pjmedia_port         base;
 
1685
    pj_status_t        (*codec_deinit)();
 
1686
    pjmedia_endpt       *endpt;
 
1687
    pjmedia_stream      *stream;
 
1688
    pjmedia_transport   *transport;
 
1689
};
 
1690
 
 
1691
 
 
1692
static void stream_port_custom_deinit(struct test_entry *te)
 
1693
{
 
1694
    struct stream_port *sp = (struct stream_port*) te->pdata[0];
 
1695
 
 
1696
    pjmedia_stream_destroy(sp->stream);
 
1697
    pjmedia_transport_close(sp->transport);
 
1698
    sp->codec_deinit();
 
1699
    pjmedia_endpt_destroy(sp->endpt);
 
1700
 
 
1701
}
 
1702
 
 
1703
#if PJMEDIA_HAS_L16_CODEC || \
 
1704
    PJMEDIA_HAS_OPENCORE_AMRWB_CODEC || PJMEDIA_HAS_OPENCORE_AMRNB_CODEC || \
 
1705
    PJMEDIA_HAS_G7221_CODEC || PJMEDIA_HAS_G722_CODEC || PJMEDIA_HAS_G711_CODEC || \
 
1706
    PJMEDIA_HAS_SPEEX_CODEC || PJMEDIA_HAS_ILBC_CODEC || PJMEDIA_HAS_GSM_CODEC
 
1707
static pjmedia_port* create_stream( pj_pool_t *pool,
 
1708
                                    const char *codec,
 
1709
                                    pj_status_t (*codec_init)(pjmedia_endpt*),
 
1710
                                    pj_status_t (*codec_deinit)(),
 
1711
                                    pj_bool_t srtp_enabled,
 
1712
                                    pj_bool_t srtp_80,
 
1713
                                    pj_bool_t srtp_auth,
 
1714
                                    unsigned clock_rate,
 
1715
                                    unsigned channel_count,
 
1716
                                    unsigned samples_per_frame,
 
1717
                                    unsigned flags,
 
1718
                                    struct test_entry *te)
 
1719
{
 
1720
    struct stream_port *sp;
 
1721
    pj_str_t codec_id;
 
1722
    pjmedia_port *port;
 
1723
    const pjmedia_codec_info *ci[1];
 
1724
    unsigned count;
 
1725
    pjmedia_codec_param codec_param;
 
1726
    pjmedia_stream_info si;
 
1727
    pj_status_t status;
 
1728
 
 
1729
    PJ_UNUSED_ARG(flags);
 
1730
 
 
1731
    codec_id = pj_str((char*)codec);
 
1732
    sp = PJ_POOL_ZALLOC_T(pool, struct stream_port);
 
1733
    pjmedia_port_info_init(&sp->base.info, &codec_id, 0x123456, clock_rate,
 
1734
                           channel_count, 16, samples_per_frame);
 
1735
 
 
1736
    te->pdata[0] = sp;
 
1737
    te->custom_deinit = &stream_port_custom_deinit;
 
1738
    sp->codec_deinit = codec_deinit;
 
1739
 
 
1740
    status = pjmedia_endpt_create(mem, NULL, 0, &sp->endpt);
 
1741
    if (status != PJ_SUCCESS)
 
1742
        return NULL;
 
1743
 
 
1744
    status = codec_init(sp->endpt);
 
1745
    if (status != PJ_SUCCESS)
 
1746
        return NULL;
 
1747
 
 
1748
    count = 1;
 
1749
    status = pjmedia_codec_mgr_find_codecs_by_id(pjmedia_endpt_get_codec_mgr(sp->endpt),
 
1750
                                                 &codec_id, &count, ci, NULL);
 
1751
    if (status != PJ_SUCCESS)
 
1752
        return NULL;
 
1753
 
 
1754
 
 
1755
 
 
1756
    status = pjmedia_codec_mgr_get_default_param(pjmedia_endpt_get_codec_mgr(sp->endpt),
 
1757
                                                 ci[0], &codec_param);
 
1758
    if (status != PJ_SUCCESS)
 
1759
        return NULL;
 
1760
 
 
1761
    /* Create stream info */
 
1762
    pj_bzero(&si, sizeof(si));
 
1763
    si.type = PJMEDIA_TYPE_AUDIO;
 
1764
    si.proto = PJMEDIA_TP_PROTO_RTP_AVP;
 
1765
    si.dir = PJMEDIA_DIR_ENCODING_DECODING;
 
1766
    pj_sockaddr_in_init(&si.rem_addr.ipv4, NULL, 4000);
 
1767
    pj_sockaddr_in_init(&si.rem_rtcp.ipv4, NULL, 4001);
 
1768
    pj_memcpy(&si.fmt, ci[0], sizeof(pjmedia_codec_info));
 
1769
    si.param = NULL;
 
1770
    si.tx_pt = ci[0]->pt;
 
1771
    si.tx_event_pt = 101;
 
1772
    si.rx_event_pt = 101;
 
1773
    si.ssrc = pj_rand();
 
1774
    si.jb_init = si.jb_min_pre = si.jb_max_pre = si.jb_max = -1;
 
1775
 
 
1776
    /* Create loop transport */
 
1777
    status = pjmedia_transport_loop_create(sp->endpt, &sp->transport);
 
1778
    if (status != PJ_SUCCESS)
 
1779
        return NULL;
 
1780
 
 
1781
#if PJMEDIA_HAS_SRTP
 
1782
    if (srtp_enabled) {
 
1783
        pjmedia_srtp_setting opt;
 
1784
        pjmedia_srtp_crypto crypto;
 
1785
        pjmedia_transport *srtp;
 
1786
 
 
1787
        pjmedia_srtp_setting_default(&opt);
 
1788
        opt.close_member_tp = PJ_TRUE;
 
1789
        opt.use = PJMEDIA_SRTP_MANDATORY;
 
1790
 
 
1791
        status = pjmedia_transport_srtp_create(sp->endpt, sp->transport, &opt,
 
1792
                                               &srtp);
 
1793
        if (status != PJ_SUCCESS)
 
1794
            return NULL;
 
1795
 
 
1796
        pj_bzero(&crypto, sizeof(crypto));
 
1797
        if (srtp_80) {
 
1798
            crypto.key = pj_str("123456789012345678901234567890");
 
1799
            crypto.name = pj_str("AES_CM_128_HMAC_SHA1_80");
 
1800
        } else {
 
1801
            crypto.key = pj_str("123456789012345678901234567890");
 
1802
            crypto.name = pj_str("AES_CM_128_HMAC_SHA1_32");
 
1803
        }
 
1804
 
 
1805
        if (!srtp_auth)
 
1806
            crypto.flags = PJMEDIA_SRTP_NO_AUTHENTICATION;
 
1807
 
 
1808
        status = pjmedia_transport_srtp_start(srtp, &crypto, &crypto);
 
1809
        if (status != PJ_SUCCESS)
 
1810
            return NULL;
 
1811
 
 
1812
        sp->transport = srtp;
 
1813
    }
 
1814
#endif
 
1815
 
 
1816
    /* Create stream */
 
1817
    status = pjmedia_stream_create(sp->endpt, pool, &si, sp->transport, NULL, 
 
1818
                                   &sp->stream);
 
1819
    if (status != PJ_SUCCESS)
 
1820
        return NULL;
 
1821
 
 
1822
    /* Start stream */
 
1823
    status = pjmedia_stream_start(sp->stream);
 
1824
    if (status != PJ_SUCCESS)
 
1825
        return NULL;
 
1826
 
 
1827
    status = pjmedia_stream_get_port(sp->stream, &port);
 
1828
    if (status != PJ_SUCCESS)
 
1829
        return NULL;
 
1830
 
 
1831
    return port;
 
1832
}
 
1833
#endif
 
1834
 
 
1835
#if PJMEDIA_HAS_G711_CODEC
 
1836
/* G.711 stream, no SRTP */
 
1837
static pjmedia_port* create_stream_pcmu( pj_pool_t *pool,
 
1838
                                         unsigned clock_rate,
 
1839
                                         unsigned channel_count,
 
1840
                                         unsigned samples_per_frame,
 
1841
                                         unsigned flags,
 
1842
                                         struct test_entry *te)
 
1843
{
 
1844
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init, 
 
1845
                         &pjmedia_codec_g711_deinit,
 
1846
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
 
1847
                         clock_rate, channel_count,
 
1848
                         samples_per_frame, flags, te);
 
1849
}
 
1850
 
 
1851
/* G.711 stream, SRTP 32bit key no auth */
 
1852
static pjmedia_port* create_stream_pcmu_srtp32_no_auth( pj_pool_t *pool,
 
1853
                                                        unsigned clock_rate,
 
1854
                                                        unsigned channel_count,
 
1855
                                                        unsigned samples_per_frame,
 
1856
                                                        unsigned flags,
 
1857
                                                        struct test_entry *te)
 
1858
{
 
1859
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init, 
 
1860
                         &pjmedia_codec_g711_deinit,
 
1861
                         PJ_TRUE, PJ_FALSE, PJ_FALSE,
 
1862
                         clock_rate, channel_count,
 
1863
                         samples_per_frame, flags, te);
 
1864
}
 
1865
 
 
1866
/* G.711 stream, SRTP 32bit key with auth */
 
1867
static pjmedia_port* create_stream_pcmu_srtp32_with_auth(pj_pool_t *pool,
 
1868
                                                         unsigned clock_rate,
 
1869
                                                         unsigned channel_count,
 
1870
                                                         unsigned samples_per_frame,
 
1871
                                                         unsigned flags,
 
1872
                                                         struct test_entry *te)
 
1873
{
 
1874
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init, 
 
1875
                         &pjmedia_codec_g711_deinit,
 
1876
                         PJ_TRUE, PJ_FALSE, PJ_TRUE,
 
1877
                         clock_rate, channel_count,
 
1878
                         samples_per_frame, flags, te);
 
1879
}
 
1880
 
 
1881
/* G.711 stream, SRTP 80bit key no auth */
 
1882
static pjmedia_port* create_stream_pcmu_srtp80_no_auth( pj_pool_t *pool,
 
1883
                                                        unsigned clock_rate,
 
1884
                                                        unsigned channel_count,
 
1885
                                                        unsigned samples_per_frame,
 
1886
                                                        unsigned flags,
 
1887
                                                        struct test_entry *te)
 
1888
{
 
1889
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init, 
 
1890
                         &pjmedia_codec_g711_deinit,
 
1891
                         PJ_TRUE, PJ_TRUE, PJ_FALSE,
 
1892
                         clock_rate, channel_count,
 
1893
                         samples_per_frame, flags, te);
 
1894
}
 
1895
 
 
1896
/* G.711 stream, SRTP 80bit key with auth */
 
1897
static pjmedia_port* create_stream_pcmu_srtp80_with_auth(pj_pool_t *pool,
 
1898
                                                         unsigned clock_rate,
 
1899
                                                         unsigned channel_count,
 
1900
                                                         unsigned samples_per_frame,
 
1901
                                                         unsigned flags,
 
1902
                                                         struct test_entry *te)
 
1903
{
 
1904
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init, 
 
1905
                         &pjmedia_codec_g711_deinit,
 
1906
                         PJ_TRUE, PJ_TRUE, PJ_TRUE,
 
1907
                         clock_rate, channel_count,
 
1908
                         samples_per_frame, flags, te);
 
1909
}
 
1910
#endif
 
1911
 
 
1912
#if PJMEDIA_HAS_GSM_CODEC
 
1913
/* GSM stream */
 
1914
static pjmedia_port* create_stream_gsm(  pj_pool_t *pool,
 
1915
                                         unsigned clock_rate,
 
1916
                                         unsigned channel_count,
 
1917
                                         unsigned samples_per_frame,
 
1918
                                         unsigned flags,
 
1919
                                         struct test_entry *te)
 
1920
{
 
1921
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init, 
 
1922
                         &pjmedia_codec_gsm_deinit, 
 
1923
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
 
1924
                         clock_rate, channel_count,
 
1925
                         samples_per_frame, flags, te);
 
1926
}
 
1927
 
 
1928
/* GSM stream, SRTP 32bit, no auth */
 
1929
static pjmedia_port* create_stream_gsm_srtp32_no_auth(pj_pool_t *pool,
 
1930
                                                      unsigned clock_rate,
 
1931
                                                      unsigned channel_count,
 
1932
                                                      unsigned samples_per_frame,
 
1933
                                                      unsigned flags,
 
1934
                                                      struct test_entry *te)
 
1935
{
 
1936
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init, 
 
1937
                         &pjmedia_codec_gsm_deinit, 
 
1938
                         PJ_TRUE, PJ_FALSE, PJ_FALSE,
 
1939
                         clock_rate, channel_count,
 
1940
                         samples_per_frame, flags, te);
 
1941
}
 
1942
 
 
1943
/* GSM stream, SRTP 32bit, with auth */
 
1944
static pjmedia_port* create_stream_gsm_srtp32_with_auth(pj_pool_t *pool,
 
1945
                                                        unsigned clock_rate,
 
1946
                                                        unsigned channel_count,
 
1947
                                                        unsigned samples_per_frame,
 
1948
                                                        unsigned flags,
 
1949
                                                        struct test_entry *te)
 
1950
{
 
1951
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init, 
 
1952
                         &pjmedia_codec_gsm_deinit, 
 
1953
                         PJ_TRUE, PJ_FALSE, PJ_TRUE,
 
1954
                         clock_rate, channel_count,
 
1955
                         samples_per_frame, flags, te);
 
1956
}
 
1957
 
 
1958
/* GSM stream, SRTP 80bit, no auth */
 
1959
static pjmedia_port* create_stream_gsm_srtp80_no_auth(pj_pool_t *pool,
 
1960
                                                      unsigned clock_rate,
 
1961
                                                      unsigned channel_count,
 
1962
                                                      unsigned samples_per_frame,
 
1963
                                                      unsigned flags,
 
1964
                                                      struct test_entry *te)
 
1965
{
 
1966
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init, 
 
1967
                         &pjmedia_codec_gsm_deinit, 
 
1968
                         PJ_TRUE, PJ_TRUE, PJ_FALSE,
 
1969
                         clock_rate, channel_count,
 
1970
                         samples_per_frame, flags, te);
 
1971
}
 
1972
 
 
1973
/* GSM stream, SRTP 80bit, with auth */
 
1974
static pjmedia_port* create_stream_gsm_srtp80_with_auth(pj_pool_t *pool,
 
1975
                                                        unsigned clock_rate,
 
1976
                                                        unsigned channel_count,
 
1977
                                                        unsigned samples_per_frame,
 
1978
                                                        unsigned flags,
 
1979
                                                        struct test_entry *te)
 
1980
{
 
1981
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init, 
 
1982
                         &pjmedia_codec_gsm_deinit, 
 
1983
                         PJ_TRUE, PJ_TRUE, PJ_TRUE,
 
1984
                         clock_rate, channel_count,
 
1985
                         samples_per_frame, flags, te);
 
1986
}
 
1987
#endif
 
1988
 
 
1989
#if PJMEDIA_HAS_G722_CODEC
 
1990
/* G722 stream */
 
1991
static pjmedia_port* create_stream_g722( pj_pool_t *pool,
 
1992
                                         unsigned clock_rate,
 
1993
                                         unsigned channel_count,
 
1994
                                         unsigned samples_per_frame,
 
1995
                                         unsigned flags,
 
1996
                                         struct test_entry *te)
 
1997
{
 
1998
    return create_stream(pool, "g722", &pjmedia_codec_g722_init, 
 
1999
                         &pjmedia_codec_g722_deinit, 
 
2000
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
 
2001
                         clock_rate, channel_count,
 
2002
                         samples_per_frame, flags, te);
 
2003
}
 
2004
#endif
 
2005
 
 
2006
#if PJMEDIA_HAS_G7221_CODEC
 
2007
/* G722.1 stream */
 
2008
static pjmedia_port* create_stream_g7221( pj_pool_t *pool,
 
2009
                                          unsigned clock_rate,
 
2010
                                          unsigned channel_count,
 
2011
                                          unsigned samples_per_frame,
 
2012
                                          unsigned flags,
 
2013
                                          struct test_entry *te)
 
2014
{
 
2015
    return create_stream(pool, "g7221/16000", &pjmedia_codec_g7221_init, 
 
2016
                         &pjmedia_codec_g7221_deinit, 
 
2017
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
 
2018
                         clock_rate, channel_count,
 
2019
                         samples_per_frame, flags, te);
 
2020
}
 
2021
 
 
2022
/* G722.1 Annex C stream */
 
2023
static pjmedia_port* create_stream_g7221c( pj_pool_t *pool,
 
2024
                                           unsigned clock_rate,
 
2025
                                           unsigned channel_count,
 
2026
                                           unsigned samples_per_frame,
 
2027
                                           unsigned flags,
 
2028
                                           struct test_entry *te)
 
2029
{
 
2030
    return create_stream(pool, "g7221/32000", &pjmedia_codec_g7221_init,
 
2031
                         &pjmedia_codec_g7221_deinit, 
 
2032
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
 
2033
                         clock_rate, channel_count,
 
2034
                         samples_per_frame, flags, te);
 
2035
}
 
2036
#endif  /* PJMEDIA_HAS_G7221_CODEC */ 
 
2037
 
 
2038
/* AMR-NB stream */
 
2039
#if PJMEDIA_HAS_OPENCORE_AMRNB_CODEC
 
2040
static pjmedia_port* create_stream_amr( pj_pool_t *pool,
 
2041
                                        unsigned clock_rate,
 
2042
                                        unsigned channel_count,
 
2043
                                        unsigned samples_per_frame,
 
2044
                                        unsigned flags,
 
2045
                                        struct test_entry *te)
 
2046
{
 
2047
    return create_stream(pool, "AMR/8000", &pjmedia_codec_opencore_amrnb_init, 
 
2048
                         &pjmedia_codec_opencore_amrnb_deinit, 
 
2049
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
 
2050
                         clock_rate, channel_count,
 
2051
                         samples_per_frame, flags, te);
 
2052
}
 
2053
#endif  /* PJMEDIA_HAS_OPENCORE_AMRNB_CODEC */
 
2054
 
 
2055
/* AMR-WB stream */
 
2056
#if PJMEDIA_HAS_OPENCORE_AMRWB_CODEC
 
2057
static pjmedia_port* create_stream_amrwb( pj_pool_t *pool,
 
2058
                                         unsigned clock_rate,
 
2059
                                         unsigned channel_count,
 
2060
                                         unsigned samples_per_frame,
 
2061
                                         unsigned flags,
 
2062
                                         struct test_entry *te)
 
2063
{
 
2064
    return create_stream(pool, "AMR/16000",
 
2065
                         &pjmedia_codec_opencore_amr_init_default,
 
2066
                         &pjmedia_codec_opencore_amr_deinit,
 
2067
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
 
2068
                         clock_rate, channel_count,
 
2069
                         samples_per_frame, flags, te);
 
2070
}
 
2071
#endif  /* PJMEDIA_HAS_OPENCORE_AMRWB_CODEC */
 
2072
 
 
2073
/***************************************************************************/
 
2074
/* Delay buffer */
 
2075
enum {DELAY_BUF_MAX_DELAY = 80};
 
2076
struct delaybuf_port
 
2077
{
 
2078
    pjmedia_port         base;
 
2079
    pjmedia_delay_buf   *delaybuf;
 
2080
    pjmedia_port        *gen_port;
 
2081
    int                  drift_pct;
 
2082
};
 
2083
 
 
2084
 
 
2085
static pj_status_t delaybuf_get_frame(struct pjmedia_port *this_port, 
 
2086
                                      pjmedia_frame *frame)
 
2087
{
 
2088
    struct delaybuf_port *dp = (struct delaybuf_port*)this_port;
 
2089
    pj_status_t status;
 
2090
 
 
2091
    status = pjmedia_delay_buf_get(dp->delaybuf, (pj_int16_t*)frame->buf);
 
2092
    pj_assert(status == PJ_SUCCESS);
 
2093
 
 
2094
    /* Additional GET when drift_pct is negative */
 
2095
    if (dp->drift_pct < 0) {
 
2096
        int rnd;
 
2097
        rnd = pj_rand() % 100;
 
2098
 
 
2099
        if (rnd < -dp->drift_pct) {
 
2100
            status = pjmedia_delay_buf_get(dp->delaybuf, (pj_int16_t*)frame->buf);
 
2101
            pj_assert(status == PJ_SUCCESS);
 
2102
        }
 
2103
    }
 
2104
 
 
2105
    return PJ_SUCCESS;
 
2106
}
 
2107
 
 
2108
static pj_status_t delaybuf_put_frame(struct pjmedia_port *this_port, 
 
2109
                                      pjmedia_frame *frame)
 
2110
{
 
2111
    struct delaybuf_port *dp = (struct delaybuf_port*)this_port;
 
2112
    pj_status_t status;
 
2113
    pjmedia_frame f = *frame;
 
2114
 
 
2115
    status = pjmedia_port_get_frame(dp->gen_port, &f);
 
2116
    pj_assert(status == PJ_SUCCESS);
 
2117
    status = pjmedia_delay_buf_put(dp->delaybuf, (pj_int16_t*)f.buf);
 
2118
    pj_assert(status == PJ_SUCCESS);
 
2119
 
 
2120
    /* Additional PUT when drift_pct is possitive */
 
2121
    if (dp->drift_pct > 0) {
 
2122
        int rnd;
 
2123
        rnd = pj_rand() % 100;
 
2124
 
 
2125
        if (rnd < dp->drift_pct) {
 
2126
            status = pjmedia_port_get_frame(dp->gen_port, &f);
 
2127
            pj_assert(status == PJ_SUCCESS);
 
2128
            status = pjmedia_delay_buf_put(dp->delaybuf, (pj_int16_t*)f.buf);
 
2129
            pj_assert(status == PJ_SUCCESS);
 
2130
        }
 
2131
    }
 
2132
 
 
2133
    return PJ_SUCCESS;
 
2134
}
 
2135
 
 
2136
static pj_status_t delaybuf_on_destroy(struct pjmedia_port *this_port)
 
2137
{
 
2138
    struct delaybuf_port *dp = (struct delaybuf_port*)this_port;
 
2139
    pjmedia_port_destroy(dp->gen_port);
 
2140
    pjmedia_delay_buf_destroy(dp->delaybuf);
 
2141
    return PJ_SUCCESS;
 
2142
}
 
2143
 
 
2144
static pjmedia_port* create_delaybuf(int drift_pct,
 
2145
                                     pj_pool_t *pool,
 
2146
                                     unsigned clock_rate,
 
2147
                                     unsigned channel_count,
 
2148
                                     unsigned samples_per_frame,
 
2149
                                     unsigned flags,
 
2150
                                     struct test_entry *te)
 
2151
{
 
2152
    struct delaybuf_port *dp;
 
2153
    pj_str_t name = pj_str("delaybuf");
 
2154
    unsigned opt = 0;
 
2155
    pj_status_t status;
 
2156
 
 
2157
    PJ_UNUSED_ARG(flags);
 
2158
    PJ_UNUSED_ARG(te);
 
2159
 
 
2160
    dp = PJ_POOL_ZALLOC_T(pool, struct delaybuf_port);
 
2161
    dp->drift_pct = drift_pct;
 
2162
    dp->base.get_frame = &delaybuf_get_frame;
 
2163
    dp->base.put_frame = &delaybuf_put_frame;
 
2164
    dp->base.on_destroy = &delaybuf_on_destroy;
 
2165
    pjmedia_port_info_init(&dp->base.info, &name, 0x5678, clock_rate, 
 
2166
                           channel_count, 16, samples_per_frame);
 
2167
 
 
2168
    status = pjmedia_delay_buf_create(pool, "mips_test", clock_rate, 
 
2169
                                      samples_per_frame, channel_count, 
 
2170
                                      DELAY_BUF_MAX_DELAY,
 
2171
                                      opt, &dp->delaybuf);
 
2172
    if (status != PJ_SUCCESS)
 
2173
        return NULL;
 
2174
 
 
2175
    dp->gen_port = create_gen_port(pool, clock_rate, channel_count, 
 
2176
                                   samples_per_frame, 100);
 
2177
    if (dp->gen_port == NULL)
 
2178
        return NULL;
 
2179
 
 
2180
    return &dp->base;
 
2181
}
 
2182
 
 
2183
 
 
2184
/* Delay buffer without drift */
 
2185
static pjmedia_port* delaybuf_0( pj_pool_t *pool,
 
2186
                                  unsigned clock_rate,
 
2187
                                  unsigned channel_count,
 
2188
                                  unsigned samples_per_frame,
 
2189
                                  unsigned flags,
 
2190
                                  struct test_entry *te)
 
2191
{
 
2192
    return create_delaybuf(0, pool, clock_rate, channel_count, 
 
2193
                           samples_per_frame, flags, te);
 
2194
}
 
2195
 
 
2196
 
 
2197
/* Delay buffer with 2% drift */
 
2198
static pjmedia_port* delaybuf_p2( pj_pool_t *pool,
 
2199
                                  unsigned clock_rate,
 
2200
                                  unsigned channel_count,
 
2201
                                  unsigned samples_per_frame,
 
2202
                                  unsigned flags,
 
2203
                                  struct test_entry *te)
 
2204
{
 
2205
    return create_delaybuf(2, pool, clock_rate, channel_count, 
 
2206
                           samples_per_frame, flags, te);
 
2207
}
 
2208
 
 
2209
/* Delay buffer with 5% drift */
 
2210
static pjmedia_port* delaybuf_p5( pj_pool_t *pool,
 
2211
                                  unsigned clock_rate,
 
2212
                                  unsigned channel_count,
 
2213
                                  unsigned samples_per_frame,
 
2214
                                  unsigned flags,
 
2215
                                  struct test_entry *te)
 
2216
{
 
2217
    return create_delaybuf(5, pool, clock_rate, channel_count, 
 
2218
                           samples_per_frame, flags, te);
 
2219
}
 
2220
 
 
2221
/* Delay buffer with 10% drift */
 
2222
static pjmedia_port* delaybuf_p10(pj_pool_t *pool,
 
2223
                                  unsigned clock_rate,
 
2224
                                  unsigned channel_count,
 
2225
                                  unsigned samples_per_frame,
 
2226
                                  unsigned flags,
 
2227
                                  struct test_entry *te)
 
2228
{
 
2229
    return create_delaybuf(10, pool, clock_rate, channel_count, 
 
2230
                           samples_per_frame, flags, te);
 
2231
}
 
2232
 
 
2233
/* Delay buffer with 20% drift */
 
2234
static pjmedia_port* delaybuf_p20(pj_pool_t *pool,
 
2235
                                  unsigned clock_rate,
 
2236
                                  unsigned channel_count,
 
2237
                                  unsigned samples_per_frame,
 
2238
                                  unsigned flags,
 
2239
                                  struct test_entry *te)
 
2240
{
 
2241
    return create_delaybuf(20, pool, clock_rate, channel_count, 
 
2242
                           samples_per_frame, flags, te);
 
2243
}
 
2244
 
 
2245
/* Delay buffer with -2% drift */
 
2246
static pjmedia_port* delaybuf_n2( pj_pool_t *pool,
 
2247
                                  unsigned clock_rate,
 
2248
                                  unsigned channel_count,
 
2249
                                  unsigned samples_per_frame,
 
2250
                                  unsigned flags,
 
2251
                                  struct test_entry *te)
 
2252
{
 
2253
    return create_delaybuf(-2, pool, clock_rate, channel_count, 
 
2254
                           samples_per_frame, flags, te);
 
2255
}
 
2256
 
 
2257
/* Delay buffer with -5% drift */
 
2258
static pjmedia_port* delaybuf_n5( pj_pool_t *pool,
 
2259
                                  unsigned clock_rate,
 
2260
                                  unsigned channel_count,
 
2261
                                  unsigned samples_per_frame,
 
2262
                                  unsigned flags,
 
2263
                                  struct test_entry *te)
 
2264
{
 
2265
    return create_delaybuf(-5, pool, clock_rate, channel_count, 
 
2266
                           samples_per_frame, flags, te);
 
2267
}
 
2268
 
 
2269
/* Delay buffer with -10% drift */
 
2270
static pjmedia_port* delaybuf_n10(pj_pool_t *pool,
 
2271
                                  unsigned clock_rate,
 
2272
                                  unsigned channel_count,
 
2273
                                  unsigned samples_per_frame,
 
2274
                                  unsigned flags,
 
2275
                                  struct test_entry *te)
 
2276
{
 
2277
    return create_delaybuf(-10, pool, clock_rate, channel_count, 
 
2278
                           samples_per_frame, flags, te);
 
2279
}
 
2280
 
 
2281
/* Delay buffer with -20% drift */
 
2282
static pjmedia_port* delaybuf_n20(pj_pool_t *pool,
 
2283
                                  unsigned clock_rate,
 
2284
                                  unsigned channel_count,
 
2285
                                  unsigned samples_per_frame,
 
2286
                                  unsigned flags,
 
2287
                                  struct test_entry *te)
 
2288
{
 
2289
    return create_delaybuf(-20, pool, clock_rate, channel_count, 
 
2290
                           samples_per_frame, flags, te);
 
2291
}
 
2292
 
 
2293
 
 
2294
/***************************************************************************/
 
2295
/* Run test entry, return elapsed time */
 
2296
static pj_timestamp run_entry(unsigned clock_rate, struct test_entry *e)
 
2297
{
 
2298
    pj_pool_t *pool;
 
2299
    pjmedia_port *port;
 
2300
    pj_timestamp t0, t1;
 
2301
    unsigned j, samples_per_frame;
 
2302
    pj_int16_t pcm[32000 * PTIME / 1000];
 
2303
    pjmedia_port *gen_port;
 
2304
    pj_status_t status;
 
2305
 
 
2306
    samples_per_frame = clock_rate * PTIME / 1000;
 
2307
 
 
2308
    pool = pj_pool_create(mem, "pool", 1024, 1024, NULL);
 
2309
    port = e->init(pool, clock_rate, 1, samples_per_frame, 0, e);
 
2310
    if (port == NULL) {
 
2311
        t0.u64 = 0;
 
2312
        pj_pool_release(pool);
 
2313
        PJ_LOG(1,(THIS_FILE, " init error"));
 
2314
        return t0;
 
2315
    }
 
2316
 
 
2317
    /* Port may decide to use different ptime (e.g. iLBC) */
 
2318
    samples_per_frame = PJMEDIA_PIA_SPF(&port->info);
 
2319
 
 
2320
    gen_port = create_gen_port(pool, clock_rate, 1, 
 
2321
                               samples_per_frame, 100);
 
2322
    if (gen_port == NULL) {
 
2323
        t0.u64 = 0;
 
2324
        pj_pool_release(pool);
 
2325
        return t0;
 
2326
    }
 
2327
 
 
2328
    pj_get_timestamp(&t0);
 
2329
    for (j=0; j<DURATION*clock_rate/samples_per_frame/1000; ++j) {
 
2330
        pjmedia_frame frm;
 
2331
 
 
2332
        if (e->valid_op==OP_GET_PUT) {
 
2333
            frm.buf = (void*)pcm;
 
2334
            frm.size = samples_per_frame * 2;
 
2335
            frm.type = PJMEDIA_FRAME_TYPE_NONE;
 
2336
 
 
2337
            status = pjmedia_port_get_frame(port, &frm);
 
2338
            pj_assert(status == PJ_SUCCESS);
 
2339
 
 
2340
            status = pjmedia_port_put_frame(port, &frm);
 
2341
            pj_assert(status == PJ_SUCCESS);
 
2342
 
 
2343
        } else if (e->valid_op == OP_GET) {
 
2344
            frm.buf = (void*)pcm;
 
2345
            frm.size = samples_per_frame * 2;
 
2346
            frm.type = PJMEDIA_FRAME_TYPE_NONE;
 
2347
 
 
2348
            status = pjmedia_port_get_frame(port, &frm);
 
2349
            pj_assert(status == PJ_SUCCESS);
 
2350
 
 
2351
        } else if (e->valid_op == OP_PUT) {
 
2352
            frm.buf = (void*)pcm;
 
2353
            frm.size = samples_per_frame * 2;
 
2354
            frm.type = PJMEDIA_FRAME_TYPE_NONE;
 
2355
 
 
2356
            status = pjmedia_port_get_frame(gen_port, &frm);
 
2357
            pj_assert(status == PJ_SUCCESS);
 
2358
 
 
2359
            status = pjmedia_port_put_frame(port, &frm);
 
2360
            pj_assert(status == PJ_SUCCESS);
 
2361
 
 
2362
        } else if (e->valid_op == OP_PUT_GET) {
 
2363
            frm.buf = (void*)pcm;
 
2364
            frm.size = samples_per_frame * 2;
 
2365
            frm.type = PJMEDIA_FRAME_TYPE_NONE;
 
2366
 
 
2367
            status = pjmedia_port_get_frame(gen_port, &frm);
 
2368
            pj_assert(status == PJ_SUCCESS);
 
2369
 
 
2370
            status = pjmedia_port_put_frame(port, &frm);
 
2371
            pj_assert(status == PJ_SUCCESS);
 
2372
 
 
2373
            status = pjmedia_port_get_frame(port, &frm);
 
2374
            pj_assert(status == PJ_SUCCESS);
 
2375
        }
 
2376
    }
 
2377
    pj_get_timestamp(&t1);
 
2378
 
 
2379
    pj_sub_timestamp(&t1, &t0);
 
2380
 
 
2381
    if (e->custom_deinit)
 
2382
        e->custom_deinit(e);
 
2383
 
 
2384
    pjmedia_port_destroy(port);
 
2385
    pj_pool_release(pool);
 
2386
 
 
2387
    return t1;
 
2388
}
 
2389
 
 
2390
/***************************************************************************/
 
2391
int mips_test(void)
 
2392
{
 
2393
    struct test_entry entries[] = {
 
2394
        { "get from memplayer", OP_GET, K8|K16, &gen_port_test_init},
 
2395
        { "conference bridge with 1 call", OP_GET_PUT, K8|K16, &conf1_test_init},
 
2396
        { "conference bridge with 2 calls", OP_GET_PUT, K8|K16, &conf2_test_init},
 
2397
        { "conference bridge with 4 calls", OP_GET_PUT, K8|K16, &conf4_test_init},
 
2398
        { "conference bridge with 8 calls", OP_GET_PUT, K8|K16, &conf8_test_init},
 
2399
        { "conference bridge with 16 calls", OP_GET_PUT, K8|K16, &conf16_test_init},
 
2400
        { "upsample+downsample - linear", OP_GET, K8|K16, &linear_resample},
 
2401
        { "upsample+downsample - small filter", OP_GET, K8|K16, &small_filt_resample},
 
2402
        { "upsample+downsample - large filter", OP_GET, K8|K16, &large_filt_resample},
 
2403
        { "WSOLA PLC - 0% loss", OP_GET, K8|K16, &wsola_plc_0},
 
2404
        { "WSOLA PLC - 2% loss", OP_GET, K8|K16, &wsola_plc_2},
 
2405
        { "WSOLA PLC - 5% loss", OP_GET, K8|K16, &wsola_plc_5},
 
2406
        { "WSOLA PLC - 10% loss", OP_GET, K8|K16, &wsola_plc_10},
 
2407
        { "WSOLA PLC - 20% loss", OP_GET, K8|K16, &wsola_plc_20},
 
2408
        { "WSOLA PLC - 50% loss", OP_GET, K8|K16, &wsola_plc_50},
 
2409
        { "WSOLA discard 2% excess", OP_GET, K8|K16, &wsola_discard_2},
 
2410
        { "WSOLA discard 5% excess", OP_GET, K8|K16, &wsola_discard_5},
 
2411
        { "WSOLA discard 10% excess", OP_GET, K8|K16, &wsola_discard_10},
 
2412
        { "WSOLA discard 20% excess", OP_GET, K8|K16, &wsola_discard_20},
 
2413
        { "WSOLA discard 50% excess", OP_GET, K8|K16, &wsola_discard_50},
 
2414
        { "Delay buffer", OP_GET_PUT, K8|K16, &delaybuf_0},
 
2415
        { "Delay buffer - drift -2%", OP_GET_PUT, K8|K16, &delaybuf_n2},
 
2416
        { "Delay buffer - drift -5%", OP_GET_PUT, K8|K16, &delaybuf_n5},
 
2417
        { "Delay buffer - drift -10%", OP_GET_PUT, K8|K16, &delaybuf_n10},
 
2418
        { "Delay buffer - drift -20%", OP_GET_PUT, K8|K16, &delaybuf_n20},
 
2419
        { "Delay buffer - drift +2%", OP_GET_PUT, K8|K16, &delaybuf_p2},
 
2420
        { "Delay buffer - drift +5%", OP_GET_PUT, K8|K16, &delaybuf_p5},
 
2421
        { "Delay buffer - drift +10%", OP_GET_PUT, K8|K16, &delaybuf_p10},
 
2422
        { "Delay buffer - drift +20%", OP_GET_PUT, K8|K16, &delaybuf_p20},
 
2423
        { "echo canceller 100ms tail len", OP_GET_PUT, K8|K16, &ec_create_100},
 
2424
        { "echo canceller 128ms tail len", OP_GET_PUT, K8|K16, &ec_create_128},
 
2425
        { "echo canceller 200ms tail len", OP_GET_PUT, K8|K16, &ec_create_200},
 
2426
        { "echo canceller 256ms tail len", OP_GET_PUT, K8|K16, &ec_create_256},
 
2427
        { "echo canceller 400ms tail len", OP_GET_PUT, K8|K16, &ec_create_400},
 
2428
        { "echo canceller 500ms tail len", OP_GET_PUT, K8|K16, &ec_create_500},
 
2429
        { "echo canceller 512ms tail len", OP_GET_PUT, K8|K16, &ec_create_512},
 
2430
        { "echo canceller 600ms tail len", OP_GET_PUT, K8|K16, &ec_create_600},
 
2431
        { "echo canceller 800ms tail len", OP_GET_PUT, K8|K16, &ec_create_800},
 
2432
        { "echo suppressor 100ms tail len", OP_GET_PUT, K8|K16, &es_create_100},
 
2433
        { "echo suppressor 128ms tail len", OP_GET_PUT, K8|K16, &es_create_128},
 
2434
        { "echo suppressor 200ms tail len", OP_GET_PUT, K8|K16, &es_create_200},
 
2435
        { "echo suppressor 256ms tail len", OP_GET_PUT, K8|K16, &es_create_256},
 
2436
        { "echo suppressor 400ms tail len", OP_GET_PUT, K8|K16, &es_create_400},
 
2437
        { "echo suppressor 500ms tail len", OP_GET_PUT, K8|K16, &es_create_500},
 
2438
        { "echo suppressor 512ms tail len", OP_GET_PUT, K8|K16, &es_create_512},
 
2439
        { "echo suppressor 600ms tail len", OP_GET_PUT, K8|K16, &es_create_600},
 
2440
        { "echo suppressor 800ms tail len", OP_GET_PUT, K8|K16, &es_create_800},
 
2441
        { "tone generator with single freq", OP_GET, K8|K16, &create_tonegen1},
 
2442
        { "tone generator with dual freq", OP_GET, K8|K16, &create_tonegen2},
 
2443
#if PJMEDIA_HAS_G711_CODEC
 
2444
        { "codec encode/decode - G.711", OP_PUT, K8, &g711_encode_decode},
 
2445
#endif
 
2446
#if PJMEDIA_HAS_G722_CODEC
 
2447
        { "codec encode/decode - G.722", OP_PUT, K16, &g722_encode_decode},
 
2448
#endif
 
2449
#if PJMEDIA_HAS_GSM_CODEC
 
2450
        { "codec encode/decode - GSM", OP_PUT, K8, &gsm_encode_decode},
 
2451
#endif
 
2452
#if PJMEDIA_HAS_ILBC_CODEC
 
2453
        { "codec encode/decode - iLBC", OP_PUT, K8, &ilbc_encode_decode},
 
2454
#endif
 
2455
#if PJMEDIA_HAS_SPEEX_CODEC
 
2456
        { "codec encode/decode - Speex 8Khz", OP_PUT, K8, &speex8_encode_decode},
 
2457
        { "codec encode/decode - Speex 16Khz", OP_PUT, K16, &speex16_encode_decode},
 
2458
#endif
 
2459
#if PJMEDIA_HAS_G7221_CODEC
 
2460
        { "codec encode/decode - G.722.1", OP_PUT, K16, &g7221_encode_decode},
 
2461
        { "codec encode/decode - G.722.1c", OP_PUT, K32, &g7221c_encode_decode},
 
2462
#endif
 
2463
#if PJMEDIA_HAS_OPENCORE_AMRNB_CODEC
 
2464
        { "codec encode/decode - AMR-NB", OP_PUT, K8, &amr_encode_decode},
 
2465
#endif
 
2466
#if PJMEDIA_HAS_OPENCORE_AMRWB_CODEC
 
2467
        { "codec encode/decode - AMR-WB", OP_PUT, K16, &amrwb_encode_decode},
 
2468
#endif
 
2469
#if PJMEDIA_HAS_L16_CODEC
 
2470
        { "codec encode/decode - L16/8000/1", OP_PUT, K8, &l16_8_encode_decode},
 
2471
        { "codec encode/decode - L16/16000/1", OP_PUT, K16, &l16_16_encode_decode},
 
2472
#endif
 
2473
#if PJMEDIA_HAS_G711_CODEC
 
2474
        { "stream TX/RX - G.711", OP_PUT_GET, K8, &create_stream_pcmu},
 
2475
        { "stream TX/RX - G.711 SRTP 32bit", OP_PUT_GET, K8, &create_stream_pcmu_srtp32_no_auth},
 
2476
        { "stream TX/RX - G.711 SRTP 32bit +auth", OP_PUT_GET, K8, &create_stream_pcmu_srtp32_with_auth},
 
2477
        { "stream TX/RX - G.711 SRTP 80bit", OP_PUT_GET, K8, &create_stream_pcmu_srtp80_no_auth},
 
2478
        { "stream TX/RX - G.711 SRTP 80bit +auth", OP_PUT_GET, K8, &create_stream_pcmu_srtp80_with_auth},
 
2479
#endif
 
2480
#if PJMEDIA_HAS_G722_CODEC
 
2481
        { "stream TX/RX - G.722", OP_PUT_GET, K16, &create_stream_g722},
 
2482
#endif
 
2483
#if PJMEDIA_HAS_GSM_CODEC
 
2484
        { "stream TX/RX - GSM", OP_PUT_GET, K8, &create_stream_gsm},
 
2485
        { "stream TX/RX - GSM SRTP 32bit", OP_PUT_GET, K8, &create_stream_gsm_srtp32_no_auth},
 
2486
        { "stream TX/RX - GSM SRTP 32bit + auth", OP_PUT_GET, K8, &create_stream_gsm_srtp32_with_auth},
 
2487
        { "stream TX/RX - GSM SRTP 80bit", OP_PUT_GET, K8, &create_stream_gsm_srtp80_no_auth},
 
2488
        { "stream TX/RX - GSM SRTP 80bit + auth", OP_PUT_GET, K8, &create_stream_gsm_srtp80_with_auth},
 
2489
#endif
 
2490
#if PJMEDIA_HAS_G7221_CODEC
 
2491
        { "stream TX/RX - G.722.1", OP_PUT_GET, K16, &create_stream_g7221},
 
2492
        { "stream TX/RX - G.722.1c", OP_PUT_GET, K32, &create_stream_g7221c},
 
2493
#endif
 
2494
#if PJMEDIA_HAS_OPENCORE_AMRNB_CODEC
 
2495
        { "stream TX/RX - AMR-NB", OP_PUT_GET, K8, &create_stream_amr},
 
2496
#endif
 
2497
#if PJMEDIA_HAS_OPENCORE_AMRWB_CODEC
 
2498
        { "stream TX/RX - AMR-WB", OP_PUT_GET, K16, &create_stream_amrwb},
 
2499
#endif
 
2500
    };
 
2501
 
 
2502
    unsigned i, c, k[3] = {K8, K16, K32}, clock_rates[3] = {8000, 16000, 32000};
 
2503
 
 
2504
    PJ_LOG(3,(THIS_FILE, "MIPS test, with CPU=%dMhz, %6.1f MIPS", CPU_MHZ, CPU_IPS / 1000000));
 
2505
    PJ_LOG(3,(THIS_FILE, "Clock  Item                                      Time     CPU    MIPS"));
 
2506
    PJ_LOG(3,(THIS_FILE, " Rate                                           (usec)    (%%)       "));
 
2507
    PJ_LOG(3,(THIS_FILE, "----------------------------------------------------------------------"));
 
2508
 
 
2509
    for (c=0; c<PJ_ARRAY_SIZE(clock_rates); ++c) {
 
2510
        for (i=0; i<PJ_ARRAY_SIZE(entries); ++i) {
 
2511
            enum 
 
2512
            {
 
2513
                RETRY   = 5,    /* number of test retries */
 
2514
            };
 
2515
            struct test_entry *e = &entries[i];
 
2516
            pj_timestamp times[RETRY], tzero;
 
2517
            int usec;
 
2518
            float cpu_pct, mips_val;
 
2519
            unsigned j, clock_rate = clock_rates[c];
 
2520
 
 
2521
            if ((e->valid_clock_rate & k[c]) == 0)
 
2522
                continue;
 
2523
 
 
2524
            /* Run test */
 
2525
            for (j=0; j<RETRY; ++j) {
 
2526
                pj_thread_sleep(1);
 
2527
                times[j] = run_entry(clock_rate, e);
 
2528
            }
 
2529
 
 
2530
            /* Sort ascending */
 
2531
            for (j=0; j<RETRY; ++j) {
 
2532
                unsigned k;
 
2533
                for (k=j+1; k<RETRY; ++k) {
 
2534
                    if (times[k].u64 < times[j].u64) {
 
2535
                        pj_timestamp tmp = times[j];
 
2536
                        times[j] = times[k];
 
2537
                        times[k] = tmp;
 
2538
                    }
 
2539
                }
 
2540
            }
 
2541
 
 
2542
            /* Calculate usec elapsed as average of two best times */
 
2543
            tzero.u32.hi = tzero.u32.lo = 0;
 
2544
            usec = (pj_elapsed_usec(&tzero, &times[0]) + 
 
2545
                    pj_elapsed_usec(&tzero, &times[1])) / 2;
 
2546
 
 
2547
            usec = usec / (DURATION / 1000);
 
2548
 
 
2549
            mips_val = (float)(CPU_IPS * usec / 1000000.0 / 1000000);
 
2550
            cpu_pct = (float)(100.0 * usec / 1000000);
 
2551
            PJ_LOG(3,(THIS_FILE, "%2dKHz %-38s % 8d %8.3f %7.2f", 
 
2552
                      clock_rate/1000, e->title, usec, cpu_pct, mips_val));
 
2553
 
 
2554
        }
 
2555
    }
 
2556
 
 
2557
    return 0;
 
2558
}
 
2559
 
 
2560
 
 
2561