← Back to branch summary

~noskcaj/ubuntu/saucy/sflphone/merge-1.2.3-2

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/third_party/g7221/common/basic_op_i.h

  • Committer: Jackson Doak
  • Date: 2013-07-10 21:04:46 UTC
  • mfrom: (20.1.3 sid)
  • Revision ID: noskcaj@ubuntu.com-20130710210446-y8f587vza807icr9
https://launchpad.net/bugs/1196978
Properly merged from upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/third_party/g7221/common/basic_op_i.h
 
1
/*___________________________________________________________________________
 
2
 |                                                                           |
 
3
 |   Function Name : extract_h                                               |
 
4
 |                                                                           |
 
5
 |   Purpose :                                                               |
 
6
 |                                                                           |
 
7
 |   Return the 16 MSB of L_var1.                                            |
 
8
 |                                                                           |
 
9
 |   Complexity weight : 1                                                   |
 
10
 |                                                                           |
 
11
 |   Inputs :                                                                |
 
12
 |                                                                           |
 
13
 |    L_var1                                                                 |
 
14
 |             32 bit long signed integer (Word32 ) whose value falls in the |
 
15
 |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
 
16
 |                                                                           |
 
17
 |   Outputs :                                                               |
 
18
 |                                                                           |
 
19
 |    none                                                                   |
 
20
 |                                                                           |
 
21
 |   Return Value :                                                          |
 
22
 |                                                                           |
 
23
 |    var_out                                                                |
 
24
 |             16 bit short signed integer (Word16) whose value falls in the |
 
25
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
26
 |___________________________________________________________________________|
 
27
*/
 
28
PJ_INLINE(Word16) extract_h (Word32 L_var1)
 
29
{
 
30
    return (Word16) (L_var1 >> 16);
 
31
}
 
32
/* ------------------------- End of extract_h() ------------------------- */
 
33
 
 
34
 
 
35
/*___________________________________________________________________________
 
36
 |                                                                           |
 
37
 |   Function Name : extract_l                                               |
 
38
 |                                                                           |
 
39
 |   Purpose :                                                               |
 
40
 |                                                                           |
 
41
 |   Return the 16 LSB of L_var1.                                            |
 
42
 |                                                                           |
 
43
 |   Complexity weight : 1                                                   |
 
44
 |                                                                           |
 
45
 |   Inputs :                                                                |
 
46
 |                                                                           |
 
47
 |    L_var1                                                                 |
 
48
 |             32 bit long signed integer (Word32 ) whose value falls in the |
 
49
 |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
 
50
 |                                                                           |
 
51
 |   Outputs :                                                               |
 
52
 |                                                                           |
 
53
 |    none                                                                   |
 
54
 |                                                                           |
 
55
 |   Return Value :                                                          |
 
56
 |                                                                           |
 
57
 |    var_out                                                                |
 
58
 |             16 bit short signed integer (Word16) whose value falls in the |
 
59
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
60
 |___________________________________________________________________________|
 
61
*/
 
62
PJ_INLINE(Word16) extract_l (Word32 L_var1)
 
63
{
 
64
    return (Word16) L_var1;
 
65
}
 
66
 
 
67
/* ------------------------- End of extract_l() ------------------------- */
 
68
 
 
69
 
 
70
/*___________________________________________________________________________
 
71
 |                                                                           |
 
72
 |   Function Name : saturate                                                |
 
73
 |                                                                           |
 
74
 |   Purpose :                                                               |
 
75
 |                                                                           |
 
76
 |    Limit the 32 bit input to the range of a 16 bit word.                  |
 
77
 |                                                                           |
 
78
 |   Inputs :                                                                |
 
79
 |                                                                           |
 
80
 |    L_var1                                                                 |
 
81
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
82
 |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
 
83
 |                                                                           |
 
84
 |   Outputs :                                                               |
 
85
 |                                                                           |
 
86
 |    none                                                                   |
 
87
 |                                                                           |
 
88
 |   Return Value :                                                          |
 
89
 |                                                                           |
 
90
 |    var_out                                                                |
 
91
 |             16 bit short signed integer (Word16) whose value falls in the |
 
92
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
93
 |___________________________________________________________________________|
 
94
*/
 
95
PJ_INLINE(Word16) saturate (Word32 L_var1)
 
96
{
 
97
    Word16 val16 = (Word16) L_var1;
 
98
 
 
99
    if (val16 == L_var1)
 
100
        return val16;
 
101
 
 
102
    if (L_var1 > MAX_16)
 
103
        return MAX_16;
 
104
    return MIN_16;
 
105
}
 
106
/* ------------------------- End of saturate() ------------------------- */
 
107
 
 
108
 
 
109
#if PJ_HAS_INT64
 
110
PJ_INLINE(Word32) L_saturate (pj_int64_t LL_var1)
 
111
{
 
112
    pj_int32_t L_var1 = (pj_int32_t)LL_var1;
 
113
    if (LL_var1 == L_var1)
 
114
        return L_var1;
 
115
    else if (LL_var1 > MAX_32)
 
116
        return MAX_32;
 
117
    else
 
118
        return MIN_32;
 
119
}
 
120
#endif
 
121
 
 
122
 
 
123
/*___________________________________________________________________________
 
124
 |                                                                           |
 
125
 |   Function Name : add                                                     |
 
126
 |                                                                           |
 
127
 |   Purpose :                                                               |
 
128
 |                                                                           |
 
129
 |    Performs the addition (var1+var2) with overflow control and saturation;|
 
130
 |    the 16 bit result is set at +32767 when overflow occurs or at -32768   |
 
131
 |    when underflow occurs.                                                 |
 
132
 |                                                                           |
 
133
 |   Complexity weight : 1                                                   |
 
134
 |                                                                           |
 
135
 |   Inputs :                                                                |
 
136
 |                                                                           |
 
137
 |    var1                                                                   |
 
138
 |             16 bit short signed integer (Word16) whose value falls in the |
 
139
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
140
 |                                                                           |
 
141
 |    var2                                                                   |
 
142
 |             16 bit short signed integer (Word16) whose value falls in the |
 
143
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
144
 |                                                                           |
 
145
 |   Outputs :                                                               |
 
146
 |                                                                           |
 
147
 |    none                                                                   |
 
148
 |                                                                           |
 
149
 |   Return Value :                                                          |
 
150
 |                                                                           |
 
151
 |    var_out                                                                |
 
152
 |             16 bit short signed integer (Word16) whose value falls in the |
 
153
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
154
 |___________________________________________________________________________|
 
155
*/
 
156
PJ_INLINE(Word16) add (Word16 var1, Word16 var2)
 
157
{
 
158
    return saturate (var1 + var2);
 
159
}
 
160
/* ------------------------- End of add() ------------------------- */
 
161
 
 
162
 
 
163
/*___________________________________________________________________________
 
164
 |                                                                           |
 
165
 |   Function Name : sub                                                     |
 
166
 |                                                                           |
 
167
 |   Purpose :                                                               |
 
168
 |                                                                           |
 
169
 |    Performs the subtraction (var1+var2) with overflow control and satu-   |
 
170
 |    ration; the 16 bit result is set at +32767 when overflow occurs or at  |
 
171
 |    -32768 when underflow occurs.                                          |
 
172
 |                                                                           |
 
173
 |   Complexity weight : 1                                                   |
 
174
 |                                                                           |
 
175
 |   Inputs :                                                                |
 
176
 |                                                                           |
 
177
 |    var1                                                                   |
 
178
 |             16 bit short signed integer (Word16) whose value falls in the |
 
179
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
180
 |                                                                           |
 
181
 |    var2                                                                   |
 
182
 |             16 bit short signed integer (Word16) whose value falls in the |
 
183
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
184
 |                                                                           |
 
185
 |   Outputs :                                                               |
 
186
 |                                                                           |
 
187
 |    none                                                                   |
 
188
 |                                                                           |
 
189
 |   Return Value :                                                          |
 
190
 |                                                                           |
 
191
 |    var_out                                                                |
 
192
 |             16 bit short signed integer (Word16) whose value falls in the |
 
193
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
194
 |___________________________________________________________________________|
 
195
*/
 
196
PJ_INLINE(Word16) sub (Word16 var1, Word16 var2)
 
197
{
 
198
    return saturate ((Word32) var1 - var2);
 
199
}
 
200
/* ------------------------- End of sub() ------------------------- */
 
201
 
 
202
 
 
203
/*___________________________________________________________________________
 
204
 |                                                                           |
 
205
 |   Function Name : negate                                                  |
 
206
 |                                                                           |
 
207
 |   Purpose :                                                               |
 
208
 |                                                                           |
 
209
 |   Negate var1 with saturation, saturate in the case where input is -32768:|
 
210
 |                negate(var1) = sub(0,var1).                                |
 
211
 |                                                                           |
 
212
 |   Complexity weight : 1                                                   |
 
213
 |                                                                           |
 
214
 |   Inputs :                                                                |
 
215
 |                                                                           |
 
216
 |    var1                                                                   |
 
217
 |             16 bit short signed integer (Word16) whose value falls in the |
 
218
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
219
 |                                                                           |
 
220
 |   Outputs :                                                               |
 
221
 |                                                                           |
 
222
 |    none                                                                   |
 
223
 |                                                                           |
 
224
 |   Return Value :                                                          |
 
225
 |                                                                           |
 
226
 |    var_out                                                                |
 
227
 |             16 bit short signed integer (Word16) whose value falls in the |
 
228
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
229
 |___________________________________________________________________________|
 
230
*/
 
231
PJ_INLINE(Word16) negate (Word16 var1)
 
232
{
 
233
    return (Word16)((var1 == MIN_16) ? MAX_16 : -var1);
 
234
}
 
235
/* ------------------------- End of negate() ------------------------- */
 
236
 
 
237
 
 
238
 
 
239
 
 
240
/*___________________________________________________________________________
 
241
 |                                                                           |
 
242
 |   Function Name : L_add                                                   |
 
243
 |                                                                           |
 
244
 |   Purpose :                                                               |
 
245
 |                                                                           |
 
246
 |   32 bits addition of the two 32 bits variables (L_var1+L_var2) with      |
 
247
 |   overflow control and saturation; the result is set at +2147483647 when  |
 
248
 |   overflow occurs or at -2147483648 when underflow occurs.                |
 
249
 |                                                                           |
 
250
 |   Complexity weight : 2                                                   |
 
251
 |                                                                           |
 
252
 |   Inputs :                                                                |
 
253
 |                                                                           |
 
254
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
255
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
256
 |                                                                           |
 
257
 |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
 
258
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
259
 |                                                                           |
 
260
 |   Outputs :                                                               |
 
261
 |                                                                           |
 
262
 |    none                                                                   |
 
263
 |                                                                           |
 
264
 |   Return Value :                                                          |
 
265
 |                                                                           |
 
266
 |    L_var_out                                                              |
 
267
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
268
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
269
 |___________________________________________________________________________|
 
270
*/
 
271
PJ_INLINE(Word32) L_add (Word32 L_var1, Word32 L_var2)
 
272
{
 
273
#if PJ_HAS_INT64
 
274
    return L_saturate(((pj_int64_t)L_var1) + L_var2);
 
275
#else
 
276
    Word32 L_var_out;
 
277
 
 
278
    L_var_out = L_var1 + L_var2;
 
279
 
 
280
    if (((L_var1 ^ L_var2) & MIN_32) == 0)
 
281
    {
 
282
        if ((L_var_out ^ L_var1) & MIN_32)
 
283
        {
 
284
            SET_OVERFLOW(1);
 
285
            L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32;
 
286
        }
 
287
    }
 
288
    return (L_var_out);
 
289
#endif
 
290
}
 
291
 
 
292
/* ------------------------- End of L_add() ------------------------- */
 
293
 
 
294
 
 
295
 
 
296
 
 
297
/*___________________________________________________________________________
 
298
 |                                                                           |
 
299
 |   Function Name : L_sub                                                   |
 
300
 |                                                                           |
 
301
 |   Purpose :                                                               |
 
302
 |                                                                           |
 
303
 |   32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with   |
 
304
 |   overflow control and saturation; the result is set at +2147483647 when  |
 
305
 |   overflow occurs or at -2147483648 when underflow occurs.                |
 
306
 |                                                                           |
 
307
 |   Complexity weight : 2                                                   |
 
308
 |                                                                           |
 
309
 |   Inputs :                                                                |
 
310
 |                                                                           |
 
311
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
312
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
313
 |                                                                           |
 
314
 |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
 
315
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
316
 |                                                                           |
 
317
 |   Outputs :                                                               |
 
318
 |                                                                           |
 
319
 |    none                                                                   |
 
320
 |                                                                           |
 
321
 |   Return Value :                                                          |
 
322
 |                                                                           |
 
323
 |    L_var_out                                                              |
 
324
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
325
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
326
 |___________________________________________________________________________|
 
327
*/
 
328
PJ_INLINE(Word32) L_sub (Word32 L_var1, Word32 L_var2)
 
329
{
 
330
#if PJ_HAS_INT64
 
331
    return L_saturate((pj_int64_t)L_var1 - L_var2);
 
332
#else
 
333
    Word32 L_var_out;
 
334
 
 
335
    L_var_out = L_var1 - L_var2;
 
336
 
 
337
    if (((L_var1 ^ L_var2) & MIN_32) != 0)
 
338
    {
 
339
        if ((L_var_out ^ L_var1) & MIN_32)
 
340
        {
 
341
            L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32;
 
342
            SET_OVERFLOW(1);
 
343
        }
 
344
    }
 
345
    return (L_var_out);
 
346
#endif
 
347
}
 
348
/* ------------------------- End of L_sub() ------------------------- */
 
349
 
 
350
/*___________________________________________________________________________
 
351
 |                                                                           |
 
352
 |   Function Name : L_mult                                                  |
 
353
 |                                                                           |
 
354
 |   Purpose :                                                               |
 
355
 |                                                                           |
 
356
 |   L_mult is the 32 bit result of the multiplication of var1 times var2    |
 
357
 |   with one shift left i.e.:                                               |
 
358
 |        L_mult(var1,var2) = L_shl((var1 times var2),1) and                 |
 
359
 |        L_mult(-32768,-32768) = 2147483647.                                |
 
360
 |                                                                           |
 
361
 |   Complexity weight : 1                                                   |
 
362
 |                                                                           |
 
363
 |   Inputs :                                                                |
 
364
 |                                                                           |
 
365
 |    var1                                                                   |
 
366
 |             16 bit short signed integer (Word16) whose value falls in the |
 
367
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
368
 |                                                                           |
 
369
 |    var2                                                                   |
 
370
 |             16 bit short signed integer (Word16) whose value falls in the |
 
371
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
372
 |                                                                           |
 
373
 |   Outputs :                                                               |
 
374
 |                                                                           |
 
375
 |    none                                                                   |
 
376
 |                                                                           |
 
377
 |   Return Value :                                                          |
 
378
 |                                                                           |
 
379
 |    L_var_out                                                              |
 
380
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
381
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
382
 |___________________________________________________________________________|
 
383
*/
 
384
PJ_INLINE(Word32) L_mult (Word16 var1, Word16 var2)
 
385
{
 
386
    Word32 L_var_out;
 
387
 
 
388
    L_var_out = (Word32) var1 *(Word32) var2;
 
389
 
 
390
    if (L_var_out != (Word32) 0x40000000L)
 
391
    {
 
392
        return L_var_out << 1;
 
393
    }
 
394
    else
 
395
    {
 
396
        SET_OVERFLOW(1);
 
397
        return MAX_32;
 
398
    }
 
399
}
 
400
/* ------------------------- End of L_mult() ------------------------- */
 
401
 
 
402
 
 
403
/*___________________________________________________________________________
 
404
 |                                                                           |
 
405
 |   Function Name : L_mac                                                   |
 
406
 |                                                                           |
 
407
 |   Purpose :                                                               |
 
408
 |                                                                           |
 
409
 |   Multiply var1 by var2 and shift the result left by 1. Add the 32 bit    |
 
410
 |   result to L_var3 with saturation, return a 32 bit result:               |
 
411
 |        L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)).         |
 
412
 |                                                                           |
 
413
 |   Complexity weight : 1                                                   |
 
414
 |                                                                           |
 
415
 |   Inputs :                                                                |
 
416
 |                                                                           |
 
417
 |    L_var3   32 bit long signed integer (Word32) whose value falls in the  |
 
418
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
419
 |                                                                           |
 
420
 |    var1                                                                   |
 
421
 |             16 bit short signed integer (Word16) whose value falls in the |
 
422
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
423
 |                                                                           |
 
424
 |    var2                                                                   |
 
425
 |             16 bit short signed integer (Word16) whose value falls in the |
 
426
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
427
 |                                                                           |
 
428
 |   Outputs :                                                               |
 
429
 |                                                                           |
 
430
 |    none                                                                   |
 
431
 |                                                                           |
 
432
 |   Return Value :                                                          |
 
433
 |                                                                           |
 
434
 |    L_var_out                                                              |
 
435
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
436
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
437
 |___________________________________________________________________________|
 
438
*/
 
439
PJ_INLINE(Word32) L_mac (Word32 L_var3, Word16 var1, Word16 var2)
 
440
{
 
441
    return L_add (L_var3, L_mult (var1, var2));
 
442
}
 
443
/* ------------------------- End of L_mac() ------------------------- */
 
444
 
 
445
 
 
446
/*___________________________________________________________________________
 
447
 |                                                                           |
 
448
 |   Function Name : round                                                   |
 
449
 |                                                                           |
 
450
 |   Purpose :                                                               |
 
451
 |                                                                           |
 
452
 |   Round the lower 16 bits of the 32 bit input number into the MS 16 bits  |
 
453
 |   with saturation. Shift the resulting bits right by 16 and return the 16 |
 
454
 |   bit number:                                                             |
 
455
 |               round(L_var1) = extract_h(L_add(L_var1,32768))              |
 
456
 |                                                                           |
 
457
 |   Complexity weight : 1                                                   |
 
458
 |                                                                           |
 
459
 |   Inputs :                                                                |
 
460
 |                                                                           |
 
461
 |    L_var1                                                                 |
 
462
 |             32 bit long signed integer (Word32 ) whose value falls in the |
 
463
 |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
 
464
 |                                                                           |
 
465
 |   Outputs :                                                               |
 
466
 |                                                                           |
 
467
 |    none                                                                   |
 
468
 |                                                                           |
 
469
 |   Return Value :                                                          |
 
470
 |                                                                           |
 
471
 |    var_out                                                                |
 
472
 |             16 bit short signed integer (Word16) whose value falls in the |
 
473
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 
474
 |___________________________________________________________________________|
 
475
*/
 
476
PJ_INLINE(Word16) itu_round (Word32 L_var1)
 
477
{
 
478
    return extract_h (L_add (L_var1, (Word32) 0x00008000L));
 
479
}
 
480
/* ------------------------- End of round() ------------------------- */
 
481
 
 
482
 
 
483
/*___________________________________________________________________________
 
484
 |                                                                           |
 
485
 |   Function Name : L_shr                                                   |
 
486
 |                                                                           |
 
487
 |   Purpose :                                                               |
 
488
 |                                                                           |
 
489
 |   Arithmetically shift the 32 bit input L_var1 right var2 positions with  |
 
490
 |   sign extension. If var2 is negative, arithmetically shift L_var1 left   |
 
491
 |   by -var2 and zero fill the -var2 LSB of the result. Saturate the result |
 
492
 |   in case of underflows or overflows.                                     |
 
493
 |                                                                           |
 
494
 |   Complexity weight : 2                                                   |
 
495
 |                                                                           |
 
496
 |   Inputs :                                                                |
 
497
 |                                                                           |
 
498
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
499
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
500
 |                                                                           |
 
501
 |    var2                                                                   |
 
502
 |             16 bit short signed integer (Word16) whose value falls in the |
 
503
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
504
 |                                                                           |
 
505
 |   Outputs :                                                               |
 
506
 |                                                                           |
 
507
 |    none                                                                   |
 
508
 |                                                                           |
 
509
 |   Return Value :                                                          |
 
510
 |                                                                           |
 
511
 |    L_var_out                                                              |
 
512
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
513
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
514
 |___________________________________________________________________________|
 
515
*/
 
516
PJ_INLINE(Word32) L_shr_nocheck(Word32 L_var1, Word16 var2)
 
517
{
 
518
#if 1
 
519
    return L_var1 >> var2;
 
520
#else
 
521
    if (var2 >= 31)
 
522
    {
 
523
        return (L_var1 < 0L) ? -1 : 0;
 
524
    }
 
525
    else
 
526
    {
 
527
        if (L_var1 < 0)
 
528
        {
 
529
            return ~((~L_var1) >> var2);
 
530
        }
 
531
        else
 
532
        {
 
533
            return L_var1 >> var2;
 
534
        }
 
535
    }
 
536
#endif
 
537
}
 
538
 
 
539
PJ_INLINE(Word32) L_shl_nocheck (Word32 L_var1, Word16 var2)
 
540
{
 
541
#if PJ_HAS_INT64
 
542
    return L_saturate( ((pj_int64_t)L_var1) << var2 );
 
543
#else
 
544
    for (; var2 > 0; var2--)
 
545
    {
 
546
        if (L_var1 > (Word32) 0X3fffffffL)
 
547
        {
 
548
            SET_OVERFLOW(1);
 
549
            return MAX_32;
 
550
        }
 
551
        else
 
552
        {
 
553
            if (L_var1 < (Word32) 0xc0000000L)
 
554
            {
 
555
                SET_OVERFLOW(1);
 
556
                return MIN_32;
 
557
            }
 
558
        }
 
559
        L_var1 <<= 1;
 
560
    }
 
561
    return (L_var1);
 
562
#endif
 
563
}
 
564
 
 
565
PJ_INLINE(Word32) L_shr (Word32 L_var1, Word16 var2)
 
566
{
 
567
    if (var2 < 0)
 
568
    {
 
569
        if (var2 < -32)
 
570
            var2 = -32;
 
571
        return L_shl_nocheck (L_var1, (Word16) -var2);
 
572
    }
 
573
    else
 
574
    {
 
575
        return L_shr_nocheck(L_var1, var2);
 
576
    }
 
577
}
 
578
/* ------------------------- End of L_shr() ------------------------- */
 
579
 
 
580
/*___________________________________________________________________________
 
581
 |                                                                           |
 
582
 |   Function Name : L_shl                                                   |
 
583
 |                                                                           |
 
584
 |   Purpose :                                                               |
 
585
 |                                                                           |
 
586
 |   Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero  |
 
587
 |   fill the var2 LSB of the result. If var2 is negative, arithmetically    |
 
588
 |   shift L_var1 right by -var2 with sign extension. Saturate the result in |
 
589
 |   case of underflows or overflows.                                        |
 
590
 |                                                                           |
 
591
 |   Complexity weight : 2                                                   |
 
592
 |                                                                           |
 
593
 |   Inputs :                                                                |
 
594
 |                                                                           |
 
595
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 
596
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 
597
 |                                                                           |
 
598
 |    var2                                                                   |
 
599
 |             16 bit short signed integer (Word16) whose value falls in the |
 
600
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
601
 |                                                                           |
 
602
 |   Outputs :                                                               |
 
603
 |                                                                           |
 
604
 |    none                                                                   |
 
605
 |                                                                           |
 
606
 |   Return Value :                                                          |
 
607
 |                                                                           |
 
608
 |    L_var_out                                                              |
 
609
 |             32 bit long signed integer (Word32) whose value falls in the  |
 
610
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 
611
 |___________________________________________________________________________|
 
612
*/
 
613
PJ_INLINE(Word32) L_shl (Word32 L_var1, Word16 var2)
 
614
{
 
615
    if (var2 <= 0)
 
616
    {
 
617
        if (var2 < -32)
 
618
            var2 = -32;
 
619
        return L_shr_nocheck(L_var1, (Word16) -var2);
 
620
    }
 
621
    else
 
622
    {
 
623
        return L_shl_nocheck(L_var1, var2);
 
624
    }
 
625
}
 
626
/* ------------------------- End of L_shl() ------------------------- */
 
627
 
 
628
 
 
629
/*___________________________________________________________________________
 
630
 |                                                                           |
 
631
 |   Function Name : abs_s                                                   |
 
632
 |                                                                           |
 
633
 |   Purpose :                                                               |
 
634
 |                                                                           |
 
635
 |    Absolute value of var1; abs_s(-32768) = 32767.                         |
 
636
 |                                                                           |
 
637
 |   Complexity weight : 1                                                   |
 
638
 |                                                                           |
 
639
 |   Inputs :                                                                |
 
640
 |                                                                           |
 
641
 |    var1                                                                   |
 
642
 |             16 bit short signed integer (Word16) whose value falls in the |
 
643
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 
644
 |                                                                           |
 
645
 |   Outputs :                                                               |
 
646
 |                                                                           |
 
647
 |    none                                                                   |
 
648
 |                                                                           |
 
649
 |   Return Value :                                                          |
 
650
 |                                                                           |
 
651
 |    var_out                                                                |
 
652
 |             16 bit short signed integer (Word16) whose value falls in the |
 
653
 |             range : 0x0000 0000 <= var_out <= 0x0000 7fff.                |
 
654
 |___________________________________________________________________________|
 
655
*/
 
656
PJ_INLINE(Word16) abs_s (Word16 var1)
 
657
{
 
658
#if 1
 
659
    if (var1 >= 0)
 
660
        return var1;
 
661
    else if (var1 == MIN_16)
 
662
        return MAX_16;
 
663
    else
 
664
        return (Word16)-var1;
 
665
#else
 
666
    if (var1 == MIN_16)
 
667
    {
 
668
        return MAX_16;
 
669
    }
 
670
    else
 
671
    {
 
672
        if (var1 < 0)
 
673
        {
 
674
            return (Word16)-var1;
 
675
        }
 
676
        else
 
677
        {
 
678
            return var1;
 
679
        }
 
680
    }
 
681
#endif
 
682
}
 
683
/* ------------------------- End of abs_s() ------------------------- */
 
684
 
 
685
 
 
686
PJ_INLINE(Word16) shl_nocheck(Word16 var1, Word16 var2)
 
687
{
 
688
#if 1
 
689
    /* blp: this should be more optimized */
 
690
    return saturate (((Word32)var1) << var2);
 
691
#else
 
692
    /* Original algorithm */
 
693
    Word32 result = (Word32) var1 *((Word32) 1 << var2);
 
694
 
 
695
    if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result)))
 
696
    {
 
697
        SET_OVERFLOW(1);
 
698
        return (Word16) ((var1 > 0) ? MAX_16 : MIN_16);
 
699
    }
 
700
    else
 
701
    {
 
702
        return extract_l (result);
 
703
    }
 
704
#endif
 
705
}
 
706
 
 
707
PJ_INLINE(Word16) shr_nocheck(Word16 var1, Word16 var2)
 
708
{
 
709
#if 1
 
710
    /* blp: this should yield the same value */
 
711
    return (Word16) (var1 >> var2);
 
712
#else
 
713
    /* Original algorithm */
 
714
    if (var2 >= 15)
 
715
    {
 
716
        return (Word16)((var1 < 0) ? -1 : 0);
 
717
    }
 
718
    else
 
719
    {
 
720
        if (var1 < 0)
 
721
        {
 
722
            return (Word16) (~((~var1) >> var2));
 
723
        }
 
724
        else
 
725
        {
 
726
            return (Word16)(var1 >> var2);
 
727
        }
 
728
    }
 
729
#endif
 
730
}