basic_op.h revision 4f1efc098cb5791c3e9f483f2af84aef70d2d0a0 
1/* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18/****************************************************************************************
19Portions of this file are derived from the following 3GPP standard:
20
21    3GPP TS 26.073
22    ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
23    Available from http://www.3gpp.org
24
25(C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
26Permission to distribute, modify and use this file under the standard license
27terms listed above has been obtained from the copyright holder.
28****************************************************************************************/
29/*
30
31 Pathname: ./include/basic_op.h
32
33------------------------------------------------------------------------------
34 REVISION HISTORY
35
36 Description: Revised basic_op.h since the basicop2.c functions were split
37          up into separate source and header files. This function was
38          retained because there are legacy GSM AMR C functions that still
39          include this file. This file now includes the various basicop2
40          functions' header files instead of defining the function
41          prototypes.
42
43 Description: Including header files with platform specific inline assembly
44              instructions.
45
46 Who:                       Date:
47 Description:
48
49------------------------------------------------------------------------------
50 INCLUDE DESCRIPTION
51
52 This file includes all the basicop2.c functions' header files.
53
54------------------------------------------------------------------------------
55*/
56
57/*----------------------------------------------------------------------------
58; CONTINUE ONLY IF NOT ALREADY DEFINED
59----------------------------------------------------------------------------*/
60#ifndef BASIC_OP_H
61#define BASIC_OP_H
62
63/*----------------------------------------------------------------------------
64; INCLUDES
65----------------------------------------------------------------------------*/
66#include    "basicop_malloc.h"
67
68#if defined(PV_ARM_V5)
69#include "basic_op_arm_v5.h"
70
71#elif defined(PV_ARM_GCC_V5)
72#include "basic_op_arm_gcc_v5.h"
73
74#else
75#include "basic_op_c_equivalent.h"
76
77#endif
78
79
80
81#include    "add.h"
82#include    "div_s.h"
83#include    "div_32.h"
84#include    "extract_h.h"
85#include    "extract_l.h"
86#include    "l_deposit_h.h"
87#include    "l_deposit_l.h"
88#include    "l_shr_r.h"
89#include    "mult_r.h"
90#include    "norm_l.h"
91#include    "norm_s.h"
92#include    "round.h"
93#include    "shr_r.h"
94#include    "sub.h"
95#include    "shr.h"
96#include    "l_abs.h"
97#include    "l_negate.h"
98#include    "l_extract.h"
99#include    "l_abs.h"
100/*--------------------------------------------------------------------------*/
101#ifdef __cplusplus
102extern "C"
103{
104#endif
105
106    /*----------------------------------------------------------------------------
107    ; MACROS
108    ; Define module specific macros here
109    ----------------------------------------------------------------------------*/
110
111    /*----------------------------------------------------------------------------
112    ; DEFINES
113    ; Include all pre-processor statements here.
114    ----------------------------------------------------------------------------*/
115
116    /*----------------------------------------------------------------------------
117    ; EXTERNAL VARIABLES REFERENCES
118    ; Declare variables used in this module but defined elsewhere
119    ----------------------------------------------------------------------------*/
120
121    /*----------------------------------------------------------------------------
122    ; SIMPLE TYPEDEF'S
123    ----------------------------------------------------------------------------*/
124
125    /*----------------------------------------------------------------------------
126    ; ENUMERATED TYPEDEF'S
127    ----------------------------------------------------------------------------*/
128
129    /*----------------------------------------------------------------------------
130    ; STRUCTURES TYPEDEF'S
131    ----------------------------------------------------------------------------*/
132
133    /*----------------------------------------------------------------------------
134    ; GLOBAL FUNCTION DEFINITIONS
135    ; Function Prototype declaration
136    ----------------------------------------------------------------------------*/
137    /*
138    ------------------------------------------------------------------------------
139     FUNCTION NAME: mac_32
140    ------------------------------------------------------------------------------
141     INPUT AND OUTPUT DEFINITIONS
142
143     Inputs:
144        L_var3 = 32 bit long signed integer (Word32) whose value falls
145                 in the range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
146        L_var1_hi = 16 bit short signed integer (Word16) whose value falls in
147               the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
148        L_var1_lo = 16 bit short signed integer (Word16) whose value falls in
149               the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
150        L_var2_hi = 16 bit short signed integer (Word16) whose value falls in
151               the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
152        L_var2_lo = 16 bit short signed integer (Word16) whose value falls in
153               the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
154
155        pOverflow = pointer to overflow (Flag)
156
157     Outputs:
158        pOverflow -> 1 if the 32 bit mac operation resulted in overflow
159
160     Returns:
161        L_var3 = 32-bit result of L_var3 + (L_var1 * L_var2)(Word32)
162
163    */
164    static inline Word32 Mac_32(Word32 L_var3,
165    Word16 L_var1_hi,
166    Word16 L_var1_lo,
167    Word16 L_var2_hi,
168    Word16 L_var2_lo,
169    Flag *pOverflow)
170    {
171        Word16  product;
172
173        L_var3 = L_mac(L_var3, L_var1_hi, L_var2_hi, pOverflow);
174
175        product = mult(L_var1_hi, L_var2_lo, pOverflow);
176        L_var3 = L_mac(L_var3, product, 1, pOverflow);
177
178        product = mult(L_var1_lo, L_var2_hi, pOverflow);
179        L_var3 = L_mac(L_var3, product, 1, pOverflow);
180
181        return (L_var3);
182    }
183
184    /*
185    ------------------------------------------------------------------------------
186     FUNCTION NAME: mac_32_16
187    ------------------------------------------------------------------------------
188     INPUT AND OUTPUT DEFINITIONS
189
190     Inputs:
191        L_var3 = 32 bit long signed integer (Word32) whose value falls
192                 in the range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
193        L_var1_hi = 16 bit short signed integer (Word16) whose value falls in
194               the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
195        L_var1_lo = 16 bit short signed integer (Word16) whose value falls in
196               the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
197        var2= 16 bit short signed integer (Word16) whose value falls in
198               the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
199        pOverflow = pointer to overflow (Flag)
200
201     Outputs:
202        pOverflow -> 1 if the 32 bit mac operation resulted in overflow
203
204     Returns:
205        L_var3 = 32-bit result of L_var3 + (L_var1 * var2)(Word32)
206    */
207
208    static inline Word32 Mac_32_16(Word32 L_var3,
209                                   Word16 L_var1_hi,
210                                   Word16 L_var1_lo,
211                                   Word16 var2,
212                                   Flag  *pOverflow)
213    {
214        Word16  product;
215
216        L_var3 = L_mac(L_var3, L_var1_hi, var2, pOverflow);
217
218        product = mult(L_var1_lo, var2, pOverflow);
219        L_var3 = L_mac(L_var3, product, 1, pOverflow);
220
221        return (L_var3);
222    }
223
224
225    /*----------------------------------------------------------------------------
226         Function Name : negate
227
228         Negate var1 with saturation, saturate in the case where input is -32768:
229                      negate(var1) = sub(0,var1).
230
231         Inputs :
232          var1
233                   16 bit short signed integer (Word16) whose value falls in the
234                   range : 0x8000 <= var1 <= 0x7fff.
235
236         Outputs :
237          none
238
239         Return Value :
240                   16 bit short signed integer (Word16) whose value falls in the
241                   range : 0x8000 <= var_out <= 0x7fff.
242     ----------------------------------------------------------------------------*/
243
244    static inline Word16 negate(Word16 var1)
245    {
246        return (((var1 == MIN_16) ? MAX_16 : -var1));
247    }
248
249    /*----------------------------------------------------------------------------
250
251         Function Name : shl
252
253         Arithmetically shift the 16 bit input var1 left var2 positions.Zero fill
254         the var2 LSB of the result. If var2 is negative, arithmetically shift
255         var1 right by -var2 with sign extension. Saturate the result in case of
256         underflows or overflows.
257
258         Inputs :
259          var1
260                   16 bit short signed integer (Word16) whose value falls in the
261                   range : 0x8000 <= var1 <= 0x7fff.
262
263          var2
264                   16 bit short signed integer (Word16) whose value falls in the
265                   range : 0x8000 <= var1 <= 0x7fff.
266
267          pOverflow : pointer to overflow (Flag)
268
269         Return Value :
270          var_out
271                   16 bit short signed integer (Word16) whose value falls in the
272                   range : 0x8000 <= var_out <= 0x7fff.
273     ----------------------------------------------------------------------------*/
274
275    static inline Word16 shl(Word16 var1, Word16 var2, Flag *pOverflow)
276    {
277        Word16 var_out = 0;
278
279        OSCL_UNUSED_ARG(pOverflow);
280
281        if (var2 < 0)
282        {
283            var2 = -var2;
284            if (var2 < 15)
285            {
286                var_out = var1 >> var2;
287            }
288
289        }
290        else
291        {
292            var_out = var1 << var2;
293            if (var_out >> var2 != var1)
294            {
295                var_out = (var1 >> 15) ^ MAX_16;
296            }
297        }
298        return (var_out);
299    }
300
301
302    /*----------------------------------------------------------------------------
303
304         Function Name : L_shl
305
306         Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero
307         fill the var2 LSB of the result. If var2 is negative, arithmetically
308         shift L_var1 right by -var2 with sign extension. Saturate the result in
309         case of underflows or overflows.
310
311         Inputs :
312          L_var1   32 bit long signed integer (Word32) whose value falls in the
313                   range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
314
315          var2
316                   16 bit short signed integer (Word16) whose value falls in the
317                   range :  8000 <= var2 <= 7fff.
318
319          pOverflow : pointer to overflow (Flag)
320
321         Return Value :
322                   32 bit long signed integer (Word32) whose value falls in the
323                   range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
324
325     ----------------------------------------------------------------------------*/
326
327    static inline Word32 L_shl(Word32 L_var1, Word16 var2, Flag *pOverflow)
328    {
329        Word32 L_var_out = 0;
330
331        OSCL_UNUSED_ARG(pOverflow);
332
333        if (var2 > 0)
334        {
335            L_var_out = L_var1 << var2;
336            if (L_var_out >> var2 != L_var1)
337            {
338                L_var_out = (L_var1 >> 31) ^ MAX_32;
339            }
340        }
341        else
342        {
343            var2 = -var2;
344            if (var2 < 31)
345            {
346                L_var_out = L_var1 >> var2;
347            }
348
349        }
350
351        return (L_var_out);
352    }
353
354
355    /*----------------------------------------------------------------------------
356
357         Function Name : L_shr
358
359         Arithmetically shift the 32 bit input L_var1 right var2 positions with
360         sign extension. If var2 is negative, arithmetically shift L_var1 left
361         by -var2 and zero fill the -var2 LSB of the result. Saturate the result
362         in case of underflows or overflows.
363
364         Inputs :
365          L_var1   32 bit long signed integer (Word32) whose value falls in the
366                   range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
367
368          var2
369                   16 bit short signed integer (Word16) whose value falls in the
370                   range :  8000 <= var2 <= 7fff.
371
372          pOverflow : pointer to overflow (Flag)
373
374         Return Value :
375                   32 bit long signed integer (Word32) whose value falls in the
376                   range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
377
378     ----------------------------------------------------------------------------*/
379
380    static inline Word32 L_shr(Word32 L_var1, Word16 var2, Flag *pOverflow)
381    {
382        Word32 L_var_out = 0;
383
384        OSCL_UNUSED_ARG(pOverflow);
385
386        if (var2 > 0)
387        {
388            if (var2 < 31)
389            {
390                L_var_out = L_var1 >> var2;
391            }
392        }
393        else
394        {
395            var2 = -var2;
396
397            L_var_out = L_var1 << (var2) ;
398            if ((L_var_out >> (var2)) != L_var1)
399            {
400                L_var_out = (L_var1 >> 31) ^ MAX_32;
401            }
402
403        }
404
405        return (L_var_out);
406    }
407
408    /*----------------------------------------------------------------------------
409
410         Function Name : abs_s
411
412          Absolute value of var1; abs_s(-32768) = 32767.
413
414         Inputs :
415          var1
416                   16 bit short signed integer (Word16) whose value falls in the
417                   range : 0x8000 <= var1 <= 0x7fff.
418
419          pOverflow : pointer to overflow (Flag)
420
421         Outputs :
422          none
423
424         Return Value :
425                   16 bit short signed integer (Word16) whose value falls in the
426                   range : 0x0000 <= var_out <= 0x7fff.
427
428     ----------------------------------------------------------------------------*/
429
430    static inline Word16 abs_s(Word16 var1)
431    {
432
433        Word16 y = var1 - (var1 < 0);
434        y = y ^(y >> 15);
435        return (y);
436
437    }
438    /*----------------------------------------------------------------------------
439    ; END
440    ----------------------------------------------------------------------------*/
441#ifdef __cplusplus
442}
443#endif
444
445
446#endif /* BASIC_OP_H */
447
448
449