archive
/
tasks
mirror of https://github.com/tasks/tasks
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
14.0
main
renovate/work
renovate/fragment.ktx
renovate/google.oauth2
renovate/activity.compose
list_settings
renovate/com.android.billingclient-billing-ktx-7.x
renovate/osmdroid
renovate/dagger.hilt
renovate/com.android.billingclient-billing-ktx-6.x
renovate/coil
renovate/retrofit-monorepo
atd_image
remove_adapters
gtask_related_email
synthesis
gtask_note_sync
save_or_discard
gh-pages
4.8.15
4.8.14
4.8.13
4.8.12
4.8.11
4.6.12
4.6.9
4.6.8.1
4.6.8
4.6.7
fork
4.6.6
4.0.2
4.0.1
4.0.0
3.8.5
3.8.5.1
3.8.4.4
3.8.4.2
3.8.4.1
3.8.3
3.8.2
3.8.0.2
3.8.0.1
3.8.0
3.7.7
3.7.6
3.7.5
3.7.4
3.7.3.1
3.7.3
3.7.2
3.7.1
3.7.0
3.6.3
3.6.1
3.6.0
3.5.0
3.4.0
3.3.6
3.3.3
3.3.0
3.2.7
3.2.6
3.2.5
3.2.4
3.2.3
3.2.0
3.1.0
3.0.6
3.0.4
3.0.3
3.0.2
3.0.0
2.14.4-limited
2.14.3
2.14.2
2.14.1
2.14.0
0.6.0-lite
10.0
10.0.1
10.0.2
10.0.3
10.1
10.2
10.3
10.4
10.4.1
11.0
11.0.1
11.1
11.1.1
11.10
11.10.1
11.10.2
11.11
11.12
11.12.1
11.12.2
11.12.3
11.13
11.2
11.2.1
11.2.2
11.3
11.3.1
11.3.2
11.3.3
11.3.4
11.4
11.5
11.5.1
11.6
11.6.1
11.7
11.8
11.9
11.9.1
11.9.2
12.0
12.1
12.2
12.3
12.4
12.5
12.6
12.6.1
12.7
12.7.1
13.0.1
13.0.2
13.1
13.1.1
13.1.2
13.10
13.11
13.11.1
13.11.2
13.2
13.2.1
13.2.2
13.2.3
13.2.4
13.3
13.3.1
13.3.2
13.4
13.5
13.5.1
13.6
13.6.1
13.6.2
13.6.3
13.7
13.8
13.8.1
13.9
13.9.6
13.9.7
13.9.9
3.8.3.1
3.9.1
3.9.1.1
4.1.3
4.1.3.1
4.2.0
4.2.1
4.2.2
4.3.0
4.3.1
4.3.2
4.3.3
4.3.4
4.3.4.1
4.3.4.2
4.4.0
4.4.1
4.4.2
4.4.3
4.4.4
4.4.4.1
4.5.0
4.5.1
4.5.2
4.5.3
4.6.0
4.6.1
4.6.10
4.6.11
4.6.13
4.6.14
4.6.15
4.6.16
4.6.17
4.6.18
4.6.2
4.6.3
4.6.4
4.6.5
4.7.0
4.7.1
4.7.10-fdroid
4.7.11
4.7.11-fdroid
4.7.12
4.7.12-fdroid
4.7.13
4.7.14
4.7.14-fdroid
4.7.15
4.7.15-fdroid
4.7.16
4.7.16-fdroid
4.7.17
4.7.18
4.7.19
4.7.2
4.7.20
4.7.21
4.7.22
4.7.3
4.7.4
4.7.5
4.7.6
4.7.7
4.7.8
4.7.9
4.8.0
4.8.1
4.8.10
4.8.16
4.8.17
4.8.18
4.8.19
4.8.2
4.8.20
4.8.21
4.8.22
4.8.3
4.8.4
4.8.5
4.8.6
4.8.7
4.8.8
4.8.9
4.9.0
4.9.1
4.9.10
4.9.11
4.9.12
4.9.13
4.9.14
4.9.15
4.9.2
4.9.3
4.9.4
4.9.5
4.9.6
4.9.7
4.9.8
5.0.0
5.0.1
5.0.2
5.1.0
5.1.2
5.1.3
5.1.4
5.1.5
5.2.0
5.2.1
5.3.0
5.3.1
5.3.2
5.3.3
5.3.4
5.3.5
5.3.6
6.0
6.0.1
6.0.2
6.0.3
6.0.4
6.0.5
6.0.6
6.1
6.1.1
6.1.2
6.1.3
6.2
6.3
6.3.1
6.4
6.4.1
6.4.3
6.4.5
6.5
6.5.1
6.5.2
6.5.3
6.5.4
6.5.5
6.5.6
6.6
6.6.1
6.6.2
6.6.3
6.6.4
6.6.5
6.7
6.7.1
6.7.2
6.7.3
6.8
6.8.1
6.9
6.9.1
6.9.2
6.9.3
7.0
7.1
7.1.1
7.1.2
7.2
7.2.1
7.2.2
7.3
7.3.1
7.3.2
7.4
7.4.1
7.4.2
7.5
7.6
7.6.1
7.7
7.8
8.0
8.0.1
8.1
8.10
8.11
8.2
8.2.1
8.3
8.4
8.5
8.6
8.6.1
8.7
8.7.1
8.8
8.9
8.9.1
8.9.2
9.0
9.1
9.2
9.3
9.3.1
9.4
9.4.1
9.5
9.6
9.7
9.7.1
9.7.2
9.7.3
lite-0.5.0
lite-0.5.1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '6f2635c9d6'
${ noResults }
tasks/android-aac-enc/jni/basic_op/basicop2.c

1625 lines
84 KiB
C
Raw Blame History

/*
** Copyright 2003-2010, VisualOn, Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
/*******************************************************************************
File: basicop2.c
Content: Basic arithmetic operators.
*******************************************************************************/
#include "typedef.h"
#include "basic_op.h"
/*___________________________________________________________________________
| |
| Functions |
|___________________________________________________________________________|
*/
/*___________________________________________________________________________
| |
| Function Name : saturate |
| |
| Purpose : |
| |
| Limit the 32 bit input to the range of a 16 bit word. |
| |
| Inputs : |
| |
| L_var1 |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!SATRUATE_IS_INLINE)
Word16 saturate(Word32 L_var1)
{
Word16 var_out;
if (L_var1 > 0X00007fffL)
{
var_out = MAX_16;
}
else if (L_var1 < (Word32) 0xffff8000L)
{
var_out = MIN_16;
}
else
{
var_out = extract_l(L_var1);
}
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : add |
| |
| Purpose : |
| |
| Performs the addition (var1+var2) with overflow control and saturation;|
| the 16 bit result is set at +32767 when overflow occurs or at -32768 |
| when underflow occurs. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!ADD_IS_INLINE)
Word16 add (Word16 var1, Word16 var2)
{
Word16 var_out;
Word32 L_sum;
L_sum = (Word32)var1 + (Word32)var2;
var_out = saturate(L_sum);
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : sub |
| |
| Purpose : |
| |
| Performs the subtraction (var1+var2) with overflow control and satu- |
| ration; the 16 bit result is set at +32767 when overflow occurs or at |
| -32768 when underflow occurs. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!SUB_IS_INLINE)
Word16 sub(Word16 var1, Word16 var2)
{
Word16 var_out;
Word32 L_diff;
L_diff = (Word32) var1 - var2;
var_out = saturate(L_diff);
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : abs_s |
| |
| Purpose : |
| |
| Absolute value of var1; abs_s(-32768) = 32767. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0x0000 0000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
//Word16 abs_s (Word16 var1)
//{
// Word16 var_out;
//
// if (var1 == MIN_16)
// {
// var_out = MAX_16;
// }
// else
// {
// if (var1 < 0)
// {
// var_out = (Word16)-var1;
// }
// else
// {
// var_out = var1;
// }
// }
//
// return (var_out);
//}
/*___________________________________________________________________________
| |
| Function Name : shl |
| |
| Purpose : |
| |
| Arithmetically shift the 16 bit input var1 left var2 positions.Zero fill|
| the var2 LSB of the result. If var2 is negative, arithmetically shift |
| var1 right by -var2 with sign extension. Saturate the result in case of |
| underflows or overflows. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!SHL_IS_INLINE)
Word16 shl (Word16 var1, Word16 var2)
{
Word16 var_out;
Word32 result;
if (var2 < 0)
{
if (var2 < -16)
var2 = -16;
var_out = shr (var1, (Word16)-var2);
}
else
{
result = (Word32) var1 *((Word32) 1 << var2);
if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result)))
{
//Overflow = 1;
var_out = (Word16)((var1 > 0) ? MAX_16 : MIN_16);
}
else
{
var_out = extract_l(result);
}
}
return (var_out);
}
#endif
// end
/*___________________________________________________________________________
| |
| Function Name : shr |
| |
| Purpose : |
| |
| Arithmetically shift the 16 bit input var1 right var2 positions with |
| sign extension. If var2 is negative, arithmetically shift var1 left by |
| -var2 with sign extension. Saturate the result in case of underflows or |
| overflows. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!SHR_IS_INLINE)
Word16 shr (Word16 var1, Word16 var2)
{
Word16 var_out;
if (var2 < 0)
{
if (var2 < -16)
var2 = -16;
var_out = shl (var1, (Word16)-var2);
}
else
{
if (var2 >= 15)
{
var_out = (Word16)((var1 < 0) ? -1 : 0);
}
else
{
if (var1 < 0)
{
var_out = (Word16)(~((~var1) >> var2));
}
else
{
var_out = (Word16)(var1 >> var2);
}
}
}
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : mult |
| |
| Purpose : |
| |
| Performs the multiplication of var1 by var2 and gives a 16 bit result |
| which is scaled i.e.: |
| mult(var1,var2) = extract_l(L_shr((var1 times var2),15)) and |
| mult(-32768,-32768) = 32767. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!MULT_IS_INLINE)
Word16 mult (Word16 var1, Word16 var2)
{
Word16 var_out;
Word32 L_product;
L_product = (Word32) var1 *(Word32) var2;
L_product = (L_product & (Word32) 0xffff8000L) >> 15;
if (L_product & (Word32) 0x00010000L)
L_product = L_product | (Word32) 0xffff0000L;
var_out = saturate(L_product);
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_mult |
| |
| Purpose : |
| |
| L_mult is the 32 bit result of the multiplication of var1 times var2 |
| with one shift left i.e.: |
| L_mult(var1,var2) = L_shl((var1 times var2),1) and |
| L_mult(-32768,-32768) = 2147483647. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
#if (!L_MULT_IS_INLINE)
Word32 L_mult(Word16 var1, Word16 var2)
{
Word32 L_var_out;
L_var_out = (Word32) var1 *(Word32) var2;
if (L_var_out != (Word32) 0x40000000L)
{
L_var_out <<= 1;
}
else
{
L_var_out = MAX_32;
}
return (L_var_out);
}
#endif
// end
/*___________________________________________________________________________
| |
| Function Name : negate |
| |
| Purpose : |
| |
| Negate var1 with saturation, saturate in the case where input is -32768:|
| negate(var1) = sub(0,var1). |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
//Word16 negate (Word16 var1)
//{
// Word16 var_out;
//
// var_out = (Word16)((var1 == MIN_16) ? MAX_16 : -var1);
//
// return (var_out);
//}
/*___________________________________________________________________________
| |
| Function Name : extract_h |
| |
| Purpose : |
| |
| Return the 16 MSB of L_var1. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| L_var1 |
| 32 bit long signed integer (Word32 ) whose value falls in the |
| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!EXTRACT_H_IS_INLINE)
Word16 extract_h (Word32 L_var1)
{
Word16 var_out;
var_out = (Word16) (L_var1 >> 16);
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : extract_l |
| |
| Purpose : |
| |
| Return the 16 LSB of L_var1. |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| L_var1 |
| 32 bit long signed integer (Word32 ) whose value falls in the |
| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!EXTRACT_L_IS_INLINE)
Word16 extract_l(Word32 L_var1)
{
Word16 var_out;
var_out = (Word16) L_var1;
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : round |
| |
| Purpose : |
| |
| Round the lower 16 bits of the 32 bit input number into the MS 16 bits |
| with saturation. Shift the resulting bits right by 16 and return the 16 |
| bit number: |
| round(L_var1) = extract_h(L_add(L_var1,32768)) |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| L_var1 |
| 32 bit long signed integer (Word32 ) whose value falls in the |
| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!ROUND_IS_INLINE)
Word16 round16(Word32 L_var1)
{
Word16 var_out;
Word32 L_rounded;
L_rounded = L_add (L_var1, (Word32) 0x00008000L);
var_out = extract_h (L_rounded);
return (var_out);
}
#endif
// end
/*___________________________________________________________________________
| |
| Function Name : L_mac |
| |
| Purpose : |
| |
| Multiply var1 by var2 and shift the result left by 1. Add the 32 bit |
| result to L_var3 with saturation, return a 32 bit result: |
| L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)). |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| L_var3 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
#if (!L_MSU_IS_INLINE)
Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2)
{
Word32 L_var_out;
Word32 L_product;
L_product = L_mult(var1, var2);
L_var_out = L_add (L_var3, L_product);
return (L_var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_msu |
| |
| Purpose : |
| |
| Multiply var1 by var2 and shift the result left by 1. Subtract the 32 |
| bit result to L_var3 with saturation, return a 32 bit result: |
| L_msu(L_var3,var1,var2) = L_sub(L_var3,L_mult(var1,var2)). |
| |
| Complexity weight : 1 |
| |
| Inputs : |
| |
| L_var3 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
#if (!L_MSU_IS_INLINE)
Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2)
{
Word32 L_var_out;
Word32 L_product;
L_product = L_mult(var1, var2);
L_var_out = L_sub (L_var3, L_product);
return (L_var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_add |
| |
| Purpose : |
| |
| 32 bits addition of the two 32 bits variables (L_var1+L_var2) with |
| overflow control and saturation; the result is set at +2147483647 when |
| overflow occurs or at -2147483648 when underflow occurs. |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| L_var1 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| L_var2 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
#if (!L_ADD_IS_INLINE)
Word32 L_add (Word32 L_var1, Word32 L_var2)
{
Word32 L_var_out;
L_var_out = L_var1 + L_var2;
if (((L_var1 ^ L_var2) & MIN_32) == 0)
{
if ((L_var_out ^ L_var1) & MIN_32)
{
L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32;
//Overflow = 1;
}
}
return (L_var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_sub |
| |
| Purpose : |
| |
| 32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with |
| overflow control and saturation; the result is set at +2147483647 when |
| overflow occurs or at -2147483648 when underflow occurs. |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| L_var1 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| L_var2 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
#if (!L_SUB_IS_INLINE)
Word32 L_sub(Word32 L_var1, Word32 L_var2)
{
Word32 L_var_out;
L_var_out = L_var1 - L_var2;
if (((L_var1 ^ L_var2) & MIN_32) != 0)
{
if ((L_var_out ^ L_var1) & MIN_32)
{
L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32;
//Overflow = 1;
}
}
return (L_var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_negate |
| |
| Purpose : |
| |
| Negate the 32 bit variable L_var1 with saturation; saturate in the case |
| where input is -2147483648 (0x8000 0000). |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| L_var1 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
//Word32 L_negate (Word32 L_var1)
//{
// Word32 L_var_out;
//
// L_var_out = (L_var1 == MIN_32) ? MAX_32 : -L_var1;
//
// return (L_var_out);
//}
/*___________________________________________________________________________
| |
| Function Name : mult_r |
| |
| Purpose : |
| |
| Same as mult with rounding, i.e.: |
| mult_r(var1,var2) = extract_l(L_shr(((var1 * var2) + 16384),15)) and |
| mult_r(-32768,-32768) = 32767. |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!MULT_R_IS_INLINE)
Word16 mult_r (Word16 var1, Word16 var2)
{
Word16 var_out;
Word32 L_product_arr;
L_product_arr = (Word32) var1 *(Word32) var2; /* product */
L_product_arr += (Word32) 0x00004000L; /* round */
L_product_arr &= (Word32) 0xffff8000L;
L_product_arr >>= 15; /* shift */
if (L_product_arr & (Word32) 0x00010000L) /* sign extend when necessary */
{
L_product_arr |= (Word32) 0xffff0000L;
}
var_out = saturate(L_product_arr);
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_shl |
| |
| Purpose : |
| |
| Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero |
| fill the var2 LSB of the result. If var2 is negative, arithmetically |
| shift L_var1 right by -var2 with sign extension. Saturate the result in |
| case of underflows or overflows. |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| L_var1 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
#if (!L_SHL_IS_INLINE)
Word32 L_shl (Word32 L_var1, Word16 var2)
{
Word32 L_var_out = 0L;
if (var2 <= 0)
{
L_var1 = L_shr(L_var1, (Word16)-var2);
}
else
{
for (; var2 > 0; var2--)
{
if (L_var1 > (Word32) 0X3fffffffL)
{
return MAX_32;
}
else
{
if (L_var1 < (Word32) 0xc0000000L)
{
return MIN_32;
}
}
L_var1 <<= 1;
}
}
return (L_var1);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_shr |
| |
| Purpose : |
| |
| Arithmetically shift the 32 bit input L_var1 right var2 positions with |
| sign extension. If var2 is negative, arithmetically shift L_var1 left |
| by -var2 and zero fill the -var2 LSB of the result. Saturate the result |
| in case of underflows or overflows. |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| L_var1 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
#if (!L_SHR_IS_INLINE)
Word32 L_shr (Word32 L_var1, Word16 var2)
{
Word32 L_var_out;
if (var2 < 0)
{
L_var_out = L_shl (L_var1, (Word16)-var2);
}
else
{
if (var2 >= 31)
{
L_var_out = (L_var1 < 0L) ? -1 : 0;
}
else
{
if (L_var1 < 0)
{
L_var_out = ~((~L_var1) >> var2);
}
else
{
L_var_out = L_var1 >> var2;
}
}
}
return (L_var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : shr_r |
| |
| Purpose : |
| |
| Same as shr(var1,var2) but with rounding. Saturate the result in case of|
| underflows or overflows : |
| - If var2 is greater than zero : |
| if (sub(shl(shr(var1,var2),1),shr(var1,sub(var2,1)))) |
| is equal to zero |
| then |
| shr_r(var1,var2) = shr(var1,var2) |
| else |
| shr_r(var1,var2) = add(shr(var1,var2),1) |
| - If var2 is less than or equal to zero : |
| shr_r(var1,var2) = shr(var1,var2). |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!SHR_R_IS_INLINE)
Word16 shr_r (Word16 var1, Word16 var2)
{
Word16 var_out;
if (var2 > 15)
{
var_out = 0;
}
else
{
var_out = shr (var1, var2);
if (var2 > 0)
{
if ((var1 & ((Word16) 1 << (var2 - 1))) != 0)
{
var_out++;
}
}
}
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : mac_r |
| |
| Purpose : |
| |
| Multiply var1 by var2 and shift the result left by 1. Add the 32 bit |
| result to L_var3 with saturation. Round the LS 16 bits of the result |
| into the MS 16 bits with saturation and shift the result right by 16. |
| Return a 16 bit result. |
| mac_r(L_var3,var1,var2) = round(L_mac(L_var3,var1,var2)) |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| L_var3 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0x0000 8000 <= L_var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!MAC_R_IS_INLINE)
Word16 mac_r (Word32 L_var3, Word16 var1, Word16 var2)
{
Word16 var_out;
L_var3 = L_mac (L_var3, var1, var2);
L_var3 = L_add (L_var3, (Word32) 0x00008000L);
var_out = extract_h (L_var3);
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : msu_r |
| |
| Purpose : |
| |
| Multiply var1 by var2 and shift the result left by 1. Subtract the 32 |
| bit result to L_var3 with saturation. Round the LS 16 bits of the res- |
| ult into the MS 16 bits with saturation and shift the result right by |
| 16. Return a 16 bit result. |
| msu_r(L_var3,var1,var2) = round(L_msu(L_var3,var1,var2)) |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| L_var3 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0x0000 8000 <= L_var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
#if (!MSU_R_IS_INLINE)
Word16 msu_r (Word32 L_var3, Word16 var1, Word16 var2)
{
Word16 var_out;
L_var3 = L_msu (L_var3, var1, var2);
L_var3 = L_add (L_var3, (Word32) 0x00008000L);
var_out = extract_h (L_var3);
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_deposit_h |
| |
| Purpose : |
| |
| Deposit the 16 bit var1 into the 16 MS bits of the 32 bit output. The |
| 16 LS bits of the output are zeroed. |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= var_out <= 0x7fff 0000. |
|___________________________________________________________________________|
*/
//Word32 L_deposit_h (Word16 var1)
//{
// Word32 L_var_out;
//
// L_var_out = (Word32) var1 << 16;
//
// return (L_var_out);
//}
/*___________________________________________________________________________
| |
| Function Name : L_deposit_l |
| |
| Purpose : |
| |
| Deposit the 16 bit var1 into the 16 LS bits of the 32 bit output. The |
| 16 MS bits of the output are sign extended. |
| |
| Complexity weight : 2 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0xFFFF 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
//Word32 L_deposit_l (Word16 var1)
//{
// Word32 L_var_out;
//
// L_var_out = (Word32) var1;
//
// return (L_var_out);
//}
/*___________________________________________________________________________
| |
| Function Name : L_shr_r |
| |
| Purpose : |
| |
| Same as L_shr(L_var1,var2) but with rounding. Saturate the result in |
| case of underflows or overflows : |
| - If var2 is greater than zero : |
| if (L_sub(L_shl(L_shr(L_var1,var2),1),L_shr(L_var1,sub(var2,1))))|
| is equal to zero |
| then |
| L_shr_r(L_var1,var2) = L_shr(L_var1,var2) |
| else |
| L_shr_r(L_var1,var2) = L_add(L_shr(L_var1,var2),1) |
| - If var2 is less than or equal to zero : |
| L_shr_r(L_var1,var2) = L_shr(L_var1,var2). |
| |
| Complexity weight : 3 |
| |
| Inputs : |
| |
| L_var1 |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= var1 <= 0x7fff ffff. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
#if (!L_SHR_R_IS_INLINE)
Word32 L_shr_r (Word32 L_var1, Word16 var2)
{
Word32 L_var_out;
if (var2 > 31)
{
L_var_out = 0;
}
else
{
L_var_out = L_shr (L_var1, var2);
if (var2 > 0)
{
if ((L_var1 & ((Word32) 1 << (var2 - 1))) != 0)
{
L_var_out++;
}
}
}
return (L_var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : L_abs |
| |
| Purpose : |
| |
| Absolute value of L_var1; Saturate in case where the input is |
| -214783648 |
| |
| Complexity weight : 3 |
| |
| Inputs : |
| |
| L_var1 |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= var1 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| L_var_out |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x0000 0000 <= var_out <= 0x7fff ffff. |
|___________________________________________________________________________|
*/
//Word32 L_abs (Word32 L_var1)
//{
// Word32 L_var_out;
//
// if (L_var1 == MIN_32)
// {
// L_var_out = MAX_32;
// }
// else
// {
// if (L_var1 < 0)
// {
// L_var_out = -L_var1;
// }
// else
// {
// L_var_out = L_var1;
// }
// }
//
// return (L_var_out);
//}
/*___________________________________________________________________________
| |
| Function Name : norm_s |
| |
| Purpose : |
| |
| Produces the number of left shift needed to normalize the 16 bit varia- |
| ble var1 for positive values on the interval with minimum of 16384 and |
| maximum of 32767, and for negative values on the interval with minimum |
| of -32768 and maximum of -16384; in order to normalize the result, the |
| following operation must be done : |
| norm_var1 = shl(var1,norm_s(var1)). |
| |
| Complexity weight : 15 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0x0000 0000 <= var_out <= 0x0000 000f. |
|___________________________________________________________________________|
*/
#if (!NORM_S_IS_INLINE)
Word16 norm_s (Word16 var1)
{
Word16 var_out;
if (var1 == 0)
{
var_out = 0;
}
else
{
if (var1 == -1)
{
var_out = 15;
}
else
{
if (var1 < 0)
{
var1 = (Word16)~var1;
}
for (var_out = 0; var1 < 0x4000; var_out++)
{
var1 <<= 1;
}
}
}
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : div_s |
| |
| Purpose : |
| |
| Produces a result which is the fractional integer division of var1 by |
| var2; var1 and var2 must be positive and var2 must be greater or equal |
| to var1; the result is positive (leading bit equal to 0) and truncated |
| to 16 bits. |
| If var1 = var2 then div(var1,var2) = 32767. |
| |
| Complexity weight : 18 |
| |
| Inputs : |
| |
| var1 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0x0000 0000 <= var1 <= var2 and var2 != 0. |
| |
| var2 |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : var1 <= var2 <= 0x0000 7fff and var2 != 0. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0x0000 0000 <= var_out <= 0x0000 7fff. |
| It's a Q15 value (point between b15 and b14). |
|___________________________________________________________________________|
*/
#if (!DIV_S_IS_INLINE)
Word16 div_s (Word16 var1, Word16 var2)
{
Word16 var_out = 0;
Word16 iteration;
Word32 L_num;
Word32 L_denom;
if (var1 == 0)
{
var_out = 0;
}
else
{
if (var1 == var2)
{
var_out = MAX_16;
}
else
{
L_num = L_deposit_l (var1);
L_denom = L_deposit_l (var2);
for (iteration = 0; iteration < 15; iteration++)
{
var_out <<= 1;
L_num <<= 1;
if (L_num >= L_denom)
{
L_num = L_sub(L_num, L_denom);
var_out = add (var_out, 1);
}
}
}
}
return (var_out);
}
#endif
/*___________________________________________________________________________
| |
| Function Name : norm_l |
| |
| Purpose : |
| |
| Produces the number of left shifts needed to normalize the 32 bit varia-|
| ble L_var1 for positive values on the interval with minimum of |
| 1073741824 and maximum of 2147483647, and for negative values on the in-|
| terval with minimum of -2147483648 and maximum of -1073741824; in order |
| to normalize the result, the following operation must be done : |
| norm_L_var1 = L_shl(L_var1,norm_l(L_var1)). |
| |
| Complexity weight : 30 |
| |
| Inputs : |
| |
| L_var1 |
| 32 bit long signed integer (Word32) whose value falls in the |
| range : 0x8000 0000 <= var1 <= 0x7fff ffff. |
| |
| Outputs : |
| |
| none |
| |
| Return Value : |
| |
| var_out |
| 16 bit short signed integer (Word16) whose value falls in the |
| range : 0x0000 0000 <= var_out <= 0x0000 001f. |
|___________________________________________________________________________|
*/
#if (!NORM_L_IS_INLINE)
Word16 norm_l (Word32 L_var1)
{
Word16 var_out;
if (L_var1 == 0)
{
var_out = 0;
}
else
{
if (L_var1 == (Word32) 0xffffffffL)
{
var_out = 31;
}
else
{
if (L_var1 < 0)
{
L_var1 = ~L_var1;
}
for (var_out = 0; L_var1 < (Word32) 0x40000000L; var_out++)
{
L_var1 <<= 1;
}
}
}
return (var_out);
}
#endif
Reference in New Issue View Git Blame Copy Permalink