← Back to branch summary

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

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/third_party/g7221/common/basic_op.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* 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:
daemon/libs/pjproject-2.1.0/third_party/g7221/common/basic_op.c
 
1
#include "config.h"
 
2
 
 
3
#if !PJMEDIA_LIBG7221_FUNCS_INLINED || \
 
4
    (PJMEDIA_LIBG7221_FUNCS_INLINED && defined(__BASIC_OP_H__))
 
5
 
 
6
/*___________________________________________________________________________
 
7
 |                                                                           |
 
8
 | Basic arithmetic operators.                                               |
 
9
 |___________________________________________________________________________|
 
10
*/
 
11
 
 
12
/*___________________________________________________________________________
 
13
 |                                                                           |
 
14
 |   Include-Files                                                           |
 
15
 |___________________________________________________________________________|
 
16
*/
 
17
 
 
18
//#include <stdio.h>
 
19
//#include <stdlib.h>
 
20
#include "typedef.h"
 
21
#include "basic_op.h"
 
22
#include <pj/assert.h>
 
23
 
 
24
#if (WMOPS)
 
25
#include "count.h"
 
26
extern BASIC_OP multiCounter[MAXCOUNTERS];
 
27
extern int currCounter;
 
28
 
 
29
#endif
 
30
 
 
31
/*___________________________________________________________________________
 
32
 |                                                                           |
 
33
 |   Constants and Globals                                                   |
 
34
 |___________________________________________________________________________|
 
35
*/
 
36
#if INCLUDE_UNSAFE
 
37
Flag g7221_Overflow = 0;
 
38
Flag g7221_Carry = 0;
 
39
#endif
 
40
 
 
41
/*___________________________________________________________________________
 
42
 |                                                                           |
 
43
 |   Functions                                                               |
 
44
 |___________________________________________________________________________|
 
45
*/
 
46
/*___________________________________________________________________________
 
47
 |                                                                           |
 
48
 |   Function Name : shr                                                     |
 
49
 |                                                                           |
 
50
 |   Purpose :                                                               |
 
51
 |                                                                           |
 
52
 |   Arithmetically shift the 16 bit input var1 right var2 positions with    |
 
53
 |   sign extension. If var2 is negative, arithmetically shift var1 left by  |
 
54
 |   -var2 with sign extension. Saturate the result in case of underflows or |
 
55
 |   overflows.                                                              |
 
56
 |                                                                           |
 
57
 |   Complexity weight : 1                                                   |
 
58
 |                                                                           |
 
59
 |   Inputs :                                                                |
 
60
 |                                                                           |
 
61
 |    var1                                                                   |
 
62
 |             16 bit short signed integer (Word16) whose value falls in the |
 
63
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
64
 |                                                                           |
 
65
 |    var2                                                                   |
 
66
 |             16 bit short signed integer (Word16) whose value falls in the |
 
67
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
68
 |                                                                           |
 
69
 |   Outputs :                                                               |
 
70
 |                                                                           |
 
71
 |    none                                                                   |
 
72
 |                                                                           |
 
73
 |   Return Value :                                                          |
 
74
 |                                                                           |
 
75
 |    var_out                                                                |
 
76
 |             16 bit short signed integer (Word16) whose value falls in the |
 
77
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
78
 |___________________________________________________________________________|
 
79
*/
 
80
LIBG7221_DEF(Word16) shr (Word16 var1, Word16 var2)
 
81
{
 
82
    if (var2 < 0)
 
83
    {
 
84
        if (var2 < -16)
 
85
            var2 = -16;
 
86
        return shl_nocheck(var1, (Word16) -var2);
 
87
    }
 
88
    else
 
89
    {
 
90
        return shr_nocheck(var1, var2);
 
91
    }
 
92
}
 
93
/* ------------------------- End of shr() ------------------------- */
 
94
 
 
95
 
 
96
/*___________________________________________________________________________
 
97
 |                                                                           |
 
98
 |   Function Name : shl                                                     |
 
99
 |                                                                           |
 
100
 |   Purpose :                                                               |
 
101
 |                                                                           |
 
102
 |   Arithmetically shift the 16 bit input var1 left var2 positions.Zero fill|
 
103
 |   the var2 LSB of the result. If var2 is negative, arithmetically shift   |
 
104
 |   var1 right by -var2 with sign extension. Saturate the result in case of |
 
105
 |   underflows or overflows.                                                |
 
106
 |                                                                           |
 
107
 |   Complexity weight : 1                                                   |
 
108
 |                                                                           |
 
109
 |   Inputs :                                                                |
 
110
 |                                                                           |
 
111
 |    var1                                                                   |
 
112
 |             16 bit short signed integer (Word16) whose value falls in the |
 
113
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
114
 |                                                                           |
 
115
 |    var2                                                                   |
 
116
 |             16 bit short signed integer (Word16) whose value falls in the |
 
117
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
118
 |                                                                           |
 
119
 |   Outputs :                                                               |
 
120
 |                                                                           |
 
121
 |    none                                                                   |
 
122
 |                                                                           |
 
123
 |   Return Value :                                                          |
 
124
 |                                                                           |
 
125
 |    var_out                                                                |
 
126
 |             16 bit short signed integer (Word16) whose value falls in the |
 
127
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
128
 |___________________________________________________________________________|
 
129
*/
 
130
LIBG7221_DEF(Word16) shl (Word16 var1, Word16 var2)
 
131
{
 
132
    if (var2 < 0)
 
133
    {
 
134
        return shr_nocheck(var1, (Word16) -var2);
 
135
    }
 
136
    else
 
137
    {
 
138
        return shl_nocheck(var1, var2);
 
139
    }
 
140
}
 
141
/* ------------------------- End of shl() ------------------------- */
 
142
 
 
143
 
 
144
 
 
145
/*___________________________________________________________________________
 
146
 |                                                                           |
 
147
 |   Function Name : mult                                                    |
 
148
 |                                                                           |
 
149
 |   Purpose :                                                               |
 
150
 |                                                                           |
 
151
 |    Performs the multiplication of var1 by var2 and gives a 16 bit result  |
 
152
 |    which is scaled i.e.:                                                  |
 
153
 |             mult(var1,var2) = extract_l(L_shr((var1 times var2),15)) and  |
 
154
 |             mult(-32768,-32768) = 32767.                                  |
 
155
 |                                                                           |
 
156
 |   Complexity weight : 1                                                   |
 
157
 |                                                                           |
 
158
 |   Inputs :                                                                |
 
159
 |                                                                           |
 
160
 |    var1                                                                   |
 
161
 |             16 bit short signed integer (Word16) whose value falls in the |
 
162
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
163
 |                                                                           |
 
164
 |    var2                                                                   |
 
165
 |             16 bit short signed integer (Word16) whose value falls in the |
 
166
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
167
 |                                                                           |
 
168
 |   Outputs :                                                               |
 
169
 |                                                                           |
 
170
 |    none                                                                   |
 
171
 |                                                                           |
 
172
 |   Return Value :                                                          |
 
173
 |                                                                           |
 
174
 |    var_out                                                                |
 
175
 |             16 bit short signed integer (Word16) whose value falls in the |
 
176
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
177
 |___________________________________________________________________________|
 
178
*/
 
179
LIBG7221_DEF(Word16) mult (Word16 var1, Word16 var2)
 
180
{
 
181
    Word16 var_out;
 
182
    Word32 L_product;
 
183
 
 
184
    L_product = (Word32) var1 *(Word32) var2;
 
185
 
 
186
    L_product = (L_product & (Word32) 0xffff8000L) >> 15;
 
187
 
 
188
    if (L_product & (Word32) 0x00010000L)
 
189
        L_product = L_product | (Word32) 0xffff0000L;
 
190
 
 
191
    var_out = saturate (L_product);
 
192
#if (WMOPS)
 
193
    multiCounter[currCounter].mult++;
 
194
#endif
 
195
    return (var_out);
 
196
}
 
197
/* ------------------------- End of mult() ------------------------- */
 
198
 
 
199
 
 
200
/*___________________________________________________________________________
 
201
 |                                                                           |
 
202
 |   Function Name : L_msu                                                   |
 
203
 |                                                                           |
 
204
 |   Purpose :                                                               |
 
205
 |                                                                           |
 
206
 |   Multiply var1 by var2 and shift the result left by 1. Subtract the 32   |
 
207
 |   bit result to L_var3 with saturation, return a 32 bit result:           |
 
208
 |        L_msu(L_var3,var1,var2) = L_sub(L_var3,L_mult(var1,var2)).         |
 
209
 |                                                                           |
 
210
 |   Complexity weight : 1                                                   |
 
211
 |                                                                           |
 
212
 |   Inputs :                                                                |
 
213
 |                                                                           |
 
214
 |    L_var3   32 bit long signed integer (Word32) whose value falls in the  |
 
215
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
216
 |                                                                           |
 
217
 |    var1                                                                   |
 
218
 |             16 bit short signed integer (Word16) whose value falls in the |
 
219
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
220
 |                                                                           |
 
221
 |    var2                                                                   |
 
222
 |             16 bit short signed integer (Word16) whose value falls in the |
 
223
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
224
 |                                                                           |
 
225
 |   Outputs :                                                               |
 
226
 |                                                                           |
 
227
 |    none                                                                   |
 
228
 |                                                                           |
 
229
 |   Return Value :                                                          |
 
230
 |                                                                           |
 
231
 |    L_var_out                                                              |
 
232
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
233
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
234
 |___________________________________________________________________________|
 
235
*/
 
236
LIBG7221_DEF(Word32) L_msu (Word32 L_var3, Word16 var1, Word16 var2)
 
237
{
 
238
    Word32 L_var_out;
 
239
    Word32 L_product;
 
240
 
 
241
    L_product = L_mult (var1, var2);
 
242
#if (WMOPS)
 
243
    multiCounter[currCounter].L_mult--;
 
244
#endif
 
245
    L_var_out = L_sub (L_var3, L_product);
 
246
#if (WMOPS)
 
247
    multiCounter[currCounter].L_sub--;
 
248
    multiCounter[currCounter].L_msu++;
 
249
#endif
 
250
    return (L_var_out);
 
251
}
 
252
/* ------------------------- End of L_msu() ------------------------- */
 
253
 
 
254
#if INCLUDE_UNSAFE
 
255
/*___________________________________________________________________________
 
256
 |                                                                           |
 
257
 |   Function Name : L_macNs                                                 |
 
258
 |                                                                           |
 
259
 |   Purpose :                                                               |
 
260
 |                                                                           |
 
261
 |   Multiply var1 by var2 and shift the result left by 1. Add the 32 bit    |
 
262
 |   result to L_var3 without saturation, return a 32 bit result. Generate   |
 
263
 |   carry and overflow values :                                             |
 
264
 |        L_macNs(L_var3,var1,var2) = L_add_c(L_var3,L_mult(var1,var2)).     |
 
265
 |                                                                           |
 
266
 |   Complexity weight : 1                                                   |
 
267
 |                                                                           |
 
268
 |   Inputs :                                                                |
 
269
 |                                                                           |
 
270
 |    L_var3   32 bit long signed integer (Word32) whose value falls in the  |
 
271
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
272
 |                                                                           |
 
273
 |    var1                                                                   |
 
274
 |             16 bit short signed integer (Word16) whose value falls in the |
 
275
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
276
 |                                                                           |
 
277
 |    var2                                                                   |
 
278
 |             16 bit short signed integer (Word16) whose value falls in the |
 
279
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
280
 |                                                                           |
 
281
 |   Outputs :                                                               |
 
282
 |                                                                           |
 
283
 |    none                                                                   |
 
284
 |                                                                           |
 
285
 |   Return Value :                                                          |
 
286
 |                                                                           |
 
287
 |    L_var_out                                                              |
 
288
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
289
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
290
 |                                                                           |
 
291
 |   Caution :                                                               |
 
292
 |                                                                           |
 
293
 |    In some cases the Carry flag has to be cleared or set before using     |
 
294
 |    operators which take into account its value.                           |
 
295
 |___________________________________________________________________________|
 
296
*/
 
297
LIBG7221_DEF(Word32) L_macNs (Word32 L_var3, Word16 var1, Word16 var2)
 
298
{
 
299
    Word32 L_var_out;
 
300
 
 
301
    L_var_out = L_mult (var1, var2);
 
302
#if (WMOPS)
 
303
    multiCounter[currCounter].L_mult--;
 
304
#endif
 
305
    L_var_out = L_add_c (L_var3, L_var_out);
 
306
#if (WMOPS)
 
307
    multiCounter[currCounter].L_add_c--;
 
308
    multiCounter[currCounter].L_macNs++;
 
309
#endif
 
310
    return (L_var_out);
 
311
}
 
312
#endif
 
313
/* ------------------------- End of L_macNs() ------------------------- */
 
314
 
 
315
#if INCLUDE_UNSAFE
 
316
/*___________________________________________________________________________
 
317
 |                                                                           |
 
318
 |   Function Name : L_msuNs                                                 |
 
319
 |                                                                           |
 
320
 |   Purpose :                                                               |
 
321
 |                                                                           |
 
322
 |   Multiply var1 by var2 and shift the result left by 1. Subtract the 32   |
 
323
 |   bit result from L_var3 without saturation, return a 32 bit result. Ge-  |
 
324
 |   nerate carry and overflow values :                                      |
 
325
 |        L_msuNs(L_var3,var1,var2) = L_sub_c(L_var3,L_mult(var1,var2)).     |
 
326
 |                                                                           |
 
327
 |   Complexity weight : 1                                                   |
 
328
 |                                                                           |
 
329
 |   Inputs :                                                                |
 
330
 |                                                                           |
 
331
 |    L_var3   32 bit long signed integer (Word32) whose value falls in the  |
 
332
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
333
 |                                                                           |
 
334
 |    var1                                                                   |
 
335
 |             16 bit short signed integer (Word16) whose value falls in the |
 
336
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
337
 |                                                                           |
 
338
 |    var2                                                                   |
 
339
 |             16 bit short signed integer (Word16) whose value falls in the |
 
340
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
341
 |                                                                           |
 
342
 |   Outputs :                                                               |
 
343
 |                                                                           |
 
344
 |    none                                                                   |
 
345
 |                                                                           |
 
346
 |   Return Value :                                                          |
 
347
 |                                                                           |
 
348
 |    L_var_out                                                              |
 
349
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
350
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
351
 |                                                                           |
 
352
 |   Caution :                                                               |
 
353
 |                                                                           |
 
354
 |    In some cases the Carry flag has to be cleared or set before using     |
 
355
 |    operators which take into account its value.                           |
 
356
 |___________________________________________________________________________|
 
357
*/
 
358
LIBG7221_DEF(Word32) L_msuNs (Word32 L_var3, Word16 var1, Word16 var2)
 
359
{
 
360
    Word32 L_var_out;
 
361
 
 
362
    L_var_out = L_mult (var1, var2);
 
363
#if (WMOPS)
 
364
    multiCounter[currCounter].L_mult--;
 
365
#endif
 
366
    L_var_out = L_sub_c (L_var3, L_var_out);
 
367
#if (WMOPS)
 
368
    multiCounter[currCounter].L_sub_c--;
 
369
    multiCounter[currCounter].L_msuNs++;
 
370
#endif
 
371
    return (L_var_out);
 
372
}
 
373
#endif
 
374
 
 
375
/* ------------------------- End of L_msuNs() ------------------------- */
 
376
 
 
377
 
 
378
#if INCLUDE_UNSAFE
 
379
/*___________________________________________________________________________
 
380
 |                                                                           |
 
381
 |   Function Name : L_add_c                                                 |
 
382
 |                                                                           |
 
383
 |   Purpose :                                                               |
 
384
 |                                                                           |
 
385
 |   Performs 32 bits addition of the two 32 bits variables (L_var1+L_var2+C)|
 
386
 |   with carry. No saturation. Generate carry and Overflow values. The car- |
 
387
 |   ry and overflow values are binary variables which can be tested and as- |
 
388
 |   signed values.                                                          |
 
389
 |                                                                           |
 
390
 |   Complexity weight : 2                                                   |
 
391
 |                                                                           |
 
392
 |   Inputs :                                                                |
 
393
 |                                                                           |
 
394
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
395
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
396
 |                                                                           |
 
397
 |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
 
398
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
399
 |                                                                           |
 
400
 |   Outputs :                                                               |
 
401
 |                                                                           |
 
402
 |    none                                                                   |
 
403
 |                                                                           |
 
404
 |   Return Value :                                                          |
 
405
 |                                                                           |
 
406
 |    L_var_out                                                              |
 
407
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
408
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
409
 |                                                                           |
 
410
 |   Caution :                                                               |
 
411
 |                                                                           |
 
412
 |    In some cases the Carry flag has to be cleared or set before using     |
 
413
 |    operators which take into account its value.                           |
 
414
 |___________________________________________________________________________|
 
415
*/
 
416
LIBG7221_DEF(Word32) L_add_c (Word32 L_var1, Word32 L_var2)
 
417
{
 
418
    Word32 L_var_out;
 
419
    Word32 L_test;
 
420
    Flag carry_int = 0;
 
421
 
 
422
    L_var_out = L_var1 + L_var2 + GET_CARRY();
 
423
 
 
424
    L_test = L_var1 + L_var2;
 
425
 
 
426
    if ((L_var1 > 0) && (L_var2 > 0) && (L_test < 0))
 
427
    {
 
428
        SET_OVERFLOW(1);
 
429
        carry_int = 0;
 
430
    }
 
431
    else
 
432
    {
 
433
        if ((L_var1 < 0) && (L_var2 < 0))
 
434
        {
 
435
            if (L_test >= 0)
 
436
            {
 
437
                SET_OVERFLOW(1);
 
438
                carry_int = 1;
 
439
            }
 
440
            else
 
441
            {
 
442
                SET_OVERFLOW(0);
 
443
                carry_int = 1;
 
444
            }
 
445
        }
 
446
        else
 
447
        {
 
448
            if (((L_var1 ^ L_var2) < 0) && (L_test >= 0))
 
449
            {
 
450
                SET_OVERFLOW(0);
 
451
                carry_int = 1;
 
452
            }
 
453
            else
 
454
            {
 
455
                SET_OVERFLOW(0);
 
456
                carry_int = 0;
 
457
            }
 
458
        }
 
459
    }
 
460
 
 
461
    if (GET_CARRY())
 
462
    {
 
463
        if (L_test == MAX_32)
 
464
        {
 
465
            SET_OVERFLOW(1);
 
466
            SET_CARRY(carry_int);
 
467
        }
 
468
        else
 
469
        {
 
470
            if (L_test == (Word32) 0xFFFFFFFFL)
 
471
            {
 
472
                SET_CARRY(1);
 
473
            }
 
474
            else
 
475
            {
 
476
                SET_CARRY(carry_int);
 
477
            }
 
478
        }
 
479
    }
 
480
    else
 
481
    {
 
482
        SET_CARRY(carry_int);
 
483
    }
 
484
 
 
485
#if (WMOPS)
 
486
    multiCounter[currCounter].L_add_c++;
 
487
#endif
 
488
    return (L_var_out);
 
489
}
 
490
#endif
 
491
 
 
492
/* ------------------------- End of L_add_c() ------------------------- */
 
493
 
 
494
#if INCLUDE_UNSAFE
 
495
/*___________________________________________________________________________
 
496
 |                                                                           |
 
497
 |   Function Name : L_sub_c                                                 |
 
498
 |                                                                           |
 
499
 |   Purpose :                                                               |
 
500
 |                                                                           |
 
501
 |   Performs 32 bits subtraction of the two 32 bits variables with carry    |
 
502
 |   (borrow) : L_var1-L_var2-C. No saturation. Generate carry and Overflow  |
 
503
 |   values. The carry and overflow values are binary variables which can    |
 
504
 |   be tested and assigned values.                                          |
 
505
 |                                                                           |
 
506
 |   Complexity weight : 2                                                   |
 
507
 |                                                                           |
 
508
 |   Inputs :                                                                |
 
509
 |                                                                           |
 
510
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
511
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
512
 |                                                                           |
 
513
 |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
 
514
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
515
 |                                                                           |
 
516
 |   Outputs :                                                               |
 
517
 |                                                                           |
 
518
 |    none                                                                   |
 
519
 |                                                                           |
 
520
 |   Return Value :                                                          |
 
521
 |                                                                           |
 
522
 |    L_var_out                                                              |
 
523
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
524
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
525
 |                                                                           |
 
526
 |   Caution :                                                               |
 
527
 |                                                                           |
 
528
 |    In some cases the Carry flag has to be cleared or set before using     |
 
529
 |    operators which take into account its value.                           |
 
530
 |___________________________________________________________________________|
 
531
*/
 
532
LIBG7221_DEF(Word32) L_sub_c (Word32 L_var1, Word32 L_var2)
 
533
{
 
534
    Word32 L_var_out;
 
535
    Word32 L_test;
 
536
    Flag carry_int = 0;
 
537
 
 
538
    if (GET_CARRY())
 
539
    {
 
540
        SET_CARRY(0);
 
541
        if (L_var2 != MIN_32)
 
542
        {
 
543
            L_var_out = L_add_c (L_var1, -L_var2);
 
544
#if (WMOPS)
 
545
            multiCounter[currCounter].L_add_c--;
 
546
#endif
 
547
        }
 
548
        else
 
549
        {
 
550
            L_var_out = L_var1 - L_var2;
 
551
            if (L_var1 > 0L)
 
552
            {
 
553
                SET_OVERFLOW(1);
 
554
                SET_CARRY(0);
 
555
            }
 
556
        }
 
557
    }
 
558
    else
 
559
    {
 
560
        L_var_out = L_var1 - L_var2 - (Word32) 0X00000001L;
 
561
        L_test = L_var1 - L_var2;
 
562
 
 
563
        if ((L_test < 0) && (L_var1 > 0) && (L_var2 < 0))
 
564
        {
 
565
            SET_OVERFLOW(1);
 
566
            carry_int = 0;
 
567
        }
 
568
        else if ((L_test > 0) && (L_var1 < 0) && (L_var2 > 0))
 
569
        {
 
570
            SET_OVERFLOW(1);
 
571
            carry_int = 1;
 
572
        }
 
573
        else if ((L_test > 0) && ((L_var1 ^ L_var2) > 0))
 
574
        {
 
575
            SET_OVERFLOW(0);
 
576
            carry_int = 1;
 
577
        }
 
578
        if (L_test == MIN_32)
 
579
        {
 
580
            SET_OVERFLOW(1);
 
581
            SET_CARRY(carry_int);
 
582
        }
 
583
        else
 
584
        {
 
585
            SET_CARRY(carry_int);
 
586
        }
 
587
    }
 
588
 
 
589
#if (WMOPS)
 
590
    multiCounter[currCounter].L_sub_c++;
 
591
#endif
 
592
    return (L_var_out);
 
593
}
 
594
#endif
 
595
/* ------------------------- End of L_sub_c() ------------------------- */
 
596
 
 
597
 
 
598
/*___________________________________________________________________________
 
599
 |                                                                           |
 
600
 |   Function Name : L_negate                                                |
 
601
 |                                                                           |
 
602
 |   Purpose :                                                               |
 
603
 |                                                                           |
 
604
 |   Negate the 32 bit variable L_var1 with saturation; saturate in the case |
 
605
 |   where input is -2147483648 (0x8000 0000).                               |
 
606
 |                                                                           |
 
607
 |   Complexity weight : 2                                                   |
 
608
 |                                                                           |
 
609
 |   Inputs :                                                                |
 
610
 |                                                                           |
 
611
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
612
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
613
 |                                                                           |
 
614
 |   Outputs :                                                               |
 
615
 |                                                                           |
 
616
 |    none                                                                   |
 
617
 |                                                                           |
 
618
 |   Return Value :                                                          |
 
619
 |                                                                           |
 
620
 |    L_var_out                                                              |
 
621
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
622
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
623
 |___________________________________________________________________________|
 
624
*/
 
625
LIBG7221_DEF(Word32) L_negate (Word32 L_var1)
 
626
{
 
627
    Word32 L_var_out;
 
628
 
 
629
    L_var_out = (L_var1 == MIN_32) ? MAX_32 : -L_var1;
 
630
#if (WMOPS)
 
631
    multiCounter[currCounter].L_negate++;
 
632
#endif
 
633
    return (L_var_out);
 
634
}
 
635
/* ------------------------- End of L_negate() ------------------------- */
 
636
 
 
637
 
 
638
/*___________________________________________________________________________
 
639
 |                                                                           |
 
640
 |   Function Name : mult_r                                                  |
 
641
 |                                                                           |
 
642
 |   Purpose :                                                               |
 
643
 |                                                                           |
 
644
 |   Same as mult with rounding, i.e.:                                       |
 
645
 |     mult_r(var1,var2) = extract_l(L_shr(((var1 * var2) + 16384),15)) and  |
 
646
 |     mult_r(-32768,-32768) = 32767.                                        |
 
647
 |                                                                           |
 
648
 |   Complexity weight : 2                                                   |
 
649
 |                                                                           |
 
650
 |   Inputs :                                                                |
 
651
 |                                                                           |
 
652
 |    var1                                                                   |
 
653
 |             16 bit short signed integer (Word16) whose value falls in the |
 
654
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
655
 |                                                                           |
 
656
 |    var2                                                                   |
 
657
 |             16 bit short signed integer (Word16) whose value falls in the |
 
658
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
659
 |                                                                           |
 
660
 |   Outputs :                                                               |
 
661
 |                                                                           |
 
662
 |    none                                                                   |
 
663
 |                                                                           |
 
664
 |   Return Value :                                                          |
 
665
 |                                                                           |
 
666
 |    var_out                                                                |
 
667
 |             16 bit short signed integer (Word16) whose value falls in the |
 
668
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
669
 |___________________________________________________________________________|
 
670
*/
 
671
LIBG7221_DEF(Word16) mult_r (Word16 var1, Word16 var2)
 
672
{
 
673
    Word16 var_out;
 
674
    Word32 L_product_arr;
 
675
 
 
676
    L_product_arr = (Word32) var1 *(Word32) var2;       /* product */
 
677
    L_product_arr += (Word32) 0x00004000L;      /* round */
 
678
    L_product_arr &= (Word32) 0xffff8000L;
 
679
    L_product_arr >>= 15;       /* shift */
 
680
 
 
681
    if (L_product_arr & (Word32) 0x00010000L)   /* sign extend when necessary */
 
682
    {
 
683
        L_product_arr |= (Word32) 0xffff0000L;
 
684
    }
 
685
    var_out = saturate (L_product_arr);
 
686
#if (WMOPS)
 
687
    multiCounter[currCounter].mult_r++;
 
688
#endif
 
689
    return (var_out);
 
690
}
 
691
/* ------------------------- End of mult_r() ------------------------- */
 
692
 
 
693
 
 
694
 
 
695
/*___________________________________________________________________________
 
696
 |                                                                           |
 
697
 |   Function Name : shr_r                                                   |
 
698
 |                                                                           |
 
699
 |   Purpose :                                                               |
 
700
 |                                                                           |
 
701
 |   Same as shr(var1,var2) but with rounding. Saturate the result in case of|
 
702
 |   underflows or overflows :                                               |
 
703
 |    - If var2 is greater than zero :                                       |
 
704
 |          if (sub(shl(shr(var1,var2),1),shr(var1,sub(var2,1))))            |
 
705
 |          is equal to zero                                                 |
 
706
 |                     then                                                  |
 
707
 |                     shr_r(var1,var2) = shr(var1,var2)                     |
 
708
 |                     else                                                  |
 
709
 |                     shr_r(var1,var2) = add(shr(var1,var2),1)              |
 
710
 |    - If var2 is less than or equal to zero :                              |
 
711
 |                     shr_r(var1,var2) = shr(var1,var2).                    |
 
712
 |                                                                           |
 
713
 |   Complexity weight : 2                                                   |
 
714
 |                                                                           |
 
715
 |   Inputs :                                                                |
 
716
 |                                                                           |
 
717
 |    var1                                                                   |
 
718
 |             16 bit short signed integer (Word16) whose value falls in the |
 
719
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
720
 |                                                                           |
 
721
 |    var2                                                                   |
 
722
 |             16 bit short signed integer (Word16) whose value falls in the |
 
723
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
724
 |                                                                           |
 
725
 |   Outputs :                                                               |
 
726
 |                                                                           |
 
727
 |    none                                                                   |
 
728
 |                                                                           |
 
729
 |   Return Value :                                                          |
 
730
 |                                                                           |
 
731
 |    var_out                                                                |
 
732
 |             16 bit short signed integer (Word16) whose value falls in the |
 
733
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
734
 |___________________________________________________________________________|
 
735
*/
 
736
LIBG7221_DEF(Word16) shr_r (Word16 var1, Word16 var2)
 
737
{
 
738
    Word16 var_out;
 
739
 
 
740
    if (var2 > 15)
 
741
    {
 
742
        var_out = 0;
 
743
    }
 
744
    else
 
745
    {
 
746
        var_out = shr (var1, var2);
 
747
#if (WMOPS)
 
748
        multiCounter[currCounter].shr--;
 
749
#endif
 
750
 
 
751
        if (var2 > 0)
 
752
        {
 
753
            if ((var1 & ((Word16) 1 << (var2 - 1))) != 0)
 
754
            {
 
755
                var_out++;
 
756
            }
 
757
        }
 
758
    }
 
759
#if (WMOPS)
 
760
    multiCounter[currCounter].shr_r++;
 
761
#endif
 
762
    return (var_out);
 
763
}
 
764
/* ------------------------- End of shr_r() ------------------------- */
 
765
 
 
766
 
 
767
/*___________________________________________________________________________
 
768
 |                                                                           |
 
769
 |   Function Name : mac_r                                                   |
 
770
 |                                                                           |
 
771
 |   Purpose :                                                               |
 
772
 |                                                                           |
 
773
 |   Multiply var1 by var2 and shift the result left by 1. Add the 32 bit    |
 
774
 |   result to L_var3 with saturation. Round the LS 16 bits of the result    |
 
775
 |   into the MS 16 bits with saturation and shift the result right by 16.   |
 
776
 |   Return a 16 bit result.                                                 |
 
777
 |            mac_r(L_var3,var1,var2) = round(L_mac(L_var3,var1,var2))       |
 
778
 |                                                                           |
 
779
 |   Complexity weight : 2                                                   |
 
780
 |                                                                           |
 
781
 |   Inputs :                                                                |
 
782
 |                                                                           |
 
783
 |    L_var3   32 bit long signed integer (Word32) whose value falls in the  |
 
784
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
785
 |                                                                           |
 
786
 |    var1                                                                   |
 
787
 |             16 bit short signed integer (Word16) whose value falls in the |
 
788
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
789
 |                                                                           |
 
790
 |    var2                                                                   |
 
791
 |             16 bit short signed integer (Word16) whose value falls in the |
 
792
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
793
 |                                                                           |
 
794
 |   Outputs :                                                               |
 
795
 |                                                                           |
 
796
 |    none                                                                   |
 
797
 |                                                                           |
 
798
 |   Return Value :                                                          |
 
799
 |                                                                           |
 
800
 |    var_out                                                                |
 
801
 |             16 bit short signed integer (Word16) whose value falls in the |
 
802
 |             range : 0x0000 8000 <= L_var_out <= 0x0000 7fff.              |
 
803
 |___________________________________________________________________________|
 
804
*/
 
805
LIBG7221_DEF(Word16) mac_r (Word32 L_var3, Word16 var1, Word16 var2)
 
806
{
 
807
    Word16 var_out;
 
808
 
 
809
    L_var3 = L_mac (L_var3, var1, var2);
 
810
#if (WMOPS)
 
811
    multiCounter[currCounter].L_mac--;
 
812
#endif
 
813
    L_var3 = L_add (L_var3, (Word32) 0x00008000L);
 
814
#if (WMOPS)
 
815
    multiCounter[currCounter].L_add--;
 
816
#endif
 
817
    var_out = extract_h (L_var3);
 
818
#if (WMOPS)
 
819
    multiCounter[currCounter].extract_h--;
 
820
    multiCounter[currCounter].mac_r++;
 
821
#endif
 
822
    return (var_out);
 
823
}
 
824
/* ------------------------- End of mac_r() ------------------------- */
 
825
 
 
826
 
 
827
/*___________________________________________________________________________
 
828
 |                                                                           |
 
829
 |   Function Name : msu_r                                                   |
 
830
 |                                                                           |
 
831
 |   Purpose :                                                               |
 
832
 |                                                                           |
 
833
 |   Multiply var1 by var2 and shift the result left by 1. Subtract the 32   |
 
834
 |   bit result to L_var3 with saturation. Round the LS 16 bits of the res-  |
 
835
 |   ult into the MS 16 bits with saturation and shift the result right by   |
 
836
 |   16. Return a 16 bit result.                                             |
 
837
 |            msu_r(L_var3,var1,var2) = round(L_msu(L_var3,var1,var2))       |
 
838
 |                                                                           |
 
839
 |   Complexity weight : 2                                                   |
 
840
 |                                                                           |
 
841
 |   Inputs :                                                                |
 
842
 |                                                                           |
 
843
 |    L_var3   32 bit long signed integer (Word32) whose value falls in the  |
 
844
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
845
 |                                                                           |
 
846
 |    var1                                                                   |
 
847
 |             16 bit short signed integer (Word16) whose value falls in the |
 
848
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
849
 |                                                                           |
 
850
 |    var2                                                                   |
 
851
 |             16 bit short signed integer (Word16) whose value falls in the |
 
852
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
853
 |                                                                           |
 
854
 |   Outputs :                                                               |
 
855
 |                                                                           |
 
856
 |    none                                                                   |
 
857
 |                                                                           |
 
858
 |   Return Value :                                                          |
 
859
 |                                                                           |
 
860
 |    var_out                                                                |
 
861
 |             16 bit short signed integer (Word16) whose value falls in the |
 
862
 |             range : 0x0000 8000 <= L_var_out <= 0x0000 7fff.              |
 
863
 |___________________________________________________________________________|
 
864
*/
 
865
LIBG7221_DEF(Word16) msu_r (Word32 L_var3, Word16 var1, Word16 var2)
 
866
{
 
867
    Word16 var_out;
 
868
 
 
869
    L_var3 = L_msu (L_var3, var1, var2);
 
870
#if (WMOPS)
 
871
    multiCounter[currCounter].L_msu--;
 
872
#endif
 
873
    L_var3 = L_add (L_var3, (Word32) 0x00008000L);
 
874
#if (WMOPS)
 
875
    multiCounter[currCounter].L_add--;
 
876
#endif
 
877
    var_out = extract_h (L_var3);
 
878
#if (WMOPS)
 
879
    multiCounter[currCounter].extract_h--;
 
880
    multiCounter[currCounter].msu_r++;
 
881
#endif
 
882
    return (var_out);
 
883
}
 
884
/* ------------------------- End of msu_r() ------------------------- */
 
885
 
 
886
 
 
887
/*___________________________________________________________________________
 
888
 |                                                                           |
 
889
 |   Function Name : L_deposit_h                                             |
 
890
 |                                                                           |
 
891
 |   Purpose :                                                               |
 
892
 |                                                                           |
 
893
 |   Deposit the 16 bit var1 into the 16 MS bits of the 32 bit output. The   |
 
894
 |   16 LS bits of the output are zeroed.                                    |
 
895
 |                                                                           |
 
896
 |   Complexity weight : 2                                                   |
 
897
 |                                                                           |
 
898
 |   Inputs :                                                                |
 
899
 |                                                                           |
 
900
 |    var1                                                                   |
 
901
 |             16 bit short signed integer (Word16) whose value falls in the |
 
902
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
903
 |                                                                           |
 
904
 |   Outputs :                                                               |
 
905
 |                                                                           |
 
906
 |    none                                                                   |
 
907
 |                                                                           |
 
908
 |   Return Value :                                                          |
 
909
 |                                                                           |
 
910
 |    L_var_out                                                              |
 
911
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
912
 |             range : 0x8000 0000 <= var_out <= 0x7fff 0000.                |
 
913
 |___________________________________________________________________________|
 
914
*/
 
915
LIBG7221_DEF(Word32) L_deposit_h (Word16 var1)
 
916
{
 
917
    Word32 L_var_out;
 
918
 
 
919
    L_var_out = (Word32) var1 << 16;
 
920
#if (WMOPS)
 
921
    multiCounter[currCounter].L_deposit_h++;
 
922
#endif
 
923
    return (L_var_out);
 
924
}
 
925
/* ------------------------- End of L_deposit_h() ------------------------- */
 
926
 
 
927
 
 
928
/*___________________________________________________________________________
 
929
 |                                                                           |
 
930
 |   Function Name : L_deposit_l                                             |
 
931
 |                                                                           |
 
932
 |   Purpose :                                                               |
 
933
 |                                                                           |
 
934
 |   Deposit the 16 bit var1 into the 16 LS bits of the 32 bit output. The   |
 
935
 |   16 MS bits of the output are sign extended.                             |
 
936
 |                                                                           |
 
937
 |   Complexity weight : 2                                                   |
 
938
 |                                                                           |
 
939
 |   Inputs :                                                                |
 
940
 |                                                                           |
 
941
 |    var1                                                                   |
 
942
 |             16 bit short signed integer (Word16) whose value falls in the |
 
943
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
944
 |                                                                           |
 
945
 |   Outputs :                                                               |
 
946
 |                                                                           |
 
947
 |    none                                                                   |
 
948
 |                                                                           |
 
949
 |   Return Value :                                                          |
 
950
 |                                                                           |
 
951
 |    L_var_out                                                              |
 
952
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
953
 |             range : 0xFFFF 8000 <= var_out <= 0x0000 7fff.                |
 
954
 |___________________________________________________________________________|
 
955
*/
 
956
LIBG7221_DEF(Word32) L_deposit_l (Word16 var1)
 
957
{
 
958
    Word32 L_var_out;
 
959
 
 
960
    L_var_out = (Word32) var1;
 
961
#if (WMOPS)
 
962
    multiCounter[currCounter].L_deposit_l++;
 
963
#endif
 
964
    return (L_var_out);
 
965
}
 
966
/* ------------------------- End of L_deposit_l() ------------------------- */
 
967
 
 
968
 
 
969
/*___________________________________________________________________________
 
970
 |                                                                           |
 
971
 |   Function Name : L_shr_r                                                 |
 
972
 |                                                                           |
 
973
 |   Purpose :                                                               |
 
974
 |                                                                           |
 
975
 |   Same as L_shr(L_var1,var2) but with rounding. Saturate the result in    |
 
976
 |   case of underflows or overflows :                                       |
 
977
 |    - If var2 is greater than zero :                                       |
 
978
 |          if (L_sub(L_shl(L_shr(L_var1,var2),1),L_shr(L_var1,sub(var2,1))))|
 
979
 |          is equal to zero                                                 |
 
980
 |                     then                                                  |
 
981
 |                     L_shr_r(L_var1,var2) = L_shr(L_var1,var2)             |
 
982
 |                     else                                                  |
 
983
 |                     L_shr_r(L_var1,var2) = L_add(L_shr(L_var1,var2),1)    |
 
984
 |    - If var2 is less than or equal to zero :                              |
 
985
 |                     L_shr_r(L_var1,var2) = L_shr(L_var1,var2).            |
 
986
 |                                                                           |
 
987
 |   Complexity weight : 3                                                   |
 
988
 |                                                                           |
 
989
 |   Inputs :                                                                |
 
990
 |                                                                           |
 
991
 |    L_var1                                                                 |
 
992
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
993
 |             range : 0x8000 0000 <= var1 <= 0x7fff ffff.                   |
 
994
 |                                                                           |
 
995
 |    var2                                                                   |
 
996
 |             16 bit short signed integer (Word16) whose value falls in the |
 
997
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
998
 |                                                                           |
 
999
 |   Outputs :                                                               |
 
1000
 |                                                                           |
 
1001
 |    none                                                                   |
 
1002
 |                                                                           |
 
1003
 |   Return Value :                                                          |
 
1004
 |                                                                           |
 
1005
 |    L_var_out                                                              |
 
1006
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
1007
 |             range : 0x8000 0000 <= var_out <= 0x7fff ffff.                |
 
1008
 |___________________________________________________________________________|
 
1009
*/
 
1010
LIBG7221_DEF(Word32) L_shr_r (Word32 L_var1, Word16 var2)
 
1011
{
 
1012
    Word32 L_var_out;
 
1013
 
 
1014
    if (var2 > 31)
 
1015
    {
 
1016
        L_var_out = 0;
 
1017
    }
 
1018
    else
 
1019
    {
 
1020
        L_var_out = L_shr (L_var1, var2);
 
1021
#if (WMOPS)
 
1022
        multiCounter[currCounter].L_shr--;
 
1023
#endif
 
1024
        if (var2 > 0)
 
1025
        {
 
1026
            if ((L_var1 & ((Word32) 1 << (var2 - 1))) != 0)
 
1027
            {
 
1028
                L_var_out++;
 
1029
            }
 
1030
        }
 
1031
    }
 
1032
#if (WMOPS)
 
1033
    multiCounter[currCounter].L_shr_r++;
 
1034
#endif
 
1035
    return (L_var_out);
 
1036
}
 
1037
/* ------------------------- End of L_shr_r() ------------------------- */
 
1038
 
 
1039
 
 
1040
/*___________________________________________________________________________
 
1041
 |                                                                           |
 
1042
 |   Function Name : L_abs                                                   |
 
1043
 |                                                                           |
 
1044
 |   Purpose :                                                               |
 
1045
 |                                                                           |
 
1046
 |    Absolute value of L_var1; Saturate in case where the input is          |
 
1047
 |                                                               -214783648  |
 
1048
 |                                                                           |
 
1049
 |   Complexity weight : 3                                                   |
 
1050
 |                                                                           |
 
1051
 |   Inputs :                                                                |
 
1052
 |                                                                           |
 
1053
 |    L_var1                                                                 |
 
1054
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
1055
 |             range : 0x8000 0000 <= var1 <= 0x7fff ffff.                   |
 
1056
 |                                                                           |
 
1057
 |   Outputs :                                                               |
 
1058
 |                                                                           |
 
1059
 |    none                                                                   |
 
1060
 |                                                                           |
 
1061
 |   Return Value :                                                          |
 
1062
 |                                                                           |
 
1063
 |    L_var_out                                                              |
 
1064
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
1065
 |             range : 0x0000 0000 <= var_out <= 0x7fff ffff.                |
 
1066
 |___________________________________________________________________________|
 
1067
*/
 
1068
LIBG7221_DEF(Word32) L_abs (Word32 L_var1)
 
1069
{
 
1070
    Word32 L_var_out;
 
1071
 
 
1072
    if (L_var1 == MIN_32)
 
1073
    {
 
1074
        L_var_out = MAX_32;
 
1075
    }
 
1076
    else
 
1077
    {
 
1078
        if (L_var1 < 0)
 
1079
        {
 
1080
            L_var_out = -L_var1;
 
1081
        }
 
1082
        else
 
1083
        {
 
1084
            L_var_out = L_var1;
 
1085
        }
 
1086
    }
 
1087
 
 
1088
#if (WMOPS)
 
1089
    multiCounter[currCounter].L_abs++;
 
1090
#endif
 
1091
    return (L_var_out);
 
1092
}
 
1093
/* ------------------------- End of L_abs() ------------------------- */
 
1094
 
 
1095
 
 
1096
/*___________________________________________________________________________
 
1097
 |                                                                           |
 
1098
 |   Function Name : norm_s                                                  |
 
1099
 |                                                                           |
 
1100
 |   Purpose :                                                               |
 
1101
 |                                                                           |
 
1102
 |   Produces the number of left shift needed to normalize the 16 bit varia- |
 
1103
 |   ble var1 for positive values on the interval with minimum of 16384 and  |
 
1104
 |   maximum of 32767, and for negative values on the interval with minimum  |
 
1105
 |   of -32768 and maximum of -16384; in order to normalize the result, the  |
 
1106
 |   following operation must be done :                                      |
 
1107
 |                    norm_var1 = shl(var1,norm_s(var1)).                    |
 
1108
 |                                                                           |
 
1109
 |   Complexity weight : 15                                                  |
 
1110
 |                                                                           |
 
1111
 |   Inputs :                                                                |
 
1112
 |                                                                           |
 
1113
 |    var1                                                                   |
 
1114
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1115
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
1116
 |                                                                           |
 
1117
 |   Outputs :                                                               |
 
1118
 |                                                                           |
 
1119
 |    none                                                                   |
 
1120
 |                                                                           |
 
1121
 |   Return Value :                                                          |
 
1122
 |                                                                           |
 
1123
 |    var_out                                                                |
 
1124
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1125
 |             range : 0x0000 0000 <= var_out <= 0x0000 000f.                |
 
1126
 |___________________________________________________________________________|
 
1127
*/
 
1128
LIBG7221_DEF(Word16) norm_s (Word16 var1)
 
1129
{
 
1130
    Word16 var_out;
 
1131
 
 
1132
    if (var1 == 0)
 
1133
    {
 
1134
        var_out = 0;
 
1135
    }
 
1136
    else
 
1137
    {
 
1138
        if ((UWord16)var1 == (UWord16)0xffff)
 
1139
        {
 
1140
            var_out = 15;
 
1141
        }
 
1142
        else
 
1143
        {
 
1144
            if (var1 < 0)
 
1145
            {
 
1146
                var1 = (Word16)(~var1);
 
1147
            }
 
1148
            for (var_out = 0; var1 < 0x4000; var_out++)
 
1149
            {
 
1150
                var1 <<= 1;
 
1151
            }
 
1152
        }
 
1153
    }
 
1154
 
 
1155
#if (WMOPS)
 
1156
    multiCounter[currCounter].norm_s++;
 
1157
#endif
 
1158
    return (var_out);
 
1159
}
 
1160
/* ------------------------- End of norm_s() ------------------------- */
 
1161
 
 
1162
 
 
1163
/*___________________________________________________________________________
 
1164
 |                                                                           |
 
1165
 |   Function Name : div_s                                                   |
 
1166
 |                                                                           |
 
1167
 |   Purpose :                                                               |
 
1168
 |                                                                           |
 
1169
 |   Produces a result which is the fractional integer division of var1  by  |
 
1170
 |   var2; var1 and var2 must be positive and var2 must be greater or equal  |
 
1171
 |   to var1; the result is positive (leading bit equal to 0) and truncated  |
 
1172
 |   to 16 bits.                                                             |
 
1173
 |   If var1 = var2 then div(var1,var2) = 32767.                             |
 
1174
 |                                                                           |
 
1175
 |   Complexity weight : 18                                                  |
 
1176
 |                                                                           |
 
1177
 |   Inputs :                                                                |
 
1178
 |                                                                           |
 
1179
 |    var1                                                                   |
 
1180
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1181
 |             range : 0x0000 0000 <= var1 <= var2 and var2 != 0.            |
 
1182
 |                                                                           |
 
1183
 |    var2                                                                   |
 
1184
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1185
 |             range : var1 <= var2 <= 0x0000 7fff and var2 != 0.            |
 
1186
 |                                                                           |
 
1187
 |   Outputs :                                                               |
 
1188
 |                                                                           |
 
1189
 |    none                                                                   |
 
1190
 |                                                                           |
 
1191
 |   Return Value :                                                          |
 
1192
 |                                                                           |
 
1193
 |    var_out                                                                |
 
1194
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1195
 |             range : 0x0000 0000 <= var_out <= 0x0000 7fff.                |
 
1196
 |             It's a Q15 value (point between b15 and b14).                 |
 
1197
 |___________________________________________________________________________|
 
1198
*/
 
1199
LIBG7221_DEF(Word16) div_s (Word16 var1, Word16 var2)
 
1200
{
 
1201
    Word16 var_out = 0;
 
1202
    Word16 iteration;
 
1203
    Word32 L_num;
 
1204
    Word32 L_denom;
 
1205
 
 
1206
    if ((var1 > var2) || (var1 < 0) || (var2 < 0))
 
1207
    {
 
1208
        //printf ("Division Error var1=%d  var2=%d\n", var1, var2);
 
1209
        //abort(); /* exit (0); */
 
1210
        pj_assert(!"Division Error");
 
1211
    }
 
1212
    if (var2 == 0)
 
1213
    {
 
1214
        //printf ("Division by 0, Fatal error \n");
 
1215
        //abort(); /* exit (0); */
 
1216
        assert(!"Division by 0");
 
1217
    }
 
1218
    if (var1 == 0)
 
1219
    {
 
1220
        var_out = 0;
 
1221
    }
 
1222
    else
 
1223
    {
 
1224
        if (var1 == var2)
 
1225
        {
 
1226
            var_out = MAX_16;
 
1227
        }
 
1228
        else
 
1229
        {
 
1230
            L_num = L_deposit_l (var1);
 
1231
#if (WMOPS)
 
1232
            multiCounter[currCounter].L_deposit_l--;
 
1233
#endif
 
1234
            L_denom = L_deposit_l (var2);
 
1235
#if (WMOPS)
 
1236
            multiCounter[currCounter].L_deposit_l--;
 
1237
#endif
 
1238
 
 
1239
            for (iteration = 0; iteration < 15; iteration++)
 
1240
            {
 
1241
                var_out <<= 1;
 
1242
                L_num <<= 1;
 
1243
 
 
1244
                if (L_num >= L_denom)
 
1245
                {
 
1246
                    L_num = L_sub (L_num, L_denom);
 
1247
#if (WMOPS)
 
1248
                    multiCounter[currCounter].L_sub--;
 
1249
#endif
 
1250
                    var_out = add (var_out, 1);
 
1251
#if (WMOPS)
 
1252
                    multiCounter[currCounter].add--;
 
1253
#endif
 
1254
                }
 
1255
            }
 
1256
        }
 
1257
    }
 
1258
 
 
1259
#if (WMOPS)
 
1260
    multiCounter[currCounter].div_s++;
 
1261
#endif
 
1262
    return (var_out);
 
1263
}
 
1264
/* ------------------------- End of div_s() ------------------------- */
 
1265
 
 
1266
 
 
1267
/*___________________________________________________________________________
 
1268
 |                                                                           |
 
1269
 |   Function Name : norm_l                                                  |
 
1270
 |                                                                           |
 
1271
 |   Purpose :                                                               |
 
1272
 |                                                                           |
 
1273
 |   Produces the number of left shifts needed to normalize the 32 bit varia-|
 
1274
 |   ble L_var1 for positive values on the interval with minimum of          |
 
1275
 |   1073741824 and maximum of 2147483647, and for negative values on the in-|
 
1276
 |   terval with minimum of -2147483648 and maximum of -1073741824; in order |
 
1277
 |   to normalize the result, the following operation must be done :         |
 
1278
 |                   norm_L_var1 = L_shl(L_var1,norm_l(L_var1)).             |
 
1279
 |                                                                           |
 
1280
 |   Complexity weight : 30                                                  |
 
1281
 |                                                                           |
 
1282
 |   Inputs :                                                                |
 
1283
 |                                                                           |
 
1284
 |    L_var1                                                                 |
 
1285
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
1286
 |             range : 0x8000 0000 <= var1 <= 0x7fff ffff.                   |
 
1287
 |                                                                           |
 
1288
 |   Outputs :                                                               |
 
1289
 |                                                                           |
 
1290
 |    none                                                                   |
 
1291
 |                                                                           |
 
1292
 |   Return Value :                                                          |
 
1293
 |                                                                           |
 
1294
 |    var_out                                                                |
 
1295
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1296
 |             range : 0x0000 0000 <= var_out <= 0x0000 001f.                |
 
1297
 |___________________________________________________________________________|
 
1298
*/
 
1299
LIBG7221_DEF(Word16) norm_l (Word32 L_var1)
 
1300
{
 
1301
    Word16 var_out;
 
1302
 
 
1303
    if (L_var1 == 0)
 
1304
    {
 
1305
        var_out = 0;
 
1306
    }
 
1307
    else
 
1308
    {
 
1309
        if (L_var1 == (Word32) 0xffffffffL)
 
1310
        {
 
1311
            var_out = 31;
 
1312
        }
 
1313
        else
 
1314
        {
 
1315
            if (L_var1 < 0)
 
1316
            {
 
1317
                L_var1 = ~L_var1;
 
1318
            }
 
1319
            for (var_out = 0; L_var1 < (Word32) 0x40000000L; var_out++)
 
1320
            {
 
1321
                L_var1 <<= 1;
 
1322
            }
 
1323
        }
 
1324
    }
 
1325
 
 
1326
#if (WMOPS)
 
1327
    multiCounter[currCounter].norm_l++;
 
1328
#endif
 
1329
    return (var_out);
 
1330
}
 
1331
/* ------------------------- End of norm_l() ------------------------- */
 
1332
 
 
1333
 
 
1334
/*
 
1335
  *****************************************************************
 
1336
   Additional operators extracted from the G.723.1 Library
 
1337
   Adapted for WMOPS calculations
 
1338
  *****************************************************************
 
1339
*/
 
1340
 
 
1341
/*___________________________________________________________________________
 
1342
 |                                                                           |
 
1343
 |   Function Name : L_mls                                                   |
 
1344
 |                                                                           |
 
1345
 |   Purpose :                                                               |
 
1346
 |                                                                           |
 
1347
 |   Multiplies a 16 bit word v by a 32 bit word Lv and returns a 32 bit     |
 
1348
 |   word (multiplying 16 by 32 bit words gives 48 bit word; the function    |
 
1349
 |   extracts the 32 MSB and shift the result to the left by 1).             |
 
1350
 |                                                                           |
 
1351
 |   A 32 bit word can be written as                                         |
 
1352
 |    Lv = a  +  b * 2^16                                                    |
 
1353
 |   where a= unsigned 16 LSBs and b= signed 16 MSBs.                        |
 
1354
 |   The function returns v * Lv  /  2^15  which is equivalent to            |
 
1355
 |        a*v / 2^15 + b*v*2                                                 |
 
1356
 |                                                                           |
 
1357
 |   Complexity weight : 6 [to be confirmed]                                 |
 
1358
 |                                                                           |
 
1359
 |   Inputs :                                                                |
 
1360
 |                                                                           |
 
1361
 |   Lv                                                                      |
 
1362
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
1363
 |             range : 0x8000 0000 <= var1 <= 0x7fff ffff.                   |
 
1364
 |   v                                                                       |
 
1365
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1366
 |             range : 0x8000 <= var1 <= 0x7fff.                             |
 
1367
 |                                                                           |
 
1368
 |   Outputs :                                                               |
 
1369
 |                                                                           |
 
1370
 |    none                                                                   |
 
1371
 |                                                                           |
 
1372
 |   Return Value :                                                          |
 
1373
 |                                                                           |
 
1374
 |    var_out                                                                |
 
1375
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
1376
 |             range : 0x8000 0000 <= var_out <= 0x7fff ffff.                |
 
1377
 |                                                                           |
 
1378
 |___________________________________________________________________________|
 
1379
*/
 
1380
LIBG7221_DEF(Word32) L_mls (Word32 Lv, Word16 v)
 
1381
{
 
1382
   Word32   Temp  ;
 
1383
 
 
1384
   Temp = Lv & (Word32) 0x0000ffff ;
 
1385
   Temp = Temp * (Word32) v ;
 
1386
   Temp = L_shr_nocheck( Temp, (Word16) 15 ) ;
 
1387
   Temp = L_mac( Temp, v, extract_h(Lv) ) ;
 
1388
 
 
1389
#if (WMOPS)
 
1390
   multiCounter[currCounter].L_shr--;
 
1391
   multiCounter[currCounter].L_mac--;
 
1392
   multiCounter[currCounter].extract_h--;
 
1393
   multiCounter[currCounter].L_mls++;
 
1394
#endif
 
1395
 
 
1396
   return Temp ;
 
1397
}
 
1398
/* ------------------------- End of L_mls() ------------------------- */
 
1399
 
 
1400
 
 
1401
/*__________________________________________________________________________
 
1402
|                                                                           |
 
1403
|   Function Name : div_l                                                   |
 
1404
|                                                                           |
 
1405
|   Purpose :                                                               |
 
1406
|                                                                           |
 
1407
|   Produces a result which is the fractional integer division of L_var1 by|
 
1408
|   var2; L_var1 and var2 must be positive and var2 << 16 must be greater or|
 
1409
|   equal to L_var1; the result is positive (leading bit equal to 0) and    |
 
1410
|   truncated to 16 bits.                                                   |
 
1411
|   If L_var1 == var2 << 16 then div_l(L_var1,var2) = 32767.                |
 
1412
|                                                                           |
 
1413
|   Complexity weight : 20                                                  |
 
1414
|                                                                           |
 
1415
|   Inputs :                                                                |
 
1416
|                                                                           |
 
1417
|    L_var1                                                                 |
 
1418
|             32 bit long signed integer (Word32) whose value falls in the  |
 
1419
|             range : 0x0000 0000 <= var1 <= (var2 << 16)  and var2 != 0.   |
 
1420
|             L_var1 must be considered as a Q.31 value                     |
 
1421
|                                                                           |
 
1422
|    var2                                                                   |
 
1423
|             16 bit short signed integer (Word16) whose value falls in the |
 
1424
|             range : var1 <= (var2<< 16) <= 0x7fff0000 and var2 != 0.      |
 
1425
|             var2 must be considered as a Q.15 value                       |
 
1426
|                                                                           |
 
1427
|   Outputs :                                                               |
 
1428
|                                                                           |
 
1429
|    none                                                                   |
 
1430
|                                                                           |
 
1431
|   Return Value :                                                          |
 
1432
|                                                                           |
 
1433
|    var_out                                                                |
 
1434
|             16 bit short signed integer (Word16) whose value falls in the |
 
1435
|             range : 0x0000 0000 <= var_out <= 0x0000 7fff.                |
 
1436
|             It's a Q15 value (point between b15 and b14).                 |
 
1437
|___________________________________________________________________________|
 
1438
*/
 
1439
LIBG7221_DEF(Word16) div_l (Word32  L_num, Word16 den)
 
1440
{
 
1441
    Word16   var_out = (Word16)0;
 
1442
    Word32   L_den;
 
1443
    Word16   iteration;
 
1444
 
 
1445
#if (WMOPS)
 
1446
    multiCounter[currCounter].div_l++;
 
1447
#endif
 
1448
 
 
1449
    if ( den == (Word16) 0 ) {
 
1450
        //printf("Division by 0 in div_l, Fatal error \n");
 
1451
        //exit(0);
 
1452
        assert(!"Division by 0");
 
1453
    }
 
1454
 
 
1455
    if ( (L_num < (Word32) 0) || (den < (Word16) 0) ) {
 
1456
        //printf("Division Error in div_l, Fatal error \n");
 
1457
        //exit(0);
 
1458
        assert(!"Division Error");
 
1459
    }
 
1460
 
 
1461
    L_den = L_deposit_h( den ) ;
 
1462
#if (WMOPS)
 
1463
    multiCounter[currCounter].L_deposit_h--;
 
1464
#endif
 
1465
 
 
1466
    if ( L_num >= L_den ){
 
1467
        return MAX_16 ;
 
1468
    }
 
1469
    else {
 
1470
        L_num = L_shr_nocheck(L_num, (Word16)1) ;
 
1471
        L_den = L_shr_nocheck(L_den, (Word16)1);
 
1472
#if (WMOPS)
 
1473
        multiCounter[currCounter].L_shr-=2;
 
1474
#endif
 
1475
        for(iteration=(Word16)0; iteration< (Word16)15;iteration++) {
 
1476
            var_out = shl_nocheck( var_out, (Word16)1);
 
1477
            L_num   = L_shl_nocheck( L_num, (Word16)1);
 
1478
#if (WMOPS)
 
1479
            multiCounter[currCounter].shl--;
 
1480
            multiCounter[currCounter].L_shl--;
 
1481
#endif
 
1482
            if (L_num >= L_den) {
 
1483
                L_num = L_sub(L_num,L_den);
 
1484
                var_out = add(var_out, (Word16)1);
 
1485
#if (WMOPS)
 
1486
            multiCounter[currCounter].L_sub--;
 
1487
            multiCounter[currCounter].add--;
 
1488
#endif
 
1489
            }
 
1490
        }
 
1491
 
 
1492
        return var_out;
 
1493
    }
 
1494
}
 
1495
/* ------------------------- End of div_l() ------------------------- */
 
1496
 
 
1497
 
 
1498
/*__________________________________________________________________________
 
1499
|                                                                           |
 
1500
|   Function Name : i_mult                                                  |
 
1501
|                                                                           |
 
1502
|   Purpose :                                                               |
 
1503
|                                                                           |
 
1504
|   Integer 16-bit multiplication. No overflow protection is performed if   |
 
1505
|   ORIGINAL_G7231 is defined.                                              |
 
1506
|                                                                           |
 
1507
|   Complexity weight : TBD                                                 |
 
1508
|                                                                           |
 
1509
|   Inputs :                                                                |
 
1510
|                                                                           |
 
1511
|    a                                                                      |
 
1512
|             16 bit short signed integer (Word16).                         |
 
1513
|                                                                           |
 
1514
|    b                                                                      |
 
1515
|             16 bit short signed integer (Word16).                         |
 
1516
|                                                                           |
 
1517
|   Outputs :                                                               |
 
1518
|                                                                           |
 
1519
|    none                                                                   |
 
1520
|                                                                           |
 
1521
|   Return Value :                                                          |
 
1522
|                                                                           |
 
1523
|             16 bit short signed integer (Word16). No overflow checks      |
 
1524
|             are performed if ORIGINAL_G7231 is defined.                   |
 
1525
|___________________________________________________________________________|
 
1526
*/
 
1527
LIBG7221_DEF(Word16) i_mult (Word16 a, Word16 b)
 
1528
{
 
1529
#ifdef ORIGINAL_G7231
 
1530
   return a*b ;
 
1531
#else
 
1532
   Word32 register c=a*b;
 
1533
#if (WMOPS)
 
1534
    multiCounter[currCounter].i_mult++;
 
1535
#endif
 
1536
   return saturate(c) ;
 
1537
#endif
 
1538
}
 
1539
/* ------------------------- End of i_mult() ------------------------- */
 
1540
 
 
1541
 
 
1542
/*
 
1543
   ********************************************************************** 
 
1544
   The following three operators are not part of the original 
 
1545
   G.729/G.723.1 set of basic operators and implement shiftless
 
1546
   accumulation operation.
 
1547
   ********************************************************************** 
 
1548
*/
 
1549
 
 
1550
/*___________________________________________________________________________
 
1551
 |
 
1552
 |   Function Name : L_mult0
 
1553
 |
 
1554
 |   Purpose :
 
1555
 |
 
1556
 |   L_mult0 is the 32 bit result of the multiplication of var1 times var2
 
1557
 |   without one left shift.
 
1558
 |
 
1559
 |   Complexity weight : 1
 
1560
 |
 
1561
 |   Inputs :
 
1562
 |
 
1563
 |    var1     16 bit short signed integer (Word16) whose value falls in the
 
1564
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 
1565
 |
 
1566
 |    var2     16 bit short signed integer (Word16) whose value falls in the
 
1567
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 
1568
 |
 
1569
 |   Return Value :
 
1570
 |
 
1571
 |    L_var_out
 
1572
 |             32 bit long signed integer (Word32) whose value falls in the
 
1573
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
 
1574
 |___________________________________________________________________________
 
1575
*/
 
1576
LIBG7221_DEF(Word32) L_mult0 (Word16 var1,Word16 var2)
 
1577
{
 
1578
  Word32 L_var_out;
 
1579
 
 
1580
  L_var_out = (Word32)var1 * (Word32)var2;
 
1581
 
 
1582
#if (WMOPS)
 
1583
    multiCounter[currCounter].L_mult0++;
 
1584
#endif
 
1585
  return(L_var_out);
 
1586
}
 
1587
/* ------------------------- End of L_mult0() ------------------------- */
 
1588
 
 
1589
 
 
1590
/*___________________________________________________________________________
 
1591
 |
 
1592
 |   Function Name : L_mac0
 
1593
 |
 
1594
 |   Purpose :
 
1595
 |
 
1596
 |   Multiply var1 by var2 (without left shift) and add the 32 bit result to
 
1597
 |   L_var3 with saturation, return a 32 bit result:
 
1598
 |        L_mac0(L_var3,var1,var2) = L_add(L_var3,(L_mult0(var1,var2)).
 
1599
 |
 
1600
 |   Complexity weight : 1
 
1601
 |
 
1602
 |   Inputs :
 
1603
 |
 
1604
 |    L_var3   32 bit long signed integer (Word32) whose value falls in the
 
1605
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
 
1606
 |
 
1607
 |    var1     16 bit short signed integer (Word16) whose value falls in the
 
1608
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 
1609
 |
 
1610
 |    var2     16 bit short signed integer (Word16) whose value falls in the
 
1611
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 
1612
 |
 
1613
 |   Return Value :
 
1614
 |
 
1615
 |    L_var_out
 
1616
 |             32 bit long signed integer (Word32) whose value falls in the
 
1617
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
 
1618
 |___________________________________________________________________________
 
1619
*/
 
1620
LIBG7221_DEF(Word32) L_mac0 (Word32 L_var3, Word16 var1, Word16 var2)
 
1621
{
 
1622
  Word32 L_var_out;
 
1623
  Word32 L_product;
 
1624
 
 
1625
  L_product = L_mult0(var1,var2);
 
1626
  L_var_out = L_add(L_var3,L_product);
 
1627
 
 
1628
#if (WMOPS)
 
1629
    multiCounter[currCounter].L_mac0++;
 
1630
    multiCounter[currCounter].L_mult0--;
 
1631
    multiCounter[currCounter].L_add--;
 
1632
#endif
 
1633
  return(L_var_out);
 
1634
}
 
1635
/* ------------------------- End of L_mac0() ------------------------- */
 
1636
 
 
1637
 
 
1638
/*___________________________________________________________________________
 
1639
 |
 
1640
 |   Function Name : L_msu0
 
1641
 |
 
1642
 |   Purpose :
 
1643
 |
 
1644
 |   Multiply var1 by var2 (without left shift) and subtract the 32 bit
 
1645
 |   result to L_var3 with saturation, return a 32 bit result:
 
1646
 |        L_msu0(L_var3,var1,var2) = L_sub(L_var3,(L_mult0(var1,var2)).
 
1647
 |
 
1648
 |   Complexity weight : 1
 
1649
 |
 
1650
 |   Inputs :
 
1651
 |
 
1652
 |    L_var3   32 bit long signed integer (Word32) whose value falls in the
 
1653
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
 
1654
 |
 
1655
 |    var1     16 bit short signed integer (Word16) whose value falls in the
 
1656
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 
1657
 |
 
1658
 |    var2     16 bit short signed integer (Word16) whose value falls in the
 
1659
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 
1660
 |
 
1661
 |   Return Value :
 
1662
 |
 
1663
 |    L_var_out
 
1664
 |             32 bit long signed integer (Word32) whose value falls in the
 
1665
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
 
1666
 |___________________________________________________________________________
 
1667
*/
 
1668
LIBG7221_DEF(Word32) L_msu0 (Word32 L_var3, Word16 var1, Word16 var2)
 
1669
{
 
1670
  Word32 L_var_out;
 
1671
  Word32 L_product;
 
1672
 
 
1673
  L_product = L_mult0(var1,var2);
 
1674
  L_var_out = L_sub(L_var3,L_product);
 
1675
 
 
1676
#if (WMOPS)
 
1677
    multiCounter[currCounter].L_msu0++;
 
1678
    multiCounter[currCounter].L_mult0--;
 
1679
    multiCounter[currCounter].L_sub--;
 
1680
#endif
 
1681
  return(L_var_out);
 
1682
}
 
1683
/* ------------------------- End of L_msu0() ------------------------- */
 
1684
 
 
1685
 
 
1686
/*___________________________________________________________________________
 
1687
 |                                                                           |
 
1688
 |   Function Name : LU_shl                                                  |
 
1689
 |                                                                           |
 
1690
 |   Purpose :                                                               |
 
1691
 |                                                                           |
 
1692
 |   Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero  |
 
1693
 |   fill the var2 LSB of the result. If var2 is negative, arithmetically    |
 
1694
 |   shift L_var1 right by -var2 with sign extension. Saturate the result in |
 
1695
 |   case of underflows or overflows.                                        |
 
1696
 |                                                                           |
 
1697
 |   Complexity weight : 2                                                   |
 
1698
 |                                                                           |
 
1699
 |   Inputs :                                                                |
 
1700
 |                                                                           |
 
1701
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
1702
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
1703
 |                                                                           |
 
1704
 |    var2                                                                   |
 
1705
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1706
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
1707
 |                                                                           |
 
1708
 |   Outputs :                                                               |
 
1709
 |                                                                           |
 
1710
 |    none                                                                   |
 
1711
 |                                                                           |
 
1712
 |   Return Value :                                                          |
 
1713
 |                                                                           |
 
1714
 |    L_var_out                                                              |
 
1715
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
1716
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
1717
 |___________________________________________________________________________|
 
1718
*/
 
1719
LIBG7221_DEF(UWord32) LU_shl (UWord32 L_var1, Word16 var2)
 
1720
{
 
1721
    Word16 neg_var2;
 
1722
    UWord32 L_var_out = 0;
 
1723
 
 
1724
    if (var2 <= 0)
 
1725
    {
 
1726
        if (var2 < -32)
 
1727
            var2 = -32;
 
1728
        neg_var2 = negate(var2);
 
1729
        L_var_out = LU_shr (L_var1, neg_var2);
 
1730
#if (WMOPS)
 
1731
        multiCounter[currCounter].negate--;
 
1732
        multiCounter[currCounter].LU_shr--;
 
1733
#endif
 
1734
    }
 
1735
    else
 
1736
    {
 
1737
        for (; var2 > 0; var2--)
 
1738
        {
 
1739
            if (L_var1 > (UWord32) 0X7fffffffL)
 
1740
            {
 
1741
                SET_OVERFLOW(1);
 
1742
                L_var_out = UMAX_32;
 
1743
                break;
 
1744
            }
 
1745
            else
 
1746
            {
 
1747
                if (L_var1 < (UWord32) 0x00000001L)
 
1748
                {
 
1749
                    SET_OVERFLOW(1);
 
1750
                    L_var_out = (UWord32)MIN_32;
 
1751
                    break;
 
1752
                }
 
1753
            }
 
1754
            L_var1 *= 2;
 
1755
            L_var_out = L_var1;
 
1756
        }
 
1757
    }
 
1758
#if (WMOPS)
 
1759
    multiCounter[currCounter].LU_shl++;
 
1760
#endif
 
1761
    return (L_var_out);
 
1762
}
 
1763
/* ------------------------- End of LU_shl() ------------------------- */
 
1764
 
 
1765
 
 
1766
/*___________________________________________________________________________
 
1767
 |                                                                           |
 
1768
 |   Function Name : LU_shr                                                  |
 
1769
 |                                                                           |
 
1770
 |   Purpose :                                                               |
 
1771
 |                                                                           |
 
1772
 |   Arithmetically shift the 32 bit input L_var1 right var2 positions with  |
 
1773
 |   sign extension. If var2 is negative, arithmetically shift L_var1 left   |
 
1774
 |   by -var2 and zero fill the -var2 LSB of the result. Saturate the result |
 
1775
 |   in case of underflows or overflows.                                     |
 
1776
 |                                                                           |
 
1777
 |   Complexity weight : 2                                                   |
 
1778
 |                                                                           |
 
1779
 |   Inputs :                                                                |
 
1780
 |                                                                           |
 
1781
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
1782
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
1783
 |                                                                           |
 
1784
 |    var2                                                                   |
 
1785
 |             16 bit short signed integer (Word16) whose value falls in the |
 
1786
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
1787
 |                                                                           |
 
1788
 |   Outputs :                                                               |
 
1789
 |                                                                           |
 
1790
 |    none                                                                   |
 
1791
 |                                                                           |
 
1792
 |   Return Value :                                                          |
 
1793
 |                                                                           |
 
1794
 |    L_var_out                                                              |
 
1795
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
1796
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
1797
 |___________________________________________________________________________|
 
1798
*/
 
1799
LIBG7221_DEF(UWord32) LU_shr (UWord32 L_var1, Word16 var2)
 
1800
{
 
1801
    Word16  neg_var2;
 
1802
    UWord32 L_var_out;
 
1803
 
 
1804
    if (var2 < 0)
 
1805
    {
 
1806
        if (var2 < -32)
 
1807
            var2 = -32;
 
1808
        neg_var2 = negate(var2);
 
1809
        L_var_out = LU_shl (L_var1, neg_var2);
 
1810
#if (WMOPS)
 
1811
        multiCounter[currCounter].negate--;
 
1812
        multiCounter[currCounter].LU_shl--;
 
1813
#endif
 
1814
    }
 
1815
    else
 
1816
    {
 
1817
        if (var2 >= 32)
 
1818
        {
 
1819
            L_var_out = 0L;
 
1820
        }
 
1821
        else
 
1822
        {
 
1823
            L_var_out = L_var1 >> var2;
 
1824
        }
 
1825
    }
 
1826
#if (WMOPS)
 
1827
    multiCounter[currCounter].LU_shr++;
 
1828
#endif
 
1829
    return (L_var_out);
 
1830
}
 
1831
/* ------------------------- End of LU_shr() ------------------------- */
 
1832
 
 
1833
#endif /* PJMEDIA_LIBG7221_FUNCS_INLINED */
 
1834
 
 
1835
/* ************************** END OF BASOP32.C ************************** */