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.173
22    ANSI-C code for the Adaptive Multi-Rate - Wideband (AMR-WB) speech codec
23    Available from http://www.3gpp.org
24
25(C) 2007, 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
32
33
34 Pathname: ./src/pvamrwbdecoder_basic_op.h
35
36     Date: 05/07/2007
37
38------------------------------------------------------------------------------
39 REVISION HISTORY
40
41 Description:
42------------------------------------------------------------------------------
43 INCLUDE DESCRIPTION
44
45------------------------------------------------------------------------------
46*/
47
48
49#ifndef PVAMRWBDECODER_BASIC_OP_H
50#define PVAMRWBDECODER_BASIC_OP_H
51
52
53#include "normalize_amr_wb.h"
54
55
56#define MAX_32 (int32)0x7fffffffL
57#define MIN_32 (int32)0x80000000L
58
59#define MAX_16 (int16)+32767    /* 0x7fff */
60#define MIN_16 (int16)-32768    /* 0x8000 */
61
62
63
64
65/*----------------------------------------------------------------------------
66     Function Name : negate_int16
67
68     Negate var1 with saturation, saturate in the case where input is -32768:
69                  negate(var1) = sub(0,var1).
70
71     Inputs :
72      var1
73               16 bit short signed integer (int16) whose value falls in the
74               range : 0x8000 <= var1 <= 0x7fff.
75
76     Outputs :
77      none
78
79     Return Value :
80               16 bit short signed integer (int16) whose value falls in the
81               range : 0x8000 <= var_out <= 0x7fff.
82 ----------------------------------------------------------------------------*/
83
84__inline int16 negate_int16(int16 var1)
85{
86    return (((var1 == MIN_16) ? MAX_16 : -var1));
87}
88
89
90/*----------------------------------------------------------------------------
91
92     Function Name : shl_int16
93
94     Arithmetically shift the 16 bit input var1 left var2 positions.Zero fill
95     the var2 LSB of the result. If var2 is negative, arithmetically shift
96     var1 right by -var2 with sign extension. Saturate the result in case of
97     underflows or overflows.
98
99     Inputs :
100      var1
101               16 bit short signed integer (int16) whose value falls in the
102               range : 0x8000 <= var1 <= 0x7fff.
103
104      var2
105               16 bit short signed integer (int16) whose value falls in the
106               range : 0x8000 <= var1 <= 0x7fff.
107
108     Return Value :
109      var_out
110               16 bit short signed integer (int16) whose value falls in the
111               range : 0x8000 <= var_out <= 0x7fff.
112 ----------------------------------------------------------------------------*/
113
114__inline int16 shl_int16(int16 var1, int16 var2)
115{
116    int16 var_out;
117
118    if (var2 < 0)
119    {
120        var2 = (-var2) & (0xf);
121        var_out = var1 >> var2;
122    }
123    else
124    {
125        var2 &= 0xf;
126        var_out = var1 << var2;
127        if (var_out >> var2 != var1)
128        {
129            var_out = (var1 >> 15) ^ MAX_16;
130        }
131    }
132    return (var_out);
133}
134
135
136/*----------------------------------------------------------------------------
137
138     Function Name : shl_int32
139
140     Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero
141     fill the var2 LSB of the result. If var2 is negative, arithmetically
142     shift L_var1 right by -var2 with sign extension. Saturate the result in
143     case of underflows or overflows.
144
145     Inputs :
146      L_var1   32 bit long signed integer (int32) whose value falls in the
147               range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
148
149      var2
150               16 bit short signed integer (int16) whose value falls in the
151               range :  8000 <= var2 <= 7fff.
152     Return Value :
153               32 bit long signed integer (int32) whose value falls in the
154               range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
155
156 ----------------------------------------------------------------------------*/
157
158__inline int32 shl_int32(int32 L_var1, int16 var2)
159{
160    int32 L_var_out;
161
162    if (var2 > 0)
163    {
164        L_var_out = L_var1 << var2;
165        if (L_var_out >> var2 != L_var1)
166        {
167            L_var_out = (L_var1 >> 31) ^ MAX_32;
168        }
169    }
170    else
171    {
172        var2 = (-var2) & (0xf);
173        L_var_out = L_var1 >> var2;
174    }
175
176    return (L_var_out);
177}
178
179
180/*----------------------------------------------------------------------------
181
182     Function Name : shr_int32
183
184     Arithmetically shift the 32 bit input L_var1 right var2 positions with
185     sign extension. If var2 is negative, arithmetically shift L_var1 left
186     by -var2 and zero fill the -var2 LSB of the result. Saturate the result
187     in case of underflows or overflows.
188
189     Inputs :
190      L_var1   32 bit long signed integer (int32) whose value falls in the
191               range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
192
193      var2
194               16 bit short signed integer (int16) whose value falls in the
195               range :  8000 <= var2 <= 7fff.
196     Return Value :
197               32 bit long signed integer (int32) whose value falls in the
198               range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
199
200 ----------------------------------------------------------------------------*/
201
202__inline int32 shr_int32(int32 L_var1, int16 var2)
203{
204    int32 L_var_out;
205
206    if (var2 >= 0)
207    {
208        L_var_out = L_var1 >> (var2 & 0x1f);
209    }
210    else
211    {
212        var2 = (int16)(-var2);
213        var2 &= 0x1f;
214        L_var_out = L_var1 << var2;
215        if (L_var_out >> var2 != L_var1)
216        {
217            L_var_out = (L_var1 >> 31) ^ MAX_32;
218        }
219
220    }
221    return (L_var_out);
222}
223
224
225
226
227
228
229#if defined(PV_ARM_V5)
230
231#include "pvamrwbdecoder_basic_op_armv5.h"
232
233#elif defined(PV_ARM_GCC_V5)
234
235#include "pvamrwbdecoder_basic_op_gcc_armv5.h"
236
237#else
238
239#ifndef C_EQUIVALENT
240#define C_EQUIVALENT        // default to C_EQUIVALENT
241#endif
242
243#include "pvamrwbdecoder_basic_op_cequivalent.h"
244
245#endif
246
247
248#endif   /*  PVAMRWBDECODER_BASIC_OP_H  */
249
250