• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 /****************************************************************************************
19 Portions 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)
26 Permission to distribute, modify and use this file under the standard license
27 terms listed above has been obtained from the copyright holder.
28 ****************************************************************************************/
29 /*
30 
31  Pathname: ./include/basic_op_c_equivalent.h
32 
33 ------------------------------------------------------------------------------
34  REVISION HISTORY
35 
36  Who:                       Date:
37  Description:
38 
39 ------------------------------------------------------------------------------
40  INCLUDE DESCRIPTION
41 
42  This file includes all the C-Equivalent basicop.c functions.
43 
44 ------------------------------------------------------------------------------
45 */
46 
47 /*----------------------------------------------------------------------------
48 ; CONTINUE ONLY IF NOT ALREADY DEFINED
49 ----------------------------------------------------------------------------*/
50 #ifndef BASIC_OP_C_EQUIVALENT_H
51 #define BASIC_OP_C_EQUIVALENT_H
52 
53 /*----------------------------------------------------------------------------
54 ; INCLUDES
55 ----------------------------------------------------------------------------*/
56 #include    "basicop_malloc.h"
57 
58 /*--------------------------------------------------------------------------*/
59 #ifdef __cplusplus
60 extern "C"
61 {
62 #endif
63 
64     /*----------------------------------------------------------------------------
65     ; MACROS
66     ; Define module specific macros here
67     ----------------------------------------------------------------------------*/
68 
69     /*----------------------------------------------------------------------------
70     ; DEFINES
71     ; Include all pre-processor statements here.
72     ----------------------------------------------------------------------------*/
73 
74     /*----------------------------------------------------------------------------
75     ; EXTERNAL VARIABLES REFERENCES
76     ; Declare variables used in this module but defined elsewhere
77     ----------------------------------------------------------------------------*/
78 
79     /*----------------------------------------------------------------------------
80     ; SIMPLE TYPEDEF'S
81     ----------------------------------------------------------------------------*/
82 
83     /*----------------------------------------------------------------------------
84     ; ENUMERATED TYPEDEF'S
85     ----------------------------------------------------------------------------*/
86 
87     /*----------------------------------------------------------------------------
88     ; STRUCTURES TYPEDEF'S
89     ----------------------------------------------------------------------------*/
90 
91     /*----------------------------------------------------------------------------
92     ; GLOBAL FUNCTION DEFINITIONS
93     ; Function Prototype declaration
94     ----------------------------------------------------------------------------*/
95 
96 
97     /*
98     ------------------------------------------------------------------------------
99      FUNCTION NAME: L_add
100     ------------------------------------------------------------------------------
101      INPUT AND OUTPUT DEFINITIONS
102 
103      Inputs:
104         L_var1 = 32 bit long signed integer (Word32) whose value falls
105                  in the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
106 
107         L_var2 = 32 bit long signed integer (Word32) whose value falls
108                  in the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
109 
110         pOverflow = pointer to overflow (Flag)
111 
112      Outputs:
113         pOverflow -> 1 if the 32 bit add operation resulted in overflow
114 
115      Returns:
116         L_sum = 32-bit sum of L_var1 and L_var2 (Word32)
117     */
118     __attribute__((no_sanitize("integer")))
L_add(Word32 L_var1,Word32 L_var2,Flag * pOverflow)119     static inline Word32 L_add(Word32 L_var1, Word32 L_var2, Flag *pOverflow)
120     {
121         Word32 L_sum;
122 
123         L_sum = L_var1 + L_var2;
124 
125         if ((L_var1 ^ L_var2) >= 0)
126         {
127             if ((L_sum ^ L_var1) < 0)
128             {
129                 L_sum = (L_var1 < 0) ? MIN_32 : MAX_32;
130                 *pOverflow = 1;
131             }
132         }
133 
134         return (L_sum);
135     }
136 
137     /*
138     ------------------------------------------------------------------------------
139      FUNCTION NAME: L_sub
140     ------------------------------------------------------------------------------
141      INPUT AND OUTPUT DEFINITIONS
142 
143      Inputs:
144         L_var1 = 32 bit long signed integer (Word32) whose value falls
145                  in the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
146 
147         L_var2 = 32 bit long signed integer (Word32) whose value falls
148                  in the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
149 
150         pOverflow = pointer to overflow (Flag)
151 
152      Outputs:
153         pOverflow -> 1 if the 32 bit add operation resulted in overflow
154 
155      Returns:
156         L_diff = 32-bit difference of L_var1 and L_var2 (Word32)
157     */
L_sub(Word32 L_var1,Word32 L_var2,Flag * pOverflow)158     static inline Word32 L_sub(Word32 L_var1, Word32 L_var2,
159                                Flag *pOverflow)
160     {
161         Word32 L_diff;
162 
163         L_diff = L_var1 - L_var2;
164 
165         if ((L_var1 ^ L_var2) < 0)
166         {
167             if ((L_diff ^ L_var1) & MIN_32)
168             {
169                 L_diff = (L_var1 < 0L) ? MIN_32 : MAX_32;
170                 *pOverflow = 1;
171             }
172         }
173 
174         return (L_diff);
175     }
176 
177 
178     /*
179     ------------------------------------------------------------------------------
180      FUNCTION NAME: L_mac
181     ------------------------------------------------------------------------------
182      INPUT AND OUTPUT DEFINITIONS
183 
184      Inputs:
185         L_var3 = 32 bit long signed integer (Word32) whose value falls
186                  in the range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
187         var1 = 16 bit short signed integer (Word16) whose value falls in
188                the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
189         var2 = 16 bit short signed integer (Word16) whose value falls in
190                the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
191 
192         pOverflow = pointer to overflow (Flag)
193 
194      Outputs:
195         pOverflow -> 1 if the 32 bit add operation resulted in overflow
196 
197      Returns:
198         result = 32-bit result of L_var3 + (var1 * var2)(Word32)
199     */
L_mac(Word32 L_var3,Word16 var1,Word16 var2,Flag * pOverflow)200     __inline Word32 L_mac(Word32 L_var3, Word16 var1, Word16 var2, Flag *pOverflow)
201     {
202         Word32 result;
203         Word32 L_sum;
204         result = (Word32) var1 * var2;
205         if (result != (Word32) 0x40000000L)
206         {
207             L_sum = (result << 1) + L_var3;
208 
209             /* Check if L_sum and L_var_3 share the same sign */
210             if ((L_var3 ^ result) > 0)
211             {
212                 if ((L_sum ^ L_var3) < 0)
213                 {
214                     L_sum = (L_var3 < 0) ? MIN_32 : MAX_32;
215                     *pOverflow = 1;
216                 }
217             }
218         }
219         else
220         {
221             *pOverflow = 1;
222             L_sum = MAX_32;
223         }
224         return (L_sum);
225     }
226 
227     /*
228     ------------------------------------------------------------------------------
229      FUNCTION NAME: L_mult
230     ------------------------------------------------------------------------------
231      INPUT AND OUTPUT DEFINITIONS
232 
233      Inputs:
234         L_var1 = 16 bit short signed integer (Word16) whose value falls in
235                the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
236 
237         L_var2 = 16 bit short signed integer (Word16) whose value falls in
238                the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
239 
240         pOverflow = pointer to overflow (Flag)
241 
242      Outputs:
243         pOverflow -> 1 if the 32 bit add operation resulted in overflow
244 
245      Returns:
246         L_product = 32-bit product of L_var1 and L_var2 (Word32)
247     */
L_mult(Word16 var1,Word16 var2,Flag * pOverflow)248     static inline Word32 L_mult(Word16 var1, Word16 var2, Flag *pOverflow)
249     {
250         Word32 L_product;
251 
252         L_product = (Word32) var1 * var2;
253 
254         if (L_product != (Word32) 0x40000000L)
255         {
256             L_product <<= 1;          /* Multiply by 2 */
257         }
258         else
259         {
260             *pOverflow = 1;
261             L_product = MAX_32;
262         }
263 
264         return (L_product);
265     }
266 
267 
268     /*
269     ------------------------------------------------------------------------------
270      FUNCTION NAME: L_msu
271     ------------------------------------------------------------------------------
272      INPUT AND OUTPUT DEFINITIONS
273 
274      Inputs:
275         L_var3 = 32 bit long signed integer (Word32) whose value falls
276                  in the range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
277 
278         var1 = 16 bit short signed integer (Word16) whose value falls in
279                the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
280         var2 = 16 bit short signed integer (Word16) whose value falls in
281                the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
282 
283         pOverflow = pointer to overflow (Flag)
284 
285      Outputs:
286         pOverflow -> 1 if the 32 bit operation resulted in overflow
287 
288      Returns:
289         result = 32-bit result of L_var3 - (var1 * var2)
290     */
291 
L_msu(Word32 L_var3,Word16 var1,Word16 var2,Flag * pOverflow)292     static inline Word32 L_msu(Word32 L_var3, Word16 var1, Word16 var2, Flag *pOverflow)
293     {
294         Word32 result;
295 
296         result = L_mult(var1, var2, pOverflow);
297         result = L_sub(L_var3, result, pOverflow);
298 
299         return (result);
300     }
301 
302     /*
303     ------------------------------------------------------------------------------
304      FUNCTION NAME: Mpy_32
305     ------------------------------------------------------------------------------
306      INPUT AND OUTPUT DEFINITIONS
307 
308      Inputs:
309         L_var1_hi = most significant word of first input (Word16).
310         L_var1_lo = least significant word of first input (Word16).
311         L_var2_hi = most significant word of second input (Word16).
312         L_var2_lo = least significant word of second input (Word16).
313 
314         pOverflow = pointer to overflow (Flag)
315 
316      Outputs:
317         pOverflow -> 1 if the 32 bit multiply operation resulted in overflow
318 
319      Returns:
320         L_product = 32-bit product of L_var1 and L_var2 (Word32)
321     */
Mpy_32(Word16 L_var1_hi,Word16 L_var1_lo,Word16 L_var2_hi,Word16 L_var2_lo,Flag * pOverflow)322     __inline Word32 Mpy_32(Word16 L_var1_hi,
323                            Word16 L_var1_lo,
324                            Word16 L_var2_hi,
325                            Word16 L_var2_lo,
326                            Flag   *pOverflow)
327     {
328         Word32 L_product;
329         Word32 L_sum;
330         Word32 product32;
331 
332         OSCL_UNUSED_ARG(pOverflow);
333         L_product = (Word32) L_var1_hi * L_var2_hi;
334 
335         if (L_product != (Word32) 0x40000000L)
336         {
337             L_product <<= 1;
338         }
339         else
340         {
341             L_product = MAX_32;
342         }
343 
344         /* result = mult (L_var1_hi, L_var2_lo, pOverflow); */
345         product32 = ((Word32) L_var1_hi * L_var2_lo) >> 15;
346 
347         /* L_product = L_mac (L_product, result, 1, pOverflow); */
348         L_sum = L_product + (product32 << 1);
349 
350         if ((L_product ^ product32) > 0)
351         {
352             if ((L_sum ^ L_product) < 0)
353             {
354                 L_sum = (L_product < 0) ? MIN_32 : MAX_32;
355             }
356         }
357 
358         L_product = L_sum;
359 
360         /* result = mult (L_var1_lo, L_var2_hi, pOverflow); */
361         product32 = ((Word32) L_var1_lo * L_var2_hi) >> 15;
362 
363         /* L_product = L_mac (L_product, result, 1, pOverflow); */
364         L_sum = L_product + (product32 << 1);
365 
366         if ((L_product ^ product32) > 0)
367         {
368             if ((L_sum ^ L_product) < 0)
369             {
370                 L_sum = (L_product < 0) ? MIN_32 : MAX_32;
371             }
372         }
373         return (L_sum);
374     }
375 
376     /*
377     ------------------------------------------------------------------------------
378      FUNCTION NAME: Mpy_32_16
379     ------------------------------------------------------------------------------
380      INPUT AND OUTPUT DEFINITIONS
381 
382      Inputs:
383         L_var1_hi = most significant 16 bits of 32-bit input (Word16).
384         L_var1_lo = least significant 16 bits of 32-bit input (Word16).
385         var2  = 16-bit signed integer (Word16).
386 
387         pOverflow = pointer to overflow (Flag)
388 
389      Outputs:
390         pOverflow -> 1 if the 32 bit product operation resulted in overflow
391 
392      Returns:
393         product = 32-bit product of the 32-bit L_var1 and 16-bit var1 (Word32)
394     */
395 
Mpy_32_16(Word16 L_var1_hi,Word16 L_var1_lo,Word16 var2,Flag * pOverflow)396     __inline Word32 Mpy_32_16(Word16 L_var1_hi,
397                               Word16 L_var1_lo,
398                               Word16 var2,
399                               Flag *pOverflow)
400     {
401 
402         Word32 L_product;
403         Word32 L_sum;
404         Word32 result;
405         L_product = (Word32) L_var1_hi * var2;
406 
407         if (L_product != (Word32) 0x40000000L)
408         {
409             L_product <<= 1;
410         }
411         else
412         {
413             *pOverflow = 1;
414             L_product = MAX_32;
415         }
416 
417         result = ((Word32)L_var1_lo * var2) >> 15;
418 
419         L_sum  =  L_product + (result << 1);
420 
421         if ((L_product ^ result) > 0)
422         {
423             if ((L_sum ^ L_product) < 0)
424             {
425                 L_sum = (L_product < 0) ? MIN_32 : MAX_32;
426                 *pOverflow = 1;
427             }
428         }
429         return (L_sum);
430 
431     }
432 
433     /*
434     ------------------------------------------------------------------------------
435      FUNCTION NAME: mult
436     ------------------------------------------------------------------------------
437      INPUT AND OUTPUT DEFINITIONS
438 
439      Inputs:
440         var1 = 16 bit short signed integer (Word16) whose value falls in
441                the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
442 
443         var2 = 16 bit short signed integer (Word16) whose value falls in
444                the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
445 
446         pOverflow = pointer to overflow (Flag)
447 
448      Outputs:
449         pOverflow -> 1 if the add operation resulted in overflow
450 
451      Returns:
452         product = 16-bit limited product of var1 and var2 (Word16)
453     */
mult(Word16 var1,Word16 var2,Flag * pOverflow)454     static inline Word16 mult(Word16 var1, Word16 var2, Flag *pOverflow)
455     {
456         Word32 product;
457 
458         product = ((Word32) var1 * var2) >> 15;
459 
460         /* Saturate result (if necessary). */
461         /* var1 * var2 >0x00007fff is the only case */
462         /* that saturation occurs. */
463 
464         if (product > 0x00007fffL)
465         {
466             *pOverflow = 1;
467             product = (Word32) MAX_16;
468         }
469 
470 
471         /* Return the product as a 16 bit value by type casting Word32 to Word16 */
472 
473         return ((Word16) product);
474     }
475 
476 
amrnb_fxp_mac_16_by_16bb(Word32 L_var1,Word32 L_var2,Word32 L_var3)477     static inline Word32 amrnb_fxp_mac_16_by_16bb(Word32 L_var1, Word32 L_var2, Word32 L_var3)
478     {
479         Word32 result;
480 
481         result = L_var3 + L_var1 * L_var2;
482 
483         return result;
484     }
485 
amrnb_fxp_msu_16_by_16bb(Word32 L_var1,Word32 L_var2,Word32 L_var3)486     static inline Word32 amrnb_fxp_msu_16_by_16bb(Word32 L_var1, Word32 L_var2, Word32 L_var3)
487     {
488         Word32 result;
489 
490         result = L_var3 - L_var1 * L_var2;
491 
492         return result;
493     }
494 
495 
496     /*----------------------------------------------------------------------------
497     ; END
498     ----------------------------------------------------------------------------*/
499 #ifdef __cplusplus
500 }
501 #endif
502 
503 #endif /* BASIC_OP_C_EQUIVALENT_H */
504 
505 
506 
507