/media/libstagefright/codecs/amrwb/src/pvamrwbdecoder_basic_op_cequivalent.h

https://bitbucket.org/aways/android_frameworks_av · C Header · 545 lines · 169 code · 78 blank · 298 comment · 28 complexity · 965ad212d192f208a85e083c9f3db3df MD5 · raw file

  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. 3GPP TS 26.173
  21. ANSI-C code for the Adaptive Multi-Rate - Wideband (AMR-WB) speech codec
  22. Available from http://www.3gpp.org
  23. (C) 2007, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
  24. Permission to distribute, modify and use this file under the standard license
  25. terms listed above has been obtained from the copyright holder.
  26. ****************************************************************************************/
  27. /*
  28. ------------------------------------------------------------------------------
  29. Pathname: ./src/pvamrwbdecoder_basic_op_cequivalent.h
  30. Date: 05/07/2007
  31. ------------------------------------------------------------------------------
  32. REVISION HISTORY
  33. Description:
  34. ------------------------------------------------------------------------------
  35. INCLUDE DESCRIPTION
  36. ------------------------------------------------------------------------------
  37. */
  38. #ifndef PVAMRWBDECODER_BASIC_OP_CEQUIVALENT_H
  39. #define PVAMRWBDECODER_BASIC_OP_CEQUIVALENT_H
  40. #ifdef __cplusplus
  41. extern "C"
  42. {
  43. #endif
  44. #include "normalize_amr_wb.h"
  45. #if defined(C_EQUIVALENT)
  46. /*----------------------------------------------------------------------------
  47. Function Name : add_int16
  48. Purpose :
  49. Performs the addition (var1+var2) with overflow control and saturation;
  50. the 16 bit result is set at +32767 when overflow occurs or at -32768
  51. when underflow occurs.
  52. Inputs :
  53. var1
  54. 16 bit short signed integer (int16) whose value falls in the
  55. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  56. var2
  57. 16 bit short signed integer (int16) whose value falls in the
  58. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  59. Outputs :
  60. none
  61. Return Value :
  62. 16 bit short signed integer (int16) whose value falls in the
  63. range : 0xffff 8000 <= var_out <= 0x0000 7fff.
  64. ----------------------------------------------------------------------------*/
  65. __inline int16 add_int16(int16 var1, int16 var2)
  66. {
  67. int32 L_sum;
  68. L_sum = (int32) var1 + var2;
  69. if ((L_sum >> 15) != (L_sum >> 31))
  70. {
  71. L_sum = (L_sum >> 31) ^ MAX_16;
  72. }
  73. return ((int16)(L_sum));
  74. }
  75. /*----------------------------------------------------------------------------
  76. Function Name : sub_int16
  77. Performs the subtraction (var1+var2) with overflow control and satu-
  78. ration; the 16 bit result is set at +32767 when overflow occurs or at
  79. -32768 when underflow occurs.
  80. Inputs :
  81. var1
  82. 16 bit short signed integer (int16) whose value falls in the
  83. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  84. var2
  85. 16 bit short signed integer (int16) whose value falls in the
  86. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  87. Outputs :
  88. none
  89. Return Value :
  90. 16 bit short signed integer (int16) whose value falls in the
  91. range : 0xffff 8000 <= var_out <= 0x0000 7fff.
  92. ----------------------------------------------------------------------------*/
  93. __inline int16 sub_int16(int16 var1, int16 var2)
  94. {
  95. int32 L_diff;
  96. L_diff = (int32) var1 - var2;
  97. if ((L_diff >> 15) != (L_diff >> 31))
  98. {
  99. L_diff = (L_diff >> 31) ^ MAX_16;
  100. }
  101. return ((int16)(L_diff));
  102. }
  103. /*----------------------------------------------------------------------------
  104. Function Name : mult_int16
  105. Performs the multiplication of var1 by var2 and gives a 16 bit result
  106. which is scaled i.e.:
  107. mult_int16(var1,var2) = extract_l(L_shr((var1 times var2),15)) and
  108. mult_int16(-32768,-32768) = 32767.
  109. Inputs :
  110. var1
  111. 16 bit short signed integer (int16) whose value falls in the
  112. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  113. var2
  114. 16 bit short signed integer (int16) whose value falls in the
  115. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  116. Return Value :
  117. 16 bit short signed integer (int16) whose value falls in the
  118. range : 0xffff 8000 <= var_out <= 0x0000 7fff.
  119. ----------------------------------------------------------------------------*/
  120. __inline int16 mult_int16(int16 var1, int16 var2)
  121. {
  122. int32 L_product;
  123. L_product = ((int32) var1 * (int32) var2) >> 15;
  124. if ((L_product >> 15) != (L_product >> 31))
  125. {
  126. L_product = (L_product >> 31) ^ MAX_16;
  127. }
  128. return ((int16)L_product);
  129. }
  130. /*----------------------------------------------------------------------------
  131. Function Name : add_int32
  132. 32 bits addition of the two 32 bits variables (L_var1+L_var2) with
  133. overflow control and saturation; the result is set at +2147483647 when
  134. overflow occurs or at -2147483648 when underflow occurs.
  135. Inputs :
  136. L_var1 32 bit long signed integer (int32) whose value falls in the
  137. range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
  138. L_var2 32 bit long signed integer (int32) whose value falls in the
  139. range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
  140. Return Value :
  141. L_var_out
  142. 32 bit long signed integer (int32) whose value falls in the
  143. range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
  144. ----------------------------------------------------------------------------*/
  145. __inline int32 add_int32(int32 L_var1, int32 L_var2)
  146. {
  147. int32 L_var_out;
  148. L_var_out = L_var1 + L_var2;
  149. if (((L_var1 ^ L_var2) & MIN_32) == 0) /* same sign ? */
  150. {
  151. if ((L_var_out ^ L_var1) & MIN_32) /* addition matches sign ? */
  152. {
  153. L_var_out = (L_var1 >> 31) ^ MAX_32;
  154. }
  155. }
  156. return (L_var_out);
  157. }
  158. /*----------------------------------------------------------------------------
  159. Function Name : sub_int32
  160. 32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with
  161. overflow control and saturation; the result is set at +2147483647 when
  162. overflow occurs or at -2147483648 when underflow occurs.
  163. Inputs :
  164. L_var1 32 bit long signed integer (int32) whose value falls in the
  165. range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
  166. L_var2 32 bit long signed integer (int32) whose value falls in the
  167. range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
  168. Return Value :
  169. L_var_out
  170. 32 bit long signed integer (int32) whose value falls in the
  171. range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
  172. ----------------------------------------------------------------------------*/
  173. __inline int32 sub_int32(int32 L_var1, int32 L_var2)
  174. {
  175. int32 L_var_out;
  176. L_var_out = L_var1 - L_var2;
  177. if (((L_var1 ^ L_var2) & MIN_32) != 0) /* different sign ? */
  178. {
  179. if ((L_var_out ^ L_var1) & MIN_32) /* difference matches sign ? */
  180. {
  181. L_var_out = (L_var1 >> 31) ^ MAX_32;
  182. }
  183. }
  184. return (L_var_out);
  185. }
  186. /*----------------------------------------------------------------------------
  187. Function Name : mac_16by16_to_int32
  188. Multiply var1 by var2 and shift the result left by 1. Add the 32 bit
  189. result to L_var3 with saturation, return a 32 bit result:
  190. L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)).
  191. Inputs :
  192. L_var3 32 bit long signed integer (int32) whose value falls in the
  193. range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
  194. var1
  195. 16 bit short signed integer (int16) whose value falls in the
  196. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  197. var2
  198. 16 bit short signed integer (int16) whose value falls in the
  199. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  200. Return Value :
  201. 32 bit long signed integer (int32) whose value falls in the
  202. range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
  203. ----------------------------------------------------------------------------*/
  204. __inline int32 mac_16by16_to_int32(int32 L_var3, int16 var1, int16 var2)
  205. {
  206. int32 L_var_out;
  207. int32 L_mul;
  208. L_mul = ((int32) var1 * (int32) var2);
  209. if (L_mul != 0x40000000)
  210. {
  211. L_mul <<= 1;
  212. }
  213. else
  214. {
  215. L_mul = MAX_32; /* saturation */
  216. }
  217. L_var_out = L_var3 + L_mul;
  218. if (((L_mul ^ L_var3) & MIN_32) == 0) /* same sign ? */
  219. {
  220. if ((L_var_out ^ L_var3) & MIN_32) /* addition matches sign ? */
  221. {
  222. L_var_out = (L_var3 >> 31) ^ MAX_32;
  223. }
  224. }
  225. return (L_var_out);
  226. }
  227. /*----------------------------------------------------------------------------
  228. Function Name : msu_16by16_from_int32
  229. Multiply var1 by var2 and shift the result left by 1. Subtract the 32 bit
  230. result to L_var3 with saturation, return a 32 bit result:
  231. L_msu(L_var3,var1,var2) = L_sub(L_var3,L_mult(var1,var2)).
  232. Inputs :
  233. L_var3 32 bit long signed integer (int32) whose value falls in the
  234. range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
  235. var1
  236. 16 bit short signed integer (int16) whose value falls in the
  237. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  238. var2
  239. 16 bit short signed integer (int16) whose value falls in the
  240. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  241. Return Value :
  242. 32 bit long signed integer (int32) whose value falls in the
  243. range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
  244. ----------------------------------------------------------------------------*/
  245. __inline int32 msu_16by16_from_int32(int32 L_var3, int16 var1, int16 var2)
  246. {
  247. int32 L_var_out;
  248. int32 L_mul;
  249. L_mul = ((int32) var1 * (int32) var2);
  250. if (L_mul != 0x40000000)
  251. {
  252. L_mul <<= 1;
  253. }
  254. else
  255. {
  256. L_mul = MAX_32; /* saturation */
  257. }
  258. L_var_out = L_var3 - L_mul;
  259. if (((L_mul ^ L_var3) & MIN_32) != 0) /* different sign ? */
  260. {
  261. if ((L_var_out ^ L_var3) & MIN_32) /* difference matches sign ? */
  262. {
  263. L_var_out = (L_var3 >> 31) ^ MAX_32;
  264. }
  265. }
  266. return (L_var_out);
  267. }
  268. /*----------------------------------------------------------------------------
  269. Function Name : mul_16by16_to_int32
  270. mul_16by16_to_int32 is the 32 bit result of the multiplication of var1
  271. times var2 with one shift left i.e.:
  272. L_mult(var1,var2) = L_shl((var1 times var2),1) and
  273. L_mult(-32768,-32768) = 2147483647.
  274. Inputs :
  275. var1
  276. 16 bit short signed integer (int16) whose value falls in the
  277. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  278. var2
  279. 16 bit short signed integer (int16) whose value falls in the
  280. range : 0xffff 8000 <= var1 <= 0x0000 7fff.
  281. Return Value :
  282. 32 bit long signed integer (int32) whose value falls in the
  283. range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
  284. ----------------------------------------------------------------------------*/
  285. __inline int32 mul_16by16_to_int32(int16 var1, int16 var2)
  286. {
  287. int32 L_mul;
  288. L_mul = ((int32) var1 * (int32) var2);
  289. if (L_mul != 0x40000000)
  290. {
  291. L_mul <<= 1;
  292. }
  293. else
  294. {
  295. L_mul = MAX_32; /* saturation */
  296. }
  297. return (L_mul);
  298. }
  299. /*----------------------------------------------------------------------------
  300. Function Name : amr_wb_round
  301. Round the lower 16 bits of the 32 bit input number into the MS 16 bits
  302. with saturation. Shift the resulting bits right by 16 and return the 16
  303. bit number:
  304. round(L_var1) = extract_h(L_add(L_var1,32768))
  305. Inputs :
  306. L_var1
  307. 32 bit long signed integer (int32 ) whose value falls in the
  308. range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
  309. Return Value :
  310. 16 bit short signed integer (int16) whose value falls in the
  311. range : 0xffff 8000 <= var_out <= 0x0000 7fff.
  312. ----------------------------------------------------------------------------*/
  313. __inline int16 amr_wb_round(int32 L_var1)
  314. {
  315. if (L_var1 != MAX_32)
  316. {
  317. L_var1 += 0x00008000L;
  318. }
  319. return ((int16)(L_var1 >> 16));
  320. }
  321. /*----------------------------------------------------------------------------
  322. Function Name : amr_wb_shl1_round
  323. Shift the 32 bit input number to the left by 1, round up the result and
  324. shift down by 16
  325. amr_wb_shl1_round(L_var1) = round(L_shl(L_var1,1))
  326. Inputs :
  327. L_var1
  328. 32 bit long signed integer (int32 ) whose value falls in the
  329. range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
  330. Return Value :
  331. 16 bit short signed integer (int16) whose value falls in the
  332. range : 0xffff 8000 <= var_out <= 0x0000 7fff.
  333. ----------------------------------------------------------------------------*/
  334. __inline int16 amr_wb_shl1_round(int32 L_var1)
  335. {
  336. int16 var_out;
  337. if ((L_var1 << 1) >> 1 == L_var1)
  338. {
  339. var_out = (int16)((L_var1 + 0x00004000) >> 15);
  340. }
  341. else
  342. {
  343. var_out = (int16)(((L_var1 >> 31) ^ MAX_32) >> 16);
  344. }
  345. return (var_out);
  346. }
  347. /*----------------------------------------------------------------------------
  348. Function Name : mul_32by16
  349. Multiply a 16 bit integer by a 32 bit (DPF). The result is divided
  350. by 2^15
  351. L_32 = (hi1*lo2)<<1 + ((lo1*lo2)>>15)<<1
  352. Inputs :
  353. hi hi part of 32 bit number.
  354. lo lo part of 32 bit number.
  355. n 16 bit number.
  356. ----------------------------------------------------------------------------*/
  357. __inline int32 mul_32by16(int16 hi, int16 lo, int16 n)
  358. {
  359. return (((((int32)hi*n)) + ((((int32)lo*n) >> 15))) << 1);
  360. }
  361. __inline int32 fxp_mac_16by16(int16 var1, int16 var2, int32 L_add)
  362. {
  363. L_add += (int32)var1 * var2;
  364. return L_add;
  365. }
  366. __inline int32 fxp_mul_16by16(int16 var1, const int16 var2)
  367. {
  368. int32 L_mul = (int32)var1 * var2;
  369. return L_mul;
  370. }
  371. __inline int32 fxp_mul32_by_16b(int32 L_var1, const int32 L_var2)
  372. {
  373. int32 L_mul = (int32)(((int64)L_var1 * (L_var2 << 16)) >> 32);
  374. return L_mul;
  375. }
  376. #ifdef __cplusplus
  377. }
  378. #endif
  379. #endif
  380. #endif /* PVAMRWBDECODER_BASIC_OP_CEQUIVALENT_H */