~ubuntu-branches/ubuntu/trusty/sflphone/trusty

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (4.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20140128182336-jrsv0k9u6cawc068
Tags: 1.3.0-1
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* $Id: mips_test.c 3982 2012-03-22 09:56:52Z bennylp $ */
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
 
 
686
 
static pj_status_t codec_put_frame(struct pjmedia_port *this_port,
687
 
                                   pjmedia_frame *frame)
688
 
{
689
 
    struct codec_port *cp = (struct codec_port*)this_port;
690
 
    pjmedia_frame out_frame;
691
 
    pj_status_t status;
692
 
 
693
 
    out_frame.buf = cp->pkt;
694
 
    out_frame.size = sizeof(cp->pkt);
695
 
    status = pjmedia_codec_encode(cp->codec, frame, sizeof(cp->pkt),
696
 
                                  &out_frame);
697
 
    pj_assert(status == PJ_SUCCESS);
698
 
 
699
 
    if (out_frame.size != 0) {
700
 
        pjmedia_frame parsed_frm[2], pcm_frm;
701
 
        unsigned frame_cnt = PJ_ARRAY_SIZE(parsed_frm);
702
 
        unsigned i;
703
 
 
704
 
        status = pjmedia_codec_parse(cp->codec, out_frame.buf,
705
 
                                     out_frame.size, &out_frame.timestamp,
706
 
                                     &frame_cnt, parsed_frm);
707
 
        pj_assert(status == PJ_SUCCESS);
708
 
 
709
 
        for (i=0; i<frame_cnt; ++i) {
710
 
            pcm_frm.buf = cp->pcm;
711
 
            pcm_frm.size = sizeof(cp->pkt);
712
 
            status = pjmedia_codec_decode(cp->codec, &parsed_frm[i],
713
 
                                          sizeof(cp->pcm), &pcm_frm);
714
 
            pj_assert(status == PJ_SUCCESS);
715
 
        }
716
 
    }
717
 
 
718
 
    return PJ_SUCCESS;
719
 
}
720
 
 
721
 
static pj_status_t codec_on_destroy(struct pjmedia_port *this_port)
722
 
{
723
 
    struct codec_port *cp = (struct codec_port*)this_port;
724
 
 
725
 
    pjmedia_codec_close(cp->codec);
726
 
    pjmedia_codec_mgr_dealloc_codec(pjmedia_endpt_get_codec_mgr(cp->endpt),
727
 
                                    cp->codec);
728
 
    cp->codec_deinit();
729
 
    pjmedia_endpt_destroy(cp->endpt);
730
 
    return PJ_SUCCESS;
731
 
}
732
 
 
733
 
static pjmedia_port* codec_encode_decode( pj_pool_t *pool,
734
 
                                          const char *codec,
735
 
                                          pj_status_t (*codec_init)(pjmedia_endpt*),
736
 
                                          pj_status_t (*codec_deinit)(),
737
 
                                          unsigned clock_rate,
738
 
                                          unsigned channel_count,
739
 
                                          unsigned samples_per_frame,
740
 
                                          unsigned flags,
741
 
                                          struct test_entry *te)
742
 
{
743
 
    struct codec_port *cp;
744
 
    pj_str_t codec_id;
745
 
    const pjmedia_codec_info *ci[1];
746
 
    unsigned count;
747
 
    pjmedia_codec_param codec_param;
748
 
    pj_status_t status;
749
 
 
750
 
    PJ_UNUSED_ARG(flags);
751
 
    PJ_UNUSED_ARG(te);
752
 
 
753
 
    codec_id = pj_str((char*)codec);
754
 
    cp = PJ_POOL_ZALLOC_T(pool, struct codec_port);
755
 
    pjmedia_port_info_init(&cp->base.info, &codec_id, 0x123456, clock_rate,
756
 
                           channel_count, 16, samples_per_frame);
757
 
    cp->base.put_frame = &codec_put_frame;
758
 
    cp->base.on_destroy = &codec_on_destroy;
759
 
    cp->codec_deinit = codec_deinit;
760
 
 
761
 
    status = pjmedia_endpt_create(mem, NULL, 0, &cp->endpt);
762
 
    if (status != PJ_SUCCESS)
763
 
        return NULL;
764
 
 
765
 
    status = codec_init(cp->endpt);
766
 
    if (status != PJ_SUCCESS)
767
 
        return NULL;
768
 
 
769
 
    count = 1;
770
 
    status = pjmedia_codec_mgr_find_codecs_by_id(pjmedia_endpt_get_codec_mgr(cp->endpt),
771
 
                                                 &codec_id, &count, ci, NULL);
772
 
    if (status != PJ_SUCCESS)
773
 
        return NULL;
774
 
 
775
 
    status = pjmedia_codec_mgr_alloc_codec(pjmedia_endpt_get_codec_mgr(cp->endpt),
776
 
                                           ci[0], &cp->codec);
777
 
    if (status != PJ_SUCCESS)
778
 
        return NULL;
779
 
 
780
 
    status = pjmedia_codec_mgr_get_default_param(pjmedia_endpt_get_codec_mgr(cp->endpt),
781
 
                                                 ci[0], &codec_param);
782
 
    if (status != PJ_SUCCESS)
783
 
        return NULL;
784
 
 
785
 
    status = pjmedia_codec_init(cp->codec, pool);
786
 
    if (status != PJ_SUCCESS)
787
 
        return NULL;
788
 
 
789
 
    status = pjmedia_codec_open(cp->codec, &codec_param);
790
 
    if (status != PJ_SUCCESS)
791
 
        return NULL;
792
 
 
793
 
    return &cp->base;
794
 
}
795
 
 
796
 
#if PJMEDIA_HAS_G711_CODEC
797
 
/* G.711 benchmark */
798
 
static pjmedia_port* g711_encode_decode(  pj_pool_t *pool,
799
 
                                          unsigned clock_rate,
800
 
                                          unsigned channel_count,
801
 
                                          unsigned samples_per_frame,
802
 
                                          unsigned flags,
803
 
                                          struct test_entry *te)
804
 
{
805
 
    return codec_encode_decode(pool, "pcmu", &pjmedia_codec_g711_init,
806
 
                               &pjmedia_codec_g711_deinit,
807
 
                               clock_rate, channel_count,
808
 
                               samples_per_frame, flags, te);
809
 
}
810
 
#endif
811
 
 
812
 
/* GSM benchmark */
813
 
#if PJMEDIA_HAS_GSM_CODEC
814
 
static pjmedia_port* gsm_encode_decode(  pj_pool_t *pool,
815
 
                                         unsigned clock_rate,
816
 
                                         unsigned channel_count,
817
 
                                         unsigned samples_per_frame,
818
 
                                         unsigned flags,
819
 
                                         struct test_entry *te)
820
 
{
821
 
    return codec_encode_decode(pool, "gsm", &pjmedia_codec_gsm_init,
822
 
                               &pjmedia_codec_gsm_deinit,
823
 
                               clock_rate, channel_count,
824
 
                               samples_per_frame, flags, te);
825
 
}
826
 
#endif
827
 
 
828
 
#if PJMEDIA_HAS_ILBC_CODEC
829
 
static pj_status_t ilbc_init(pjmedia_endpt *endpt)
830
 
{
831
 
    return pjmedia_codec_ilbc_init(endpt, 20);
832
 
}
833
 
 
834
 
/* iLBC benchmark */
835
 
static pjmedia_port* ilbc_encode_decode( pj_pool_t *pool,
836
 
                                         unsigned clock_rate,
837
 
                                         unsigned channel_count,
838
 
                                         unsigned samples_per_frame,
839
 
                                         unsigned flags,
840
 
                                         struct test_entry *te)
841
 
{
842
 
    samples_per_frame = 30 * clock_rate / 1000;
843
 
    return codec_encode_decode(pool, "ilbc", &ilbc_init,
844
 
                               &pjmedia_codec_ilbc_deinit, clock_rate,
845
 
                               channel_count, samples_per_frame, flags, te);
846
 
}
847
 
#endif
848
 
 
849
 
#if PJMEDIA_HAS_SPEEX_CODEC
850
 
/* Speex narrowband benchmark */
851
 
static pjmedia_port* speex8_encode_decode(pj_pool_t *pool,
852
 
                                          unsigned clock_rate,
853
 
                                          unsigned channel_count,
854
 
                                          unsigned samples_per_frame,
855
 
                                          unsigned flags,
856
 
                                          struct test_entry *te)
857
 
{
858
 
    return codec_encode_decode(pool, "speex/8000",
859
 
                               &pjmedia_codec_speex_init_default,
860
 
                               &pjmedia_codec_speex_deinit,
861
 
                               clock_rate, channel_count,
862
 
                               samples_per_frame, flags, te);
863
 
}
864
 
 
865
 
/* Speex wideband benchmark */
866
 
static pjmedia_port* speex16_encode_decode(pj_pool_t *pool,
867
 
                                           unsigned clock_rate,
868
 
                                           unsigned channel_count,
869
 
                                           unsigned samples_per_frame,
870
 
                                           unsigned flags,
871
 
                                           struct test_entry *te)
872
 
{
873
 
    return codec_encode_decode(pool, "speex/16000",
874
 
                               &pjmedia_codec_speex_init_default,
875
 
                               &pjmedia_codec_speex_deinit,
876
 
                               clock_rate, channel_count,
877
 
                               samples_per_frame, flags, te);
878
 
}
879
 
#endif
880
 
 
881
 
#if PJMEDIA_HAS_G722_CODEC
882
 
/* G.722 benchmark benchmark */
883
 
static pjmedia_port* g722_encode_decode(pj_pool_t *pool,
884
 
                                        unsigned clock_rate,
885
 
                                        unsigned channel_count,
886
 
                                        unsigned samples_per_frame,
887
 
                                        unsigned flags,
888
 
                                        struct test_entry *te)
889
 
{
890
 
    return codec_encode_decode(pool, "g722", &pjmedia_codec_g722_init,
891
 
                               &pjmedia_codec_g722_deinit,
892
 
                               clock_rate, channel_count,
893
 
                               samples_per_frame, flags, te);
894
 
}
895
 
#endif
896
 
 
897
 
#if PJMEDIA_HAS_G7221_CODEC
898
 
/* G.722.1 benchmark benchmark */
899
 
static pjmedia_port* g7221_encode_decode(pj_pool_t *pool,
900
 
                                         unsigned clock_rate,
901
 
                                         unsigned channel_count,
902
 
                                         unsigned samples_per_frame,
903
 
                                         unsigned flags,
904
 
                                         struct test_entry *te)
905
 
{
906
 
    return codec_encode_decode(pool, "g7221/16000",
907
 
                               &pjmedia_codec_g7221_init,
908
 
                               &pjmedia_codec_g7221_deinit,
909
 
                               clock_rate, channel_count,
910
 
                               samples_per_frame, flags, te);
911
 
}
912
 
 
913
 
/* G.722.1 Annex C benchmark benchmark */
914
 
static pjmedia_port* g7221c_encode_decode(pj_pool_t *pool,
915
 
                                          unsigned clock_rate,
916
 
                                          unsigned channel_count,
917
 
                                          unsigned samples_per_frame,
918
 
                                          unsigned flags,
919
 
                                          struct test_entry *te)
920
 
{
921
 
    return codec_encode_decode(pool, "g7221/32000",
922
 
                               &pjmedia_codec_g7221_init,
923
 
                               &pjmedia_codec_g7221_deinit,
924
 
                               clock_rate, channel_count,
925
 
                               samples_per_frame, flags, te);
926
 
}
927
 
#endif  /* PJMEDIA_HAS_G7221_CODEC */
928
 
 
929
 
#if PJMEDIA_HAS_OPENCORE_AMRNB_CODEC
930
 
/* AMR-NB benchmark benchmark */
931
 
static pjmedia_port* amr_encode_decode(pj_pool_t *pool,
932
 
                                       unsigned clock_rate,
933
 
                                       unsigned channel_count,
934
 
                                       unsigned samples_per_frame,
935
 
                                       unsigned flags,
936
 
                                       struct test_entry *te)
937
 
{
938
 
    return codec_encode_decode(pool, "AMR/8000",
939
 
                               &pjmedia_codec_opencore_amrnb_init,
940
 
                               &pjmedia_codec_opencore_amrnb_deinit,
941
 
                               clock_rate, channel_count,
942
 
                               samples_per_frame, flags, te);
943
 
}
944
 
#endif  /* PJMEDIA_HAS_OPENCORE_AMRNB_CODEC */
945
 
 
946
 
#if defined(PJMEDIA_HAS_L16_CODEC) && PJMEDIA_HAS_L16_CODEC!=0
947
 
static pj_status_t init_l16_default(pjmedia_endpt *endpt)
948
 
{
949
 
    return pjmedia_codec_l16_init(endpt, 0);
950
 
}
951
 
 
952
 
/* L16/8000/1 benchmark */
953
 
static pjmedia_port* l16_8_encode_decode(pj_pool_t *pool,
954
 
                                         unsigned clock_rate,
955
 
                                         unsigned channel_count,
956
 
                                         unsigned samples_per_frame,
957
 
                                         unsigned flags,
958
 
                                         struct test_entry *te)
959
 
{
960
 
    return codec_encode_decode(pool, "L16/8000/1", &init_l16_default,
961
 
                               &pjmedia_codec_l16_deinit,
962
 
                               clock_rate, channel_count,
963
 
                               samples_per_frame, flags, te);
964
 
}
965
 
 
966
 
/* L16/16000/1 benchmark */
967
 
static pjmedia_port* l16_16_encode_decode(pj_pool_t *pool,
968
 
                                          unsigned clock_rate,
969
 
                                          unsigned channel_count,
970
 
                                          unsigned samples_per_frame,
971
 
                                          unsigned flags,
972
 
                                          struct test_entry *te)
973
 
{
974
 
    return codec_encode_decode(pool, "L16/16000/1", &init_l16_default,
975
 
                               &pjmedia_codec_l16_deinit,
976
 
                               clock_rate, channel_count,
977
 
                               samples_per_frame, flags, te);
978
 
}
979
 
#endif
980
 
 
981
 
/***************************************************************************/
982
 
/* WSOLA PLC mode */
983
 
 
984
 
struct wsola_plc_port
985
 
{
986
 
    pjmedia_port     base;
987
 
    pjmedia_wsola   *wsola;
988
 
    pjmedia_port    *gen_port;
989
 
    int              loss_pct;
990
 
    pj_bool_t        prev_lost;
991
 
};
992
 
 
993
 
 
994
 
static pj_status_t wsola_plc_get_frame(struct pjmedia_port *this_port,
995
 
                                       pjmedia_frame *frame)
996
 
{
997
 
    struct wsola_plc_port *wp = (struct wsola_plc_port*)this_port;
998
 
    pj_status_t status;
999
 
 
1000
 
 
1001
 
    if ((pj_rand() % 100) > wp->loss_pct) {
1002
 
        status = pjmedia_port_get_frame(wp->gen_port, frame);
1003
 
        pj_assert(status == PJ_SUCCESS);
1004
 
 
1005
 
        status = pjmedia_wsola_save(wp->wsola, (short*)frame->buf,
1006
 
                                    wp->prev_lost);
1007
 
        pj_assert(status == PJ_SUCCESS);
1008
 
 
1009
 
        wp->prev_lost = PJ_FALSE;
1010
 
    } else {
1011
 
        status = pjmedia_wsola_generate(wp->wsola, (short*)frame->buf);
1012
 
        wp->prev_lost = PJ_TRUE;
1013
 
    }
1014
 
 
1015
 
    return PJ_SUCCESS;
1016
 
}
1017
 
 
1018
 
static pj_status_t wsola_plc_on_destroy(struct pjmedia_port *this_port)
1019
 
{
1020
 
    struct wsola_plc_port *wp = (struct wsola_plc_port*)this_port;
1021
 
    pjmedia_port_destroy(wp->gen_port);
1022
 
    pjmedia_wsola_destroy(wp->wsola);
1023
 
    return PJ_SUCCESS;
1024
 
}
1025
 
 
1026
 
static pjmedia_port* create_wsola_plc(unsigned loss_pct,
1027
 
                                      pj_pool_t *pool,
1028
 
                                      unsigned clock_rate,
1029
 
                                      unsigned channel_count,
1030
 
                                      unsigned samples_per_frame,
1031
 
                                      unsigned flags,
1032
 
                                      struct test_entry *te)
1033
 
{
1034
 
    struct wsola_plc_port *wp;
1035
 
    pj_str_t name = pj_str("wsola");
1036
 
    unsigned opt = 0;
1037
 
    pj_status_t status;
1038
 
 
1039
 
    PJ_UNUSED_ARG(flags);
1040
 
    PJ_UNUSED_ARG(te);
1041
 
 
1042
 
    wp = PJ_POOL_ZALLOC_T(pool, struct wsola_plc_port);
1043
 
    wp->loss_pct = loss_pct;
1044
 
    wp->base.get_frame = &wsola_plc_get_frame;
1045
 
    wp->base.on_destroy = &wsola_plc_on_destroy;
1046
 
    pjmedia_port_info_init(&wp->base.info, &name, 0x4123, clock_rate,
1047
 
                           channel_count, 16, samples_per_frame);
1048
 
 
1049
 
    if (loss_pct == 0)
1050
 
        opt |= PJMEDIA_WSOLA_NO_PLC;
1051
 
 
1052
 
    status = pjmedia_wsola_create(pool, clock_rate, samples_per_frame,
1053
 
                                  channel_count, 0, &wp->wsola);
1054
 
    if (status != PJ_SUCCESS)
1055
 
        return NULL;
1056
 
 
1057
 
    wp->gen_port = create_gen_port(pool, clock_rate, channel_count,
1058
 
                                   samples_per_frame, 100);
1059
 
    if (wp->gen_port == NULL)
1060
 
        return NULL;
1061
 
 
1062
 
    return &wp->base;
1063
 
}
1064
 
 
1065
 
 
1066
 
/* WSOLA PLC with 0% packet loss */
1067
 
static pjmedia_port* wsola_plc_0( pj_pool_t *pool,
1068
 
                                  unsigned clock_rate,
1069
 
                                  unsigned channel_count,
1070
 
                                  unsigned samples_per_frame,
1071
 
                                  unsigned flags,
1072
 
                                  struct test_entry *te)
1073
 
{
1074
 
    return create_wsola_plc(0, pool, clock_rate, channel_count,
1075
 
                            samples_per_frame, flags, te);
1076
 
}
1077
 
 
1078
 
 
1079
 
/* WSOLA PLC with 2% packet loss */
1080
 
static pjmedia_port* wsola_plc_2( pj_pool_t *pool,
1081
 
                                  unsigned clock_rate,
1082
 
                                  unsigned channel_count,
1083
 
                                  unsigned samples_per_frame,
1084
 
                                  unsigned flags,
1085
 
                                  struct test_entry *te)
1086
 
{
1087
 
    return create_wsola_plc(2, pool, clock_rate, channel_count,
1088
 
                            samples_per_frame, flags, te);
1089
 
}
1090
 
 
1091
 
/* WSOLA PLC with 5% packet loss */
1092
 
static pjmedia_port* wsola_plc_5( pj_pool_t *pool,
1093
 
                                  unsigned clock_rate,
1094
 
                                  unsigned channel_count,
1095
 
                                  unsigned samples_per_frame,
1096
 
                                  unsigned flags,
1097
 
                                  struct test_entry *te)
1098
 
{
1099
 
    return create_wsola_plc(5, pool, clock_rate, channel_count,
1100
 
                            samples_per_frame, flags, te);
1101
 
}
1102
 
 
1103
 
/* WSOLA PLC with 10% packet loss */
1104
 
static pjmedia_port* wsola_plc_10(pj_pool_t *pool,
1105
 
                                  unsigned clock_rate,
1106
 
                                  unsigned channel_count,
1107
 
                                  unsigned samples_per_frame,
1108
 
                                  unsigned flags,
1109
 
                                  struct test_entry *te)
1110
 
{
1111
 
    return create_wsola_plc(10, pool, clock_rate, channel_count,
1112
 
                            samples_per_frame, flags, te);
1113
 
}
1114
 
 
1115
 
/* WSOLA PLC with 20% packet loss */
1116
 
static pjmedia_port* wsola_plc_20(pj_pool_t *pool,
1117
 
                                  unsigned clock_rate,
1118
 
                                  unsigned channel_count,
1119
 
                                  unsigned samples_per_frame,
1120
 
                                  unsigned flags,
1121
 
                                  struct test_entry *te)
1122
 
{
1123
 
    return create_wsola_plc(20, pool, clock_rate, channel_count,
1124
 
                            samples_per_frame, flags, te);
1125
 
}
1126
 
 
1127
 
/* WSOLA PLC with 50% packet loss */
1128
 
static pjmedia_port* wsola_plc_50(pj_pool_t *pool,
1129
 
                                  unsigned clock_rate,
1130
 
                                  unsigned channel_count,
1131
 
                                  unsigned samples_per_frame,
1132
 
                                  unsigned flags,
1133
 
                                  struct test_entry *te)
1134
 
{
1135
 
    return create_wsola_plc(50, pool, clock_rate, channel_count,
1136
 
                            samples_per_frame, flags, te);
1137
 
}
1138
 
 
1139
 
 
1140
 
 
1141
 
/***************************************************************************/
1142
 
/* WSOLA discard mode */
1143
 
enum { CIRC_BUF_FRAME_CNT = 4 };
1144
 
struct wsola_discard_port
1145
 
{
1146
 
    pjmedia_port         base;
1147
 
    pjmedia_port        *gen_port;
1148
 
    pjmedia_wsola       *wsola;
1149
 
    pjmedia_circ_buf    *circbuf;
1150
 
    unsigned             discard_pct;
1151
 
};
1152
 
 
1153
 
 
1154
 
static pj_status_t wsola_discard_get_frame(struct pjmedia_port *this_port,
1155
 
                                           pjmedia_frame *frame)
1156
 
{
1157
 
    struct wsola_discard_port *wp = (struct wsola_discard_port*)this_port;
1158
 
    pj_status_t status;
1159
 
 
1160
 
    while (pjmedia_circ_buf_get_len(wp->circbuf) <
1161
 
                PJMEDIA_PIA_SPF(&wp->base.info) * (CIRC_BUF_FRAME_CNT-1))
1162
 
    {
1163
 
        status = pjmedia_port_get_frame(wp->gen_port, frame);
1164
 
        pj_assert(status==PJ_SUCCESS);
1165
 
 
1166
 
        status = pjmedia_circ_buf_write(wp->circbuf, (short*)frame->buf,
1167
 
                                        PJMEDIA_PIA_SPF(&wp->base.info));
1168
 
        pj_assert(status==PJ_SUCCESS);
1169
 
    }
1170
 
 
1171
 
    if ((pj_rand() % 100) < (int)wp->discard_pct) {
1172
 
        pj_int16_t *reg1, *reg2;
1173
 
        unsigned reg1_len, reg2_len;
1174
 
        unsigned del_cnt;
1175
 
 
1176
 
        pjmedia_circ_buf_get_read_regions(wp->circbuf, &reg1, &reg1_len,
1177
 
                                          &reg2, &reg2_len);
1178
 
 
1179
 
        del_cnt = PJMEDIA_PIA_SPF(&wp->base.info);
1180
 
        status = pjmedia_wsola_discard(wp->wsola, reg1, reg1_len, reg2,
1181
 
                                       reg2_len, &del_cnt);
1182
 
        pj_assert(status==PJ_SUCCESS);
1183
 
 
1184
 
        status = pjmedia_circ_buf_adv_read_ptr(wp->circbuf, del_cnt);
1185
 
        pj_assert(status==PJ_SUCCESS);
1186
 
    }
1187
 
 
1188
 
    return PJ_SUCCESS;
1189
 
}
1190
 
 
1191
 
static pj_status_t wsola_discard_on_destroy(struct pjmedia_port *this_port)
1192
 
{
1193
 
    struct wsola_discard_port *wp = (struct wsola_discard_port*)this_port;
1194
 
    pjmedia_port_destroy(wp->gen_port);
1195
 
    pjmedia_wsola_destroy(wp->wsola);
1196
 
    return PJ_SUCCESS;
1197
 
}
1198
 
 
1199
 
 
1200
 
static pjmedia_port* create_wsola_discard(unsigned discard_pct,
1201
 
                                          pj_pool_t *pool,
1202
 
                                          unsigned clock_rate,
1203
 
                                          unsigned channel_count,
1204
 
                                          unsigned samples_per_frame,
1205
 
                                          unsigned flags,
1206
 
                                          struct test_entry *te)
1207
 
{
1208
 
    struct wsola_discard_port *wp;
1209
 
    pj_str_t name = pj_str("wsola");
1210
 
    unsigned i, opt = 0;
1211
 
    pj_status_t status;
1212
 
 
1213
 
    PJ_UNUSED_ARG(flags);
1214
 
    PJ_UNUSED_ARG(te);
1215
 
 
1216
 
    wp = PJ_POOL_ZALLOC_T(pool, struct wsola_discard_port);
1217
 
    wp->discard_pct = discard_pct;
1218
 
    wp->base.get_frame = &wsola_discard_get_frame;
1219
 
    wp->base.on_destroy = &wsola_discard_on_destroy;
1220
 
    pjmedia_port_info_init(&wp->base.info, &name, 0x4123, clock_rate,
1221
 
                           channel_count, 16, samples_per_frame);
1222
 
 
1223
 
    if (discard_pct == 0)
1224
 
        opt |= PJMEDIA_WSOLA_NO_DISCARD;
1225
 
 
1226
 
    status = pjmedia_wsola_create(pool, clock_rate, samples_per_frame,
1227
 
                                  channel_count, 0, &wp->wsola);
1228
 
    if (status != PJ_SUCCESS)
1229
 
        return NULL;
1230
 
 
1231
 
    wp->gen_port = create_gen_port(pool, clock_rate, channel_count,
1232
 
                                   samples_per_frame, 100);
1233
 
    if (wp->gen_port == NULL)
1234
 
        return NULL;
1235
 
 
1236
 
    status = pjmedia_circ_buf_create(pool, samples_per_frame * CIRC_BUF_FRAME_CNT,
1237
 
                                     &wp->circbuf);
1238
 
    if (status != PJ_SUCCESS)
1239
 
        return NULL;
1240
 
 
1241
 
    /* fill up the circbuf */
1242
 
    for (i=0; i<CIRC_BUF_FRAME_CNT; ++i) {
1243
 
        short pcm[320];
1244
 
        pjmedia_frame frm;
1245
 
 
1246
 
        pj_assert(PJ_ARRAY_SIZE(pcm) >= samples_per_frame);
1247
 
        frm.buf = pcm;
1248
 
        frm.size = samples_per_frame * 2;
1249
 
 
1250
 
        status = pjmedia_port_get_frame(wp->gen_port, &frm);
1251
 
        pj_assert(status==PJ_SUCCESS);
1252
 
 
1253
 
        status = pjmedia_circ_buf_write(wp->circbuf, pcm, samples_per_frame);
1254
 
        pj_assert(status==PJ_SUCCESS);
1255
 
    }
1256
 
 
1257
 
    return &wp->base;
1258
 
}
1259
 
 
1260
 
 
1261
 
/* WSOLA with 2% discard rate */
1262
 
static pjmedia_port* wsola_discard_2( pj_pool_t *pool,
1263
 
                                      unsigned clock_rate,
1264
 
                                      unsigned channel_count,
1265
 
                                      unsigned samples_per_frame,
1266
 
                                      unsigned flags,
1267
 
                                      struct test_entry *te)
1268
 
{
1269
 
    return create_wsola_discard(2, pool, clock_rate, channel_count,
1270
 
                                samples_per_frame, flags, te);
1271
 
}
1272
 
 
1273
 
/* WSOLA with 5% discard rate */
1274
 
static pjmedia_port* wsola_discard_5( pj_pool_t *pool,
1275
 
                                      unsigned clock_rate,
1276
 
                                      unsigned channel_count,
1277
 
                                      unsigned samples_per_frame,
1278
 
                                      unsigned flags,
1279
 
                                      struct test_entry *te)
1280
 
{
1281
 
    return create_wsola_discard(5, pool, clock_rate, channel_count,
1282
 
                                samples_per_frame, flags, te);
1283
 
}
1284
 
 
1285
 
/* WSOLA with 10% discard rate */
1286
 
static pjmedia_port* wsola_discard_10(pj_pool_t *pool,
1287
 
                                      unsigned clock_rate,
1288
 
                                      unsigned channel_count,
1289
 
                                      unsigned samples_per_frame,
1290
 
                                      unsigned flags,
1291
 
                                      struct test_entry *te)
1292
 
{
1293
 
    return create_wsola_discard(10, pool, clock_rate, channel_count,
1294
 
                                samples_per_frame, flags, te);
1295
 
}
1296
 
 
1297
 
/* WSOLA with 20% discard rate */
1298
 
static pjmedia_port* wsola_discard_20(pj_pool_t *pool,
1299
 
                                      unsigned clock_rate,
1300
 
                                      unsigned channel_count,
1301
 
                                      unsigned samples_per_frame,
1302
 
                                      unsigned flags,
1303
 
                                      struct test_entry *te)
1304
 
{
1305
 
    return create_wsola_discard(20, pool, clock_rate, channel_count,
1306
 
                                samples_per_frame, flags, te);
1307
 
}
1308
 
 
1309
 
/* WSOLA with 50% discard rate */
1310
 
static pjmedia_port* wsola_discard_50(pj_pool_t *pool,
1311
 
                                      unsigned clock_rate,
1312
 
                                      unsigned channel_count,
1313
 
                                      unsigned samples_per_frame,
1314
 
                                      unsigned flags,
1315
 
                                      struct test_entry *te)
1316
 
{
1317
 
    return create_wsola_discard(50, pool, clock_rate, channel_count,
1318
 
                                samples_per_frame, flags, te);
1319
 
}
1320
 
 
1321
 
 
1322
 
 
1323
 
/***************************************************************************/
1324
 
 
1325
 
static pjmedia_port* ec_create(unsigned ec_tail_msec,
1326
 
                               pj_pool_t *pool,
1327
 
                               unsigned clock_rate,
1328
 
                               unsigned channel_count,
1329
 
                               unsigned samples_per_frame,
1330
 
                               unsigned flags,
1331
 
                               struct test_entry *te)
1332
 
{
1333
 
    pjmedia_port *gen_port, *ec_port;
1334
 
    pj_status_t status;
1335
 
 
1336
 
    PJ_UNUSED_ARG(te);
1337
 
 
1338
 
    gen_port = create_gen_port(pool, clock_rate, channel_count,
1339
 
                               samples_per_frame, 100);
1340
 
    if (gen_port == NULL)
1341
 
        return NULL;
1342
 
 
1343
 
    status = pjmedia_echo_port_create(pool, gen_port, ec_tail_msec, 0,
1344
 
                                      flags, &ec_port);
1345
 
    if (status != PJ_SUCCESS)
1346
 
        return NULL;
1347
 
 
1348
 
    return ec_port;
1349
 
}
1350
 
 
1351
 
/* EC with 100ms tail length */
1352
 
static pjmedia_port* ec_create_100(pj_pool_t *pool,
1353
 
                                   unsigned clock_rate,
1354
 
                                   unsigned channel_count,
1355
 
                                   unsigned samples_per_frame,
1356
 
                                   unsigned flags,
1357
 
                                   struct test_entry *te)
1358
 
{
1359
 
    flags = 0;
1360
 
    return ec_create(100, pool, clock_rate, channel_count, samples_per_frame,
1361
 
                     flags, te);
1362
 
}
1363
 
 
1364
 
/* EC with 128ms tail length */
1365
 
static pjmedia_port* ec_create_128(pj_pool_t *pool,
1366
 
                                   unsigned clock_rate,
1367
 
                                   unsigned channel_count,
1368
 
                                   unsigned samples_per_frame,
1369
 
                                   unsigned flags,
1370
 
                                   struct test_entry *te)
1371
 
{
1372
 
    flags = 0;
1373
 
    return ec_create(128, pool, clock_rate, channel_count, samples_per_frame,
1374
 
                     flags, te);
1375
 
}
1376
 
 
1377
 
/* EC with 200ms tail length */
1378
 
static pjmedia_port* ec_create_200(pj_pool_t *pool,
1379
 
                                   unsigned clock_rate,
1380
 
                                   unsigned channel_count,
1381
 
                                   unsigned samples_per_frame,
1382
 
                                   unsigned flags,
1383
 
                                   struct test_entry *te)
1384
 
{
1385
 
    flags = 0;
1386
 
    return ec_create(200, pool, clock_rate, channel_count, samples_per_frame,
1387
 
                     flags, te);
1388
 
}
1389
 
 
1390
 
/* EC with 256ms tail length */
1391
 
static pjmedia_port* ec_create_256(pj_pool_t *pool,
1392
 
                                   unsigned clock_rate,
1393
 
                                   unsigned channel_count,
1394
 
                                   unsigned samples_per_frame,
1395
 
                                   unsigned flags,
1396
 
                                   struct test_entry *te)
1397
 
{
1398
 
    flags = 0;
1399
 
    return ec_create(256, pool, clock_rate, channel_count, samples_per_frame,
1400
 
                     flags, te);
1401
 
}
1402
 
 
1403
 
 
1404
 
/* EC with 400ms tail length */
1405
 
static pjmedia_port* ec_create_400(pj_pool_t *pool,
1406
 
                                   unsigned clock_rate,
1407
 
                                   unsigned channel_count,
1408
 
                                   unsigned samples_per_frame,
1409
 
                                   unsigned flags,
1410
 
                                   struct test_entry *te)
1411
 
{
1412
 
    flags = 0;
1413
 
    return ec_create(400, pool, clock_rate, channel_count, samples_per_frame,
1414
 
                     flags, te);
1415
 
}
1416
 
 
1417
 
/* EC with 500ms tail length */
1418
 
static pjmedia_port* ec_create_500(pj_pool_t *pool,
1419
 
                                   unsigned clock_rate,
1420
 
                                   unsigned channel_count,
1421
 
                                   unsigned samples_per_frame,
1422
 
                                   unsigned flags,
1423
 
                                   struct test_entry *te)
1424
 
{
1425
 
    flags = 0;
1426
 
    return ec_create(500, pool, clock_rate, channel_count, samples_per_frame,
1427
 
                     flags, te);
1428
 
}
1429
 
 
1430
 
/* EC with 512ms tail length */
1431
 
static pjmedia_port* ec_create_512(pj_pool_t *pool,
1432
 
                                   unsigned clock_rate,
1433
 
                                   unsigned channel_count,
1434
 
                                   unsigned samples_per_frame,
1435
 
                                   unsigned flags,
1436
 
                                   struct test_entry *te)
1437
 
{
1438
 
    flags = 0;
1439
 
    return ec_create(512, pool, clock_rate, channel_count, samples_per_frame,
1440
 
                     flags, te);
1441
 
}
1442
 
 
1443
 
/* EC with 600ms tail length */
1444
 
static pjmedia_port* ec_create_600(pj_pool_t *pool,
1445
 
                                   unsigned clock_rate,
1446
 
                                   unsigned channel_count,
1447
 
                                   unsigned samples_per_frame,
1448
 
                                   unsigned flags,
1449
 
                                   struct test_entry *te)
1450
 
{
1451
 
    flags = 0;
1452
 
    return ec_create(600, pool, clock_rate, channel_count, samples_per_frame,
1453
 
                     flags, te);
1454
 
}
1455
 
 
1456
 
/* EC with 800ms tail length */
1457
 
static pjmedia_port* ec_create_800(pj_pool_t *pool,
1458
 
                                   unsigned clock_rate,
1459
 
                                   unsigned channel_count,
1460
 
                                   unsigned samples_per_frame,
1461
 
                                   unsigned flags,
1462
 
                                   struct test_entry *te)
1463
 
{
1464
 
    flags = 0;
1465
 
    return ec_create(800, pool, clock_rate, channel_count, samples_per_frame,
1466
 
                     flags, te);
1467
 
}
1468
 
 
1469
 
 
1470
 
 
1471
 
/* Echo suppressor with 100ms tail length */
1472
 
static pjmedia_port* es_create_100(pj_pool_t *pool,
1473
 
                                   unsigned clock_rate,
1474
 
                                   unsigned channel_count,
1475
 
                                   unsigned samples_per_frame,
1476
 
                                   unsigned flags,
1477
 
                                   struct test_entry *te)
1478
 
{
1479
 
    flags = PJMEDIA_ECHO_SIMPLE;
1480
 
    return ec_create(100, pool, clock_rate, channel_count, samples_per_frame,
1481
 
                     flags, te);
1482
 
}
1483
 
 
1484
 
/* Echo suppressor with 128ms tail length */
1485
 
static pjmedia_port* es_create_128(pj_pool_t *pool,
1486
 
                                   unsigned clock_rate,
1487
 
                                   unsigned channel_count,
1488
 
                                   unsigned samples_per_frame,
1489
 
                                   unsigned flags,
1490
 
                                   struct test_entry *te)
1491
 
{
1492
 
    flags = PJMEDIA_ECHO_SIMPLE;
1493
 
    return ec_create(128, pool, clock_rate, channel_count, samples_per_frame,
1494
 
                     flags, te);
1495
 
}
1496
 
 
1497
 
/* Echo suppressor with 200ms tail length */
1498
 
static pjmedia_port* es_create_200(pj_pool_t *pool,
1499
 
                                   unsigned clock_rate,
1500
 
                                   unsigned channel_count,
1501
 
                                   unsigned samples_per_frame,
1502
 
                                   unsigned flags,
1503
 
                                   struct test_entry *te)
1504
 
{
1505
 
    flags = PJMEDIA_ECHO_SIMPLE;
1506
 
    return ec_create(200, pool, clock_rate, channel_count, samples_per_frame,
1507
 
                     flags, te);
1508
 
}
1509
 
 
1510
 
/* Echo suppressor with 256ms tail length */
1511
 
static pjmedia_port* es_create_256(pj_pool_t *pool,
1512
 
                                   unsigned clock_rate,
1513
 
                                   unsigned channel_count,
1514
 
                                   unsigned samples_per_frame,
1515
 
                                   unsigned flags,
1516
 
                                   struct test_entry *te)
1517
 
{
1518
 
    flags = PJMEDIA_ECHO_SIMPLE;
1519
 
    return ec_create(256, pool, clock_rate, channel_count, samples_per_frame,
1520
 
                     flags, te);
1521
 
}
1522
 
 
1523
 
 
1524
 
/* Echo suppressor with 400ms tail length */
1525
 
static pjmedia_port* es_create_400(pj_pool_t *pool,
1526
 
                                   unsigned clock_rate,
1527
 
                                   unsigned channel_count,
1528
 
                                   unsigned samples_per_frame,
1529
 
                                   unsigned flags,
1530
 
                                   struct test_entry *te)
1531
 
{
1532
 
    flags = PJMEDIA_ECHO_SIMPLE;
1533
 
    return ec_create(400, pool, clock_rate, channel_count, samples_per_frame,
1534
 
                     flags, te);
1535
 
}
1536
 
 
1537
 
/* Echo suppressor with 500ms tail length */
1538
 
static pjmedia_port* es_create_500(pj_pool_t *pool,
1539
 
                                   unsigned clock_rate,
1540
 
                                   unsigned channel_count,
1541
 
                                   unsigned samples_per_frame,
1542
 
                                   unsigned flags,
1543
 
                                   struct test_entry *te)
1544
 
{
1545
 
    flags = PJMEDIA_ECHO_SIMPLE;
1546
 
    return ec_create(500, pool, clock_rate, channel_count, samples_per_frame,
1547
 
                     flags, te);
1548
 
}
1549
 
 
1550
 
/* Echo suppressor with 512ms tail length */
1551
 
static pjmedia_port* es_create_512(pj_pool_t *pool,
1552
 
                                   unsigned clock_rate,
1553
 
                                   unsigned channel_count,
1554
 
                                   unsigned samples_per_frame,
1555
 
                                   unsigned flags,
1556
 
                                   struct test_entry *te)
1557
 
{
1558
 
    flags = PJMEDIA_ECHO_SIMPLE;
1559
 
    return ec_create(512, pool, clock_rate, channel_count, samples_per_frame,
1560
 
                     flags, te);
1561
 
}
1562
 
 
1563
 
/* Echo suppressor with 600ms tail length */
1564
 
static pjmedia_port* es_create_600(pj_pool_t *pool,
1565
 
                                   unsigned clock_rate,
1566
 
                                   unsigned channel_count,
1567
 
                                   unsigned samples_per_frame,
1568
 
                                   unsigned flags,
1569
 
                                   struct test_entry *te)
1570
 
{
1571
 
    flags = PJMEDIA_ECHO_SIMPLE;
1572
 
    return ec_create(600, pool, clock_rate, channel_count, samples_per_frame,
1573
 
                     flags, te);
1574
 
}
1575
 
 
1576
 
/* Echo suppressor with 800ms tail length */
1577
 
static pjmedia_port* es_create_800(pj_pool_t *pool,
1578
 
                                   unsigned clock_rate,
1579
 
                                   unsigned channel_count,
1580
 
                                   unsigned samples_per_frame,
1581
 
                                   unsigned flags,
1582
 
                                   struct test_entry *te)
1583
 
{
1584
 
    flags = PJMEDIA_ECHO_SIMPLE;
1585
 
    return ec_create(800, pool, clock_rate, channel_count, samples_per_frame,
1586
 
                     flags, te);
1587
 
}
1588
 
 
1589
 
 
1590
 
/***************************************************************************/
1591
 
/* Tone generator, single frequency */
1592
 
static pjmedia_port* create_tonegen(unsigned freq1,
1593
 
                                    unsigned freq2,
1594
 
                                    pj_pool_t *pool,
1595
 
                                    unsigned clock_rate,
1596
 
                                    unsigned channel_count,
1597
 
                                    unsigned samples_per_frame,
1598
 
                                    unsigned flags,
1599
 
                                    struct test_entry *te)
1600
 
{
1601
 
    pjmedia_port *tonegen;
1602
 
    pjmedia_tone_desc tones[2];
1603
 
    pj_status_t status;
1604
 
 
1605
 
    PJ_UNUSED_ARG(flags);
1606
 
    PJ_UNUSED_ARG(te);
1607
 
 
1608
 
    status = pjmedia_tonegen_create(pool, clock_rate, channel_count,
1609
 
                                    samples_per_frame, 16,
1610
 
                                    PJMEDIA_TONEGEN_LOOP, &tonegen);
1611
 
    if (status != PJ_SUCCESS)
1612
 
        return NULL;
1613
 
 
1614
 
    pj_bzero(tones, sizeof(tones));
1615
 
    tones[0].freq1 = (short)freq1;
1616
 
    tones[0].freq2 = (short)freq2;
1617
 
    tones[0].on_msec = 400;
1618
 
    tones[0].off_msec = 0;
1619
 
    tones[1].freq1 = (short)freq1;
1620
 
    tones[1].freq2 = (short)freq2;
1621
 
    tones[1].on_msec = 400;
1622
 
    tones[1].off_msec = 100;
1623
 
 
1624
 
    status = pjmedia_tonegen_play(tonegen, PJ_ARRAY_SIZE(tones), tones,
1625
 
                                  PJMEDIA_TONEGEN_LOOP);
1626
 
    if (status != PJ_SUCCESS)
1627
 
        return NULL;
1628
 
 
1629
 
    return tonegen;
1630
 
}
1631
 
 
1632
 
/* Tonegen with single frequency */
1633
 
static pjmedia_port* create_tonegen1(pj_pool_t *pool,
1634
 
                                     unsigned clock_rate,
1635
 
                                     unsigned channel_count,
1636
 
                                     unsigned samples_per_frame,
1637
 
                                     unsigned flags,
1638
 
                                     struct test_entry *te)
1639
 
{
1640
 
    return create_tonegen(400, 0, pool, clock_rate, channel_count,
1641
 
                          samples_per_frame, flags, te);
1642
 
}
1643
 
 
1644
 
/* Tonegen with dual frequency */
1645
 
static pjmedia_port* create_tonegen2(pj_pool_t *pool,
1646
 
                                     unsigned clock_rate,
1647
 
                                     unsigned channel_count,
1648
 
                                     unsigned samples_per_frame,
1649
 
                                     unsigned flags,
1650
 
                                     struct test_entry *te)
1651
 
{
1652
 
    return create_tonegen(400, 440, pool, clock_rate, channel_count,
1653
 
                          samples_per_frame, flags, te);
1654
 
}
1655
 
 
1656
 
 
1657
 
 
1658
 
/***************************************************************************/
1659
 
/* Stream */
1660
 
 
1661
 
struct stream_port
1662
 
{
1663
 
    pjmedia_port         base;
1664
 
    pj_status_t        (*codec_deinit)();
1665
 
    pjmedia_endpt       *endpt;
1666
 
    pjmedia_stream      *stream;
1667
 
    pjmedia_transport   *transport;
1668
 
};
1669
 
 
1670
 
 
1671
 
static void stream_port_custom_deinit(struct test_entry *te)
1672
 
{
1673
 
    struct stream_port *sp = (struct stream_port*) te->pdata[0];
1674
 
 
1675
 
    pjmedia_stream_destroy(sp->stream);
1676
 
    pjmedia_transport_close(sp->transport);
1677
 
    sp->codec_deinit();
1678
 
    pjmedia_endpt_destroy(sp->endpt);
1679
 
 
1680
 
}
1681
 
 
1682
 
static pjmedia_port* create_stream( pj_pool_t *pool,
1683
 
                                    const char *codec,
1684
 
                                    pj_status_t (*codec_init)(pjmedia_endpt*),
1685
 
                                    pj_status_t (*codec_deinit)(),
1686
 
                                    pj_bool_t srtp_enabled,
1687
 
                                    pj_bool_t srtp_80,
1688
 
                                    pj_bool_t srtp_auth,
1689
 
                                    unsigned clock_rate,
1690
 
                                    unsigned channel_count,
1691
 
                                    unsigned samples_per_frame,
1692
 
                                    unsigned flags,
1693
 
                                    struct test_entry *te)
1694
 
{
1695
 
    struct stream_port *sp;
1696
 
    pj_str_t codec_id;
1697
 
    pjmedia_port *port;
1698
 
    const pjmedia_codec_info *ci[1];
1699
 
    unsigned count;
1700
 
    pjmedia_codec_param codec_param;
1701
 
    pjmedia_stream_info si;
1702
 
    pj_status_t status;
1703
 
 
1704
 
    PJ_UNUSED_ARG(flags);
1705
 
 
1706
 
    codec_id = pj_str((char*)codec);
1707
 
    sp = PJ_POOL_ZALLOC_T(pool, struct stream_port);
1708
 
    pjmedia_port_info_init(&sp->base.info, &codec_id, 0x123456, clock_rate,
1709
 
                           channel_count, 16, samples_per_frame);
1710
 
 
1711
 
    te->pdata[0] = sp;
1712
 
    te->custom_deinit = &stream_port_custom_deinit;
1713
 
    sp->codec_deinit = codec_deinit;
1714
 
 
1715
 
    status = pjmedia_endpt_create(mem, NULL, 0, &sp->endpt);
1716
 
    if (status != PJ_SUCCESS)
1717
 
        return NULL;
1718
 
 
1719
 
    status = codec_init(sp->endpt);
1720
 
    if (status != PJ_SUCCESS)
1721
 
        return NULL;
1722
 
 
1723
 
    count = 1;
1724
 
    status = pjmedia_codec_mgr_find_codecs_by_id(pjmedia_endpt_get_codec_mgr(sp->endpt),
1725
 
                                                 &codec_id, &count, ci, NULL);
1726
 
    if (status != PJ_SUCCESS)
1727
 
        return NULL;
1728
 
 
1729
 
 
1730
 
 
1731
 
    status = pjmedia_codec_mgr_get_default_param(pjmedia_endpt_get_codec_mgr(sp->endpt),
1732
 
                                                 ci[0], &codec_param);
1733
 
    if (status != PJ_SUCCESS)
1734
 
        return NULL;
1735
 
 
1736
 
    /* Create stream info */
1737
 
    pj_bzero(&si, sizeof(si));
1738
 
    si.type = PJMEDIA_TYPE_AUDIO;
1739
 
    si.proto = PJMEDIA_TP_PROTO_RTP_AVP;
1740
 
    si.dir = PJMEDIA_DIR_ENCODING_DECODING;
1741
 
    pj_sockaddr_in_init(&si.rem_addr.ipv4, NULL, 4000);
1742
 
    pj_sockaddr_in_init(&si.rem_rtcp.ipv4, NULL, 4001);
1743
 
    pj_memcpy(&si.fmt, ci[0], sizeof(pjmedia_codec_info));
1744
 
    si.param = NULL;
1745
 
    si.tx_pt = ci[0]->pt;
1746
 
    si.tx_event_pt = 101;
1747
 
    si.rx_event_pt = 101;
1748
 
    si.ssrc = pj_rand();
1749
 
    si.jb_init = si.jb_min_pre = si.jb_max_pre = si.jb_max = -1;
1750
 
 
1751
 
    /* Create loop transport */
1752
 
    status = pjmedia_transport_loop_create(sp->endpt, &sp->transport);
1753
 
    if (status != PJ_SUCCESS)
1754
 
        return NULL;
1755
 
 
1756
 
#if PJMEDIA_HAS_SRTP
1757
 
    if (srtp_enabled) {
1758
 
        pjmedia_srtp_setting opt;
1759
 
        pjmedia_srtp_crypto crypto;
1760
 
        pjmedia_transport *srtp;
1761
 
 
1762
 
        pjmedia_srtp_setting_default(&opt);
1763
 
        opt.close_member_tp = PJ_TRUE;
1764
 
        opt.use = PJMEDIA_SRTP_MANDATORY;
1765
 
 
1766
 
        status = pjmedia_transport_srtp_create(sp->endpt, sp->transport, &opt,
1767
 
                                               &srtp);
1768
 
        if (status != PJ_SUCCESS)
1769
 
            return NULL;
1770
 
 
1771
 
        pj_bzero(&crypto, sizeof(crypto));
1772
 
        if (srtp_80) {
1773
 
            crypto.key = pj_str("123456789012345678901234567890");
1774
 
            crypto.name = pj_str("AES_CM_128_HMAC_SHA1_80");
1775
 
        } else {
1776
 
            crypto.key = pj_str("123456789012345678901234567890");
1777
 
            crypto.name = pj_str("AES_CM_128_HMAC_SHA1_32");
1778
 
        }
1779
 
 
1780
 
        if (!srtp_auth)
1781
 
            crypto.flags = PJMEDIA_SRTP_NO_AUTHENTICATION;
1782
 
 
1783
 
        status = pjmedia_transport_srtp_start(srtp, &crypto, &crypto);
1784
 
        if (status != PJ_SUCCESS)
1785
 
            return NULL;
1786
 
 
1787
 
        sp->transport = srtp;
1788
 
    }
1789
 
#endif
1790
 
 
1791
 
    /* Create stream */
1792
 
    status = pjmedia_stream_create(sp->endpt, pool, &si, sp->transport, NULL,
1793
 
                                   &sp->stream);
1794
 
    if (status != PJ_SUCCESS)
1795
 
        return NULL;
1796
 
 
1797
 
    /* Start stream */
1798
 
    status = pjmedia_stream_start(sp->stream);
1799
 
    if (status != PJ_SUCCESS)
1800
 
        return NULL;
1801
 
 
1802
 
    status = pjmedia_stream_get_port(sp->stream, &port);
1803
 
    if (status != PJ_SUCCESS)
1804
 
        return NULL;
1805
 
 
1806
 
    return port;
1807
 
}
1808
 
 
1809
 
#if PJMEDIA_HAS_G711_CODEC
1810
 
/* G.711 stream, no SRTP */
1811
 
static pjmedia_port* create_stream_pcmu( pj_pool_t *pool,
1812
 
                                         unsigned clock_rate,
1813
 
                                         unsigned channel_count,
1814
 
                                         unsigned samples_per_frame,
1815
 
                                         unsigned flags,
1816
 
                                         struct test_entry *te)
1817
 
{
1818
 
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init,
1819
 
                         &pjmedia_codec_g711_deinit,
1820
 
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
1821
 
                         clock_rate, channel_count,
1822
 
                         samples_per_frame, flags, te);
1823
 
}
1824
 
 
1825
 
/* G.711 stream, SRTP 32bit key no auth */
1826
 
static pjmedia_port* create_stream_pcmu_srtp32_no_auth( pj_pool_t *pool,
1827
 
                                                        unsigned clock_rate,
1828
 
                                                        unsigned channel_count,
1829
 
                                                        unsigned samples_per_frame,
1830
 
                                                        unsigned flags,
1831
 
                                                        struct test_entry *te)
1832
 
{
1833
 
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init,
1834
 
                         &pjmedia_codec_g711_deinit,
1835
 
                         PJ_TRUE, PJ_FALSE, PJ_FALSE,
1836
 
                         clock_rate, channel_count,
1837
 
                         samples_per_frame, flags, te);
1838
 
}
1839
 
 
1840
 
/* G.711 stream, SRTP 32bit key with auth */
1841
 
static pjmedia_port* create_stream_pcmu_srtp32_with_auth(pj_pool_t *pool,
1842
 
                                                         unsigned clock_rate,
1843
 
                                                         unsigned channel_count,
1844
 
                                                         unsigned samples_per_frame,
1845
 
                                                         unsigned flags,
1846
 
                                                         struct test_entry *te)
1847
 
{
1848
 
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init,
1849
 
                         &pjmedia_codec_g711_deinit,
1850
 
                         PJ_TRUE, PJ_FALSE, PJ_TRUE,
1851
 
                         clock_rate, channel_count,
1852
 
                         samples_per_frame, flags, te);
1853
 
}
1854
 
 
1855
 
/* G.711 stream, SRTP 80bit key no auth */
1856
 
static pjmedia_port* create_stream_pcmu_srtp80_no_auth( pj_pool_t *pool,
1857
 
                                                        unsigned clock_rate,
1858
 
                                                        unsigned channel_count,
1859
 
                                                        unsigned samples_per_frame,
1860
 
                                                        unsigned flags,
1861
 
                                                        struct test_entry *te)
1862
 
{
1863
 
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init,
1864
 
                         &pjmedia_codec_g711_deinit,
1865
 
                         PJ_TRUE, PJ_TRUE, PJ_FALSE,
1866
 
                         clock_rate, channel_count,
1867
 
                         samples_per_frame, flags, te);
1868
 
}
1869
 
 
1870
 
/* G.711 stream, SRTP 80bit key with auth */
1871
 
static pjmedia_port* create_stream_pcmu_srtp80_with_auth(pj_pool_t *pool,
1872
 
                                                         unsigned clock_rate,
1873
 
                                                         unsigned channel_count,
1874
 
                                                         unsigned samples_per_frame,
1875
 
                                                         unsigned flags,
1876
 
                                                         struct test_entry *te)
1877
 
{
1878
 
    return create_stream(pool, "pcmu", &pjmedia_codec_g711_init,
1879
 
                         &pjmedia_codec_g711_deinit,
1880
 
                         PJ_TRUE, PJ_TRUE, PJ_TRUE,
1881
 
                         clock_rate, channel_count,
1882
 
                         samples_per_frame, flags, te);
1883
 
}
1884
 
#endif
1885
 
 
1886
 
#if PJMEDIA_HAS_GSM_CODEC
1887
 
/* GSM stream */
1888
 
static pjmedia_port* create_stream_gsm(  pj_pool_t *pool,
1889
 
                                         unsigned clock_rate,
1890
 
                                         unsigned channel_count,
1891
 
                                         unsigned samples_per_frame,
1892
 
                                         unsigned flags,
1893
 
                                         struct test_entry *te)
1894
 
{
1895
 
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init,
1896
 
                         &pjmedia_codec_gsm_deinit,
1897
 
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
1898
 
                         clock_rate, channel_count,
1899
 
                         samples_per_frame, flags, te);
1900
 
}
1901
 
 
1902
 
/* GSM stream, SRTP 32bit, no auth */
1903
 
static pjmedia_port* create_stream_gsm_srtp32_no_auth(pj_pool_t *pool,
1904
 
                                                      unsigned clock_rate,
1905
 
                                                      unsigned channel_count,
1906
 
                                                      unsigned samples_per_frame,
1907
 
                                                      unsigned flags,
1908
 
                                                      struct test_entry *te)
1909
 
{
1910
 
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init,
1911
 
                         &pjmedia_codec_gsm_deinit,
1912
 
                         PJ_TRUE, PJ_FALSE, PJ_FALSE,
1913
 
                         clock_rate, channel_count,
1914
 
                         samples_per_frame, flags, te);
1915
 
}
1916
 
 
1917
 
/* GSM stream, SRTP 32bit, with auth */
1918
 
static pjmedia_port* create_stream_gsm_srtp32_with_auth(pj_pool_t *pool,
1919
 
                                                        unsigned clock_rate,
1920
 
                                                        unsigned channel_count,
1921
 
                                                        unsigned samples_per_frame,
1922
 
                                                        unsigned flags,
1923
 
                                                        struct test_entry *te)
1924
 
{
1925
 
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init,
1926
 
                         &pjmedia_codec_gsm_deinit,
1927
 
                         PJ_TRUE, PJ_FALSE, PJ_TRUE,
1928
 
                         clock_rate, channel_count,
1929
 
                         samples_per_frame, flags, te);
1930
 
}
1931
 
 
1932
 
/* GSM stream, SRTP 80bit, no auth */
1933
 
static pjmedia_port* create_stream_gsm_srtp80_no_auth(pj_pool_t *pool,
1934
 
                                                      unsigned clock_rate,
1935
 
                                                      unsigned channel_count,
1936
 
                                                      unsigned samples_per_frame,
1937
 
                                                      unsigned flags,
1938
 
                                                      struct test_entry *te)
1939
 
{
1940
 
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init,
1941
 
                         &pjmedia_codec_gsm_deinit,
1942
 
                         PJ_TRUE, PJ_TRUE, PJ_FALSE,
1943
 
                         clock_rate, channel_count,
1944
 
                         samples_per_frame, flags, te);
1945
 
}
1946
 
 
1947
 
/* GSM stream, SRTP 80bit, with auth */
1948
 
static pjmedia_port* create_stream_gsm_srtp80_with_auth(pj_pool_t *pool,
1949
 
                                                        unsigned clock_rate,
1950
 
                                                        unsigned channel_count,
1951
 
                                                        unsigned samples_per_frame,
1952
 
                                                        unsigned flags,
1953
 
                                                        struct test_entry *te)
1954
 
{
1955
 
    return create_stream(pool, "gsm", &pjmedia_codec_gsm_init,
1956
 
                         &pjmedia_codec_gsm_deinit,
1957
 
                         PJ_TRUE, PJ_TRUE, PJ_TRUE,
1958
 
                         clock_rate, channel_count,
1959
 
                         samples_per_frame, flags, te);
1960
 
}
1961
 
#endif
1962
 
 
1963
 
#if PJMEDIA_HAS_G722_CODEC
1964
 
/* G722 stream */
1965
 
static pjmedia_port* create_stream_g722( pj_pool_t *pool,
1966
 
                                         unsigned clock_rate,
1967
 
                                         unsigned channel_count,
1968
 
                                         unsigned samples_per_frame,
1969
 
                                         unsigned flags,
1970
 
                                         struct test_entry *te)
1971
 
{
1972
 
    return create_stream(pool, "g722", &pjmedia_codec_g722_init,
1973
 
                         &pjmedia_codec_g722_deinit,
1974
 
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
1975
 
                         clock_rate, channel_count,
1976
 
                         samples_per_frame, flags, te);
1977
 
}
1978
 
#endif
1979
 
 
1980
 
#if PJMEDIA_HAS_G7221_CODEC
1981
 
/* G722.1 stream */
1982
 
static pjmedia_port* create_stream_g7221( pj_pool_t *pool,
1983
 
                                          unsigned clock_rate,
1984
 
                                          unsigned channel_count,
1985
 
                                          unsigned samples_per_frame,
1986
 
                                          unsigned flags,
1987
 
                                          struct test_entry *te)
1988
 
{
1989
 
    return create_stream(pool, "g7221/16000", &pjmedia_codec_g7221_init,
1990
 
                         &pjmedia_codec_g7221_deinit,
1991
 
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
1992
 
                         clock_rate, channel_count,
1993
 
                         samples_per_frame, flags, te);
1994
 
}
1995
 
 
1996
 
/* G722.1 Annex C stream */
1997
 
static pjmedia_port* create_stream_g7221c( pj_pool_t *pool,
1998
 
                                           unsigned clock_rate,
1999
 
                                           unsigned channel_count,
2000
 
                                           unsigned samples_per_frame,
2001
 
                                           unsigned flags,
2002
 
                                           struct test_entry *te)
2003
 
{
2004
 
    return create_stream(pool, "g7221/32000", &pjmedia_codec_g7221_init,
2005
 
                         &pjmedia_codec_g7221_deinit,
2006
 
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
2007
 
                         clock_rate, channel_count,
2008
 
                         samples_per_frame, flags, te);
2009
 
}
2010
 
#endif  /* PJMEDIA_HAS_G7221_CODEC */
2011
 
 
2012
 
/* AMR-NB stream */
2013
 
#if PJMEDIA_HAS_OPENCORE_AMRNB_CODEC
2014
 
static pjmedia_port* create_stream_amr( pj_pool_t *pool,
2015
 
                                        unsigned clock_rate,
2016
 
                                        unsigned channel_count,
2017
 
                                        unsigned samples_per_frame,
2018
 
                                        unsigned flags,
2019
 
                                        struct test_entry *te)
2020
 
{
2021
 
    return create_stream(pool, "AMR/8000", &pjmedia_codec_opencore_amrnb_init,
2022
 
                         &pjmedia_codec_opencore_amrnb_deinit,
2023
 
                         PJ_FALSE, PJ_FALSE, PJ_FALSE,
2024
 
                         clock_rate, channel_count,
2025
 
                         samples_per_frame, flags, te);
2026
 
}
2027
 
#endif  /* PJMEDIA_HAS_OPENCORE_AMRNB_CODEC */
2028
 
 
2029
 
/***************************************************************************/
2030
 
/* Delay buffer */
2031
 
enum {DELAY_BUF_MAX_DELAY = 80};
2032
 
struct delaybuf_port
2033
 
{
2034
 
    pjmedia_port         base;
2035
 
    pjmedia_delay_buf   *delaybuf;
2036
 
    pjmedia_port        *gen_port;
2037
 
    int                  drift_pct;
2038
 
};
2039
 
 
2040
 
 
2041
 
static pj_status_t delaybuf_get_frame(struct pjmedia_port *this_port,
2042
 
                                      pjmedia_frame *frame)
2043
 
{
2044
 
    struct delaybuf_port *dp = (struct delaybuf_port*)this_port;
2045
 
    pj_status_t status;
2046
 
 
2047
 
    status = pjmedia_delay_buf_get(dp->delaybuf, (pj_int16_t*)frame->buf);
2048
 
    pj_assert(status == PJ_SUCCESS);
2049
 
 
2050
 
    /* Additional GET when drift_pct is negative */
2051
 
    if (dp->drift_pct < 0) {
2052
 
        int rnd;
2053
 
        rnd = pj_rand() % 100;
2054
 
 
2055
 
        if (rnd < -dp->drift_pct) {
2056
 
            status = pjmedia_delay_buf_get(dp->delaybuf, (pj_int16_t*)frame->buf);
2057
 
            pj_assert(status == PJ_SUCCESS);
2058
 
        }
2059
 
    }
2060
 
 
2061
 
    return PJ_SUCCESS;
2062
 
}
2063
 
 
2064
 
static pj_status_t delaybuf_put_frame(struct pjmedia_port *this_port,
2065
 
                                      pjmedia_frame *frame)
2066
 
{
2067
 
    struct delaybuf_port *dp = (struct delaybuf_port*)this_port;
2068
 
    pj_status_t status;
2069
 
    pjmedia_frame f = *frame;
2070
 
 
2071
 
    status = pjmedia_port_get_frame(dp->gen_port, &f);
2072
 
    pj_assert(status == PJ_SUCCESS);
2073
 
    status = pjmedia_delay_buf_put(dp->delaybuf, (pj_int16_t*)f.buf);
2074
 
    pj_assert(status == PJ_SUCCESS);
2075
 
 
2076
 
    /* Additional PUT when drift_pct is possitive */
2077
 
    if (dp->drift_pct > 0) {
2078
 
        int rnd;
2079
 
        rnd = pj_rand() % 100;
2080
 
 
2081
 
        if (rnd < dp->drift_pct) {
2082
 
            status = pjmedia_port_get_frame(dp->gen_port, &f);
2083
 
            pj_assert(status == PJ_SUCCESS);
2084
 
            status = pjmedia_delay_buf_put(dp->delaybuf, (pj_int16_t*)f.buf);
2085
 
            pj_assert(status == PJ_SUCCESS);
2086
 
        }
2087
 
    }
2088
 
 
2089
 
    return PJ_SUCCESS;
2090
 
}
2091
 
 
2092
 
static pj_status_t delaybuf_on_destroy(struct pjmedia_port *this_port)
2093
 
{
2094
 
    struct delaybuf_port *dp = (struct delaybuf_port*)this_port;
2095
 
    pjmedia_port_destroy(dp->gen_port);
2096
 
    pjmedia_delay_buf_destroy(dp->delaybuf);
2097
 
    return PJ_SUCCESS;
2098
 
}
2099
 
 
2100
 
static pjmedia_port* create_delaybuf(int drift_pct,
2101
 
                                     pj_pool_t *pool,
2102
 
                                     unsigned clock_rate,
2103
 
                                     unsigned channel_count,
2104
 
                                     unsigned samples_per_frame,
2105
 
                                     unsigned flags,
2106
 
                                     struct test_entry *te)
2107
 
{
2108
 
    struct delaybuf_port *dp;
2109
 
    pj_str_t name = pj_str("delaybuf");
2110
 
    unsigned opt = 0;
2111
 
    pj_status_t status;
2112
 
 
2113
 
    PJ_UNUSED_ARG(flags);
2114
 
    PJ_UNUSED_ARG(te);
2115
 
 
2116
 
    dp = PJ_POOL_ZALLOC_T(pool, struct delaybuf_port);
2117
 
    dp->drift_pct = drift_pct;
2118
 
    dp->base.get_frame = &delaybuf_get_frame;
2119
 
    dp->base.put_frame = &delaybuf_put_frame;
2120
 
    dp->base.on_destroy = &delaybuf_on_destroy;
2121
 
    pjmedia_port_info_init(&dp->base.info, &name, 0x5678, clock_rate,
2122
 
                           channel_count, 16, samples_per_frame);
2123
 
 
2124
 
    status = pjmedia_delay_buf_create(pool, "mips_test", clock_rate,
2125
 
                                      samples_per_frame, channel_count,
2126
 
                                      DELAY_BUF_MAX_DELAY,
2127
 
                                      opt, &dp->delaybuf);
2128
 
    if (status != PJ_SUCCESS)
2129
 
        return NULL;
2130
 
 
2131
 
    dp->gen_port = create_gen_port(pool, clock_rate, channel_count,
2132
 
                                   samples_per_frame, 100);
2133
 
    if (dp->gen_port == NULL)
2134
 
        return NULL;
2135
 
 
2136
 
    return &dp->base;
2137
 
}
2138
 
 
2139
 
 
2140
 
/* Delay buffer without drift */
2141
 
static pjmedia_port* delaybuf_0( pj_pool_t *pool,
2142
 
                                  unsigned clock_rate,
2143
 
                                  unsigned channel_count,
2144
 
                                  unsigned samples_per_frame,
2145
 
                                  unsigned flags,
2146
 
                                  struct test_entry *te)
2147
 
{
2148
 
    return create_delaybuf(0, pool, clock_rate, channel_count,
2149
 
                           samples_per_frame, flags, te);
2150
 
}
2151
 
 
2152
 
 
2153
 
/* Delay buffer with 2% drift */
2154
 
static pjmedia_port* delaybuf_p2( pj_pool_t *pool,
2155
 
                                  unsigned clock_rate,
2156
 
                                  unsigned channel_count,
2157
 
                                  unsigned samples_per_frame,
2158
 
                                  unsigned flags,
2159
 
                                  struct test_entry *te)
2160
 
{
2161
 
    return create_delaybuf(2, pool, clock_rate, channel_count,
2162
 
                           samples_per_frame, flags, te);
2163
 
}
2164
 
 
2165
 
/* Delay buffer with 5% drift */
2166
 
static pjmedia_port* delaybuf_p5( pj_pool_t *pool,
2167
 
                                  unsigned clock_rate,
2168
 
                                  unsigned channel_count,
2169
 
                                  unsigned samples_per_frame,
2170
 
                                  unsigned flags,
2171
 
                                  struct test_entry *te)
2172
 
{
2173
 
    return create_delaybuf(5, pool, clock_rate, channel_count,
2174
 
                           samples_per_frame, flags, te);
2175
 
}
2176
 
 
2177
 
/* Delay buffer with 10% drift */
2178
 
static pjmedia_port* delaybuf_p10(pj_pool_t *pool,
2179
 
                                  unsigned clock_rate,
2180
 
                                  unsigned channel_count,
2181
 
                                  unsigned samples_per_frame,
2182
 
                                  unsigned flags,
2183
 
                                  struct test_entry *te)
2184
 
{
2185
 
    return create_delaybuf(10, pool, clock_rate, channel_count,
2186
 
                           samples_per_frame, flags, te);
2187
 
}
2188
 
 
2189
 
/* Delay buffer with 20% drift */
2190
 
static pjmedia_port* delaybuf_p20(pj_pool_t *pool,
2191
 
                                  unsigned clock_rate,
2192
 
                                  unsigned channel_count,
2193
 
                                  unsigned samples_per_frame,
2194
 
                                  unsigned flags,
2195
 
                                  struct test_entry *te)
2196
 
{
2197
 
    return create_delaybuf(20, pool, clock_rate, channel_count,
2198
 
                           samples_per_frame, flags, te);
2199
 
}
2200
 
 
2201
 
/* Delay buffer with -2% drift */
2202
 
static pjmedia_port* delaybuf_n2( pj_pool_t *pool,
2203
 
                                  unsigned clock_rate,
2204
 
                                  unsigned channel_count,
2205
 
                                  unsigned samples_per_frame,
2206
 
                                  unsigned flags,
2207
 
                                  struct test_entry *te)
2208
 
{
2209
 
    return create_delaybuf(-2, pool, clock_rate, channel_count,
2210
 
                           samples_per_frame, flags, te);
2211
 
}
2212
 
 
2213
 
/* Delay buffer with -5% drift */
2214
 
static pjmedia_port* delaybuf_n5( pj_pool_t *pool,
2215
 
                                  unsigned clock_rate,
2216
 
                                  unsigned channel_count,
2217
 
                                  unsigned samples_per_frame,
2218
 
                                  unsigned flags,
2219
 
                                  struct test_entry *te)
2220
 
{
2221
 
    return create_delaybuf(-5, pool, clock_rate, channel_count,
2222
 
                           samples_per_frame, flags, te);
2223
 
}
2224
 
 
2225
 
/* Delay buffer with -10% drift */
2226
 
static pjmedia_port* delaybuf_n10(pj_pool_t *pool,
2227
 
                                  unsigned clock_rate,
2228
 
                                  unsigned channel_count,
2229
 
                                  unsigned samples_per_frame,
2230
 
                                  unsigned flags,
2231
 
                                  struct test_entry *te)
2232
 
{
2233
 
    return create_delaybuf(-10, pool, clock_rate, channel_count,
2234
 
                           samples_per_frame, flags, te);
2235
 
}
2236
 
 
2237
 
/* Delay buffer with -20% drift */
2238
 
static pjmedia_port* delaybuf_n20(pj_pool_t *pool,
2239
 
                                  unsigned clock_rate,
2240
 
                                  unsigned channel_count,
2241
 
                                  unsigned samples_per_frame,
2242
 
                                  unsigned flags,
2243
 
                                  struct test_entry *te)
2244
 
{
2245
 
    return create_delaybuf(-20, pool, clock_rate, channel_count,
2246
 
                           samples_per_frame, flags, te);
2247
 
}
2248
 
 
2249
 
 
2250
 
/***************************************************************************/
2251
 
/* Run test entry, return elapsed time */
2252
 
static pj_timestamp run_entry(unsigned clock_rate, struct test_entry *e)
2253
 
{
2254
 
    pj_pool_t *pool;
2255
 
    pjmedia_port *port;
2256
 
    pj_timestamp t0, t1;
2257
 
    unsigned j, samples_per_frame;
2258
 
    pj_int16_t pcm[32000 * PTIME / 1000];
2259
 
    pjmedia_port *gen_port;
2260
 
    pj_status_t status;
2261
 
 
2262
 
    samples_per_frame = clock_rate * PTIME / 1000;
2263
 
 
2264
 
    pool = pj_pool_create(mem, "pool", 1024, 1024, NULL);
2265
 
    port = e->init(pool, clock_rate, 1, samples_per_frame, 0, e);
2266
 
    if (port == NULL) {
2267
 
        t0.u64 = 0;
2268
 
        pj_pool_release(pool);
2269
 
        PJ_LOG(1,(THIS_FILE, " init error"));
2270
 
        return t0;
2271
 
    }
2272
 
 
2273
 
    /* Port may decide to use different ptime (e.g. iLBC) */
2274
 
    samples_per_frame = PJMEDIA_PIA_SPF(&port->info);
2275
 
 
2276
 
    gen_port = create_gen_port(pool, clock_rate, 1,
2277
 
                               samples_per_frame, 100);
2278
 
    if (gen_port == NULL) {
2279
 
        t0.u64 = 0;
2280
 
        pj_pool_release(pool);
2281
 
        return t0;
2282
 
    }
2283
 
 
2284
 
    pj_get_timestamp(&t0);
2285
 
    for (j=0; j<DURATION*clock_rate/samples_per_frame/1000; ++j) {
2286
 
        pjmedia_frame frm;
2287
 
 
2288
 
        if (e->valid_op==OP_GET_PUT) {
2289
 
            frm.buf = (void*)pcm;
2290
 
            frm.size = samples_per_frame * 2;
2291
 
            frm.type = PJMEDIA_FRAME_TYPE_NONE;
2292
 
 
2293
 
            status = pjmedia_port_get_frame(port, &frm);
2294
 
            pj_assert(status == PJ_SUCCESS);
2295
 
 
2296
 
            status = pjmedia_port_put_frame(port, &frm);
2297
 
            pj_assert(status == PJ_SUCCESS);
2298
 
 
2299
 
        } else if (e->valid_op == OP_GET) {
2300
 
            frm.buf = (void*)pcm;
2301
 
            frm.size = samples_per_frame * 2;
2302
 
            frm.type = PJMEDIA_FRAME_TYPE_NONE;
2303
 
 
2304
 
            status = pjmedia_port_get_frame(port, &frm);
2305
 
            pj_assert(status == PJ_SUCCESS);
2306
 
 
2307
 
        } else if (e->valid_op == OP_PUT) {
2308
 
            frm.buf = (void*)pcm;
2309
 
            frm.size = samples_per_frame * 2;
2310
 
            frm.type = PJMEDIA_FRAME_TYPE_NONE;
2311
 
 
2312
 
            status = pjmedia_port_get_frame(gen_port, &frm);
2313
 
            pj_assert(status == PJ_SUCCESS);
2314
 
 
2315
 
            status = pjmedia_port_put_frame(port, &frm);
2316
 
            pj_assert(status == PJ_SUCCESS);
2317
 
 
2318
 
        } else if (e->valid_op == OP_PUT_GET) {
2319
 
            frm.buf = (void*)pcm;
2320
 
            frm.size = samples_per_frame * 2;
2321
 
            frm.type = PJMEDIA_FRAME_TYPE_NONE;
2322
 
 
2323
 
            status = pjmedia_port_get_frame(gen_port, &frm);
2324
 
            pj_assert(status == PJ_SUCCESS);
2325
 
 
2326
 
            status = pjmedia_port_put_frame(port, &frm);
2327
 
            pj_assert(status == PJ_SUCCESS);
2328
 
 
2329
 
            status = pjmedia_port_get_frame(port, &frm);
2330
 
            pj_assert(status == PJ_SUCCESS);
2331
 
        }
2332
 
    }
2333
 
    pj_get_timestamp(&t1);
2334
 
 
2335
 
    pj_sub_timestamp(&t1, &t0);
2336
 
 
2337
 
    if (e->custom_deinit)
2338
 
        e->custom_deinit(e);
2339
 
 
2340
 
    pjmedia_port_destroy(port);
2341
 
    pj_pool_release(pool);
2342
 
 
2343
 
    return t1;
2344
 
}
2345
 
 
2346
 
/***************************************************************************/
2347
 
int mips_test(void)
2348
 
{
2349
 
    struct test_entry entries[] = {
2350
 
        { "get from memplayer", OP_GET, K8|K16, &gen_port_test_init},
2351
 
        { "conference bridge with 1 call", OP_GET_PUT, K8|K16, &conf1_test_init},
2352
 
        { "conference bridge with 2 calls", OP_GET_PUT, K8|K16, &conf2_test_init},
2353
 
        { "conference bridge with 4 calls", OP_GET_PUT, K8|K16, &conf4_test_init},
2354
 
        { "conference bridge with 8 calls", OP_GET_PUT, K8|K16, &conf8_test_init},
2355
 
        { "conference bridge with 16 calls", OP_GET_PUT, K8|K16, &conf16_test_init},
2356
 
        { "upsample+downsample - linear", OP_GET, K8|K16, &linear_resample},
2357
 
        { "upsample+downsample - small filter", OP_GET, K8|K16, &small_filt_resample},
2358
 
        { "upsample+downsample - large filter", OP_GET, K8|K16, &large_filt_resample},
2359
 
        { "WSOLA PLC - 0% loss", OP_GET, K8|K16, &wsola_plc_0},
2360
 
        { "WSOLA PLC - 2% loss", OP_GET, K8|K16, &wsola_plc_2},
2361
 
        { "WSOLA PLC - 5% loss", OP_GET, K8|K16, &wsola_plc_5},
2362
 
        { "WSOLA PLC - 10% loss", OP_GET, K8|K16, &wsola_plc_10},
2363
 
        { "WSOLA PLC - 20% loss", OP_GET, K8|K16, &wsola_plc_20},
2364
 
        { "WSOLA PLC - 50% loss", OP_GET, K8|K16, &wsola_plc_50},
2365
 
        { "WSOLA discard 2% excess", OP_GET, K8|K16, &wsola_discard_2},
2366
 
        { "WSOLA discard 5% excess", OP_GET, K8|K16, &wsola_discard_5},
2367
 
        { "WSOLA discard 10% excess", OP_GET, K8|K16, &wsola_discard_10},
2368
 
        { "WSOLA discard 20% excess", OP_GET, K8|K16, &wsola_discard_20},
2369
 
        { "WSOLA discard 50% excess", OP_GET, K8|K16, &wsola_discard_50},
2370
 
        { "Delay buffer", OP_GET_PUT, K8|K16, &delaybuf_0},
2371
 
        { "Delay buffer - drift -2%", OP_GET_PUT, K8|K16, &delaybuf_n2},
2372
 
        { "Delay buffer - drift -5%", OP_GET_PUT, K8|K16, &delaybuf_n5},
2373
 
        { "Delay buffer - drift -10%", OP_GET_PUT, K8|K16, &delaybuf_n10},
2374
 
        { "Delay buffer - drift -20%", OP_GET_PUT, K8|K16, &delaybuf_n20},
2375
 
        { "Delay buffer - drift +2%", OP_GET_PUT, K8|K16, &delaybuf_p2},
2376
 
        { "Delay buffer - drift +5%", OP_GET_PUT, K8|K16, &delaybuf_p5},
2377
 
        { "Delay buffer - drift +10%", OP_GET_PUT, K8|K16, &delaybuf_p10},
2378
 
        { "Delay buffer - drift +20%", OP_GET_PUT, K8|K16, &delaybuf_p20},
2379
 
        { "echo canceller 100ms tail len", OP_GET_PUT, K8|K16, &ec_create_100},
2380
 
        { "echo canceller 128ms tail len", OP_GET_PUT, K8|K16, &ec_create_128},
2381
 
        { "echo canceller 200ms tail len", OP_GET_PUT, K8|K16, &ec_create_200},
2382
 
        { "echo canceller 256ms tail len", OP_GET_PUT, K8|K16, &ec_create_256},
2383
 
        { "echo canceller 400ms tail len", OP_GET_PUT, K8|K16, &ec_create_400},
2384
 
        { "echo canceller 500ms tail len", OP_GET_PUT, K8|K16, &ec_create_500},
2385
 
        { "echo canceller 512ms tail len", OP_GET_PUT, K8|K16, &ec_create_512},
2386
 
        { "echo canceller 600ms tail len", OP_GET_PUT, K8|K16, &ec_create_600},
2387
 
        { "echo canceller 800ms tail len", OP_GET_PUT, K8|K16, &ec_create_800},
2388
 
        { "echo suppressor 100ms tail len", OP_GET_PUT, K8|K16, &es_create_100},
2389
 
        { "echo suppressor 128ms tail len", OP_GET_PUT, K8|K16, &es_create_128},
2390
 
        { "echo suppressor 200ms tail len", OP_GET_PUT, K8|K16, &es_create_200},
2391
 
        { "echo suppressor 256ms tail len", OP_GET_PUT, K8|K16, &es_create_256},
2392
 
        { "echo suppressor 400ms tail len", OP_GET_PUT, K8|K16, &es_create_400},
2393
 
        { "echo suppressor 500ms tail len", OP_GET_PUT, K8|K16, &es_create_500},
2394
 
        { "echo suppressor 512ms tail len", OP_GET_PUT, K8|K16, &es_create_512},
2395
 
        { "echo suppressor 600ms tail len", OP_GET_PUT, K8|K16, &es_create_600},
2396
 
        { "echo suppressor 800ms tail len", OP_GET_PUT, K8|K16, &es_create_800},
2397
 
        { "tone generator with single freq", OP_GET, K8|K16, &create_tonegen1},
2398
 
        { "tone generator with dual freq", OP_GET, K8|K16, &create_tonegen2},
2399
 
#if PJMEDIA_HAS_G711_CODEC
2400
 
        { "codec encode/decode - G.711", OP_PUT, K8, &g711_encode_decode},
2401
 
#endif
2402
 
#if PJMEDIA_HAS_G722_CODEC
2403
 
        { "codec encode/decode - G.722", OP_PUT, K16, &g722_encode_decode},
2404
 
#endif
2405
 
#if PJMEDIA_HAS_GSM_CODEC
2406
 
        { "codec encode/decode - GSM", OP_PUT, K8, &gsm_encode_decode},
2407
 
#endif
2408
 
#if PJMEDIA_HAS_ILBC_CODEC
2409
 
        { "codec encode/decode - iLBC", OP_PUT, K8, &ilbc_encode_decode},
2410
 
#endif
2411
 
#if PJMEDIA_HAS_SPEEX_CODEC
2412
 
        { "codec encode/decode - Speex 8Khz", OP_PUT, K8, &speex8_encode_decode},
2413
 
        { "codec encode/decode - Speex 16Khz", OP_PUT, K16, &speex16_encode_decode},
2414
 
#endif
2415
 
#if PJMEDIA_HAS_G7221_CODEC
2416
 
        { "codec encode/decode - G.722.1", OP_PUT, K16, &g7221_encode_decode},
2417
 
        { "codec encode/decode - G.722.1c", OP_PUT, K32, &g7221c_encode_decode},
2418
 
#endif
2419
 
#if PJMEDIA_HAS_OPENCORE_AMRNB_CODEC
2420
 
        { "codec encode/decode - AMR-NB", OP_PUT, K8, &amr_encode_decode},
2421
 
#endif
2422
 
#if PJMEDIA_HAS_L16_CODEC
2423
 
        { "codec encode/decode - L16/8000/1", OP_PUT, K8, &l16_8_encode_decode},
2424
 
        { "codec encode/decode - L16/16000/1", OP_PUT, K16, &l16_16_encode_decode},
2425
 
#endif
2426
 
#if PJMEDIA_HAS_G711_CODEC
2427
 
        { "stream TX/RX - G.711", OP_PUT_GET, K8, &create_stream_pcmu},
2428
 
        { "stream TX/RX - G.711 SRTP 32bit", OP_PUT_GET, K8, &create_stream_pcmu_srtp32_no_auth},
2429
 
        { "stream TX/RX - G.711 SRTP 32bit +auth", OP_PUT_GET, K8, &create_stream_pcmu_srtp32_with_auth},
2430
 
        { "stream TX/RX - G.711 SRTP 80bit", OP_PUT_GET, K8, &create_stream_pcmu_srtp80_no_auth},
2431
 
        { "stream TX/RX - G.711 SRTP 80bit +auth", OP_PUT_GET, K8, &create_stream_pcmu_srtp80_with_auth},
2432
 
#endif
2433
 
#if PJMEDIA_HAS_G722_CODEC
2434
 
        { "stream TX/RX - G.722", OP_PUT_GET, K16, &create_stream_g722},
2435
 
#endif
2436
 
#if PJMEDIA_HAS_GSM_CODEC
2437
 
        { "stream TX/RX - GSM", OP_PUT_GET, K8, &create_stream_gsm},
2438
 
        { "stream TX/RX - GSM SRTP 32bit", OP_PUT_GET, K8, &create_stream_gsm_srtp32_no_auth},
2439
 
        { "stream TX/RX - GSM SRTP 32bit + auth", OP_PUT_GET, K8, &create_stream_gsm_srtp32_with_auth},
2440
 
        { "stream TX/RX - GSM SRTP 80bit", OP_PUT_GET, K8, &create_stream_gsm_srtp80_no_auth},
2441
 
        { "stream TX/RX - GSM SRTP 80bit + auth", OP_PUT_GET, K8, &create_stream_gsm_srtp80_with_auth},
2442
 
#endif
2443
 
#if PJMEDIA_HAS_G7221_CODEC
2444
 
        { "stream TX/RX - G.722.1", OP_PUT_GET, K16, &create_stream_g7221},
2445
 
        { "stream TX/RX - G.722.1c", OP_PUT_GET, K32, &create_stream_g7221c},
2446
 
#endif
2447
 
#if PJMEDIA_HAS_OPENCORE_AMRNB_CODEC
2448
 
        { "stream TX/RX - AMR-NB", OP_PUT_GET, K8, &create_stream_amr},
2449
 
#endif
2450
 
    };
2451
 
 
2452
 
    unsigned i, c, k[3] = {K8, K16, K32}, clock_rates[3] = {8000, 16000, 32000};
2453
 
 
2454
 
    PJ_LOG(3,(THIS_FILE, "MIPS test, with CPU=%dMhz, %6.1f MIPS", CPU_MHZ, CPU_IPS / 1000000));
2455
 
    PJ_LOG(3,(THIS_FILE, "Clock  Item                                      Time     CPU    MIPS"));
2456
 
    PJ_LOG(3,(THIS_FILE, " Rate                                           (usec)    (%%)       "));
2457
 
    PJ_LOG(3,(THIS_FILE, "----------------------------------------------------------------------"));
2458
 
 
2459
 
    for (c=0; c<PJ_ARRAY_SIZE(clock_rates); ++c) {
2460
 
        for (i=0; i<PJ_ARRAY_SIZE(entries); ++i) {
2461
 
            enum
2462
 
            {
2463
 
                RETRY   = 5,    /* number of test retries */
2464
 
            };
2465
 
            struct test_entry *e = &entries[i];
2466
 
            pj_timestamp times[RETRY], tzero;
2467
 
            int usec;
2468
 
            float cpu_pct, mips_val;
2469
 
            unsigned j, clock_rate = clock_rates[c];
2470
 
 
2471
 
            if ((e->valid_clock_rate & k[c]) == 0)
2472
 
                continue;
2473
 
 
2474
 
            /* Run test */
2475
 
            for (j=0; j<RETRY; ++j) {
2476
 
                pj_thread_sleep(1);
2477
 
                times[j] = run_entry(clock_rate, e);
2478
 
            }
2479
 
 
2480
 
            /* Sort ascending */
2481
 
            for (j=0; j<RETRY; ++j) {
2482
 
                unsigned k;
2483
 
                for (k=j+1; k<RETRY; ++k) {
2484
 
                    if (times[k].u64 < times[j].u64) {
2485
 
                        pj_timestamp tmp = times[j];
2486
 
                        times[j] = times[k];
2487
 
                        times[k] = tmp;
2488
 
                    }
2489
 
                }
2490
 
            }
2491
 
 
2492
 
            /* Calculate usec elapsed as average of two best times */
2493
 
            tzero.u32.hi = tzero.u32.lo = 0;
2494
 
            usec = (pj_elapsed_usec(&tzero, &times[0]) +
2495
 
                    pj_elapsed_usec(&tzero, &times[1])) / 2;
2496
 
 
2497
 
            usec = usec / (DURATION / 1000);
2498
 
 
2499
 
            mips_val = (float)(CPU_IPS * usec / 1000000.0 / 1000000);
2500
 
            cpu_pct = (float)(100.0 * usec / 1000000);
2501
 
            PJ_LOG(3,(THIS_FILE, "%2dKHz %-38s % 8d %8.3f %7.2f",
2502
 
                      clock_rate/1000, e->title, usec, cpu_pct, mips_val));
2503
 
 
2504
 
        }
2505
 
    }
2506
 
 
2507
 
    return 0;
2508
 
}