add.c
上传用户:sy_wanhua
上传日期:2013-07-25
资源大小:3048k
文件大小:6k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

C/C++

  1. /*
  2.  * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
  3.  * Universitaet Berlin.  See the accompanying file "COPYRIGHT" for
  4.  * details.  THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
  5.  */
  6. /* $Header: /cvsroot/vocal.modules/contrib/libsndfile-0.0.22/src/GSM610/add.c,v 1.2 2001/02/27 19:22:53 deepalir Exp $ */
  7. /*
  8.  *  See private.h for the more commonly used macro versions.
  9.  */
  10. #include <stdio.h>
  11. #include <assert.h>
  12. #include "private.h"
  13. #include "gsm.h"
  14. #include "proto.h"
  15. #define saturate(x) 
  16. ((x) < MIN_WORD ? MIN_WORD : (x) > MAX_WORD ? MAX_WORD: (x))
  17. word gsm_add P2((a,b), word a, word b)
  18. {
  19. longword sum = (longword)a + (longword)b;
  20. return saturate(sum);
  21. }
  22. word gsm_sub P2((a,b), word a, word b)
  23. {
  24. longword diff = (longword)a - (longword)b;
  25. return saturate(diff);
  26. }
  27. word gsm_mult P2((a,b), word a, word b)
  28. {
  29. if (a == MIN_WORD && b == MIN_WORD) return MAX_WORD;
  30. else return SASR( (longword)a * (longword)b, 15 );
  31. }
  32. word gsm_mult_r P2((a,b), word a, word b)
  33. {
  34. if (b == MIN_WORD && a == MIN_WORD) return MAX_WORD;
  35. else {
  36. longword prod = (longword)a * (longword)b + 16384;
  37. prod >>= 15;
  38. return prod & 0xFFFF;
  39. }
  40. }
  41. word gsm_abs P1((a), word a)
  42. {
  43. return a < 0 ? (a == MIN_WORD ? MAX_WORD : -a) : a;
  44. }
  45. longword gsm_L_mult P2((a,b),word a, word b)
  46. {
  47. assert( a != MIN_WORD || b != MIN_WORD );
  48. return ((longword)a * (longword)b) << 1;
  49. }
  50. longword gsm_L_add P2((a,b), longword a, longword b)
  51. {
  52. if (a < 0) {
  53. if (b >= 0) return a + b;
  54. else {
  55. ulongword A = (ulongword)-(a + 1) + (ulongword)-(b + 1);
  56. return A >= MAX_LONGWORD ? MIN_LONGWORD :-(longword)A-2;
  57. }
  58. }
  59. else if (b <= 0) return a + b;
  60. else {
  61. ulongword A = (ulongword)a + (ulongword)b;
  62. return A > MAX_LONGWORD ? MAX_LONGWORD : A;
  63. }
  64. }
  65. longword gsm_L_sub P2((a,b), longword a, longword b)
  66. {
  67. if (a >= 0) {
  68. if (b >= 0) return a - b;
  69. else {
  70. /* a>=0, b<0 */
  71. ulongword A = (ulongword)a + -(b + 1);
  72. return A >= MAX_LONGWORD ? MAX_LONGWORD : (A + 1);
  73. }
  74. }
  75. else if (b <= 0) return a - b;
  76. else {
  77. /* a<0, b>0 */  
  78. ulongword A = (ulongword)-(a + 1) + b;
  79. return A >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)A - 1;
  80. }
  81. }
  82. static unsigned char const bitoff[ 256 ] = {
  83.  8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
  84.  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  85.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  86.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  87.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  88.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  89.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  90.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  91.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  92.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  93.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  94.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  95.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  96.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  97.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  98.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  99. };
  100. word gsm_norm P1((a), longword a )
  101. /*
  102.  * the number of left shifts needed to normalize the 32 bit
  103.  * variable L_var1 for positive values on the interval
  104.  *
  105.  * with minimum of
  106.  * minimum of 1073741824  (01000000000000000000000000000000) and 
  107.  * maximum of 2147483647  (01111111111111111111111111111111)
  108.  *
  109.  *
  110.  * and for negative values on the interval with
  111.  * minimum of -2147483648 (-10000000000000000000000000000000) and
  112.  * maximum of -1073741824 ( -1000000000000000000000000000000).
  113.  *
  114.  * in order to normalize the result, the following
  115.  * operation must be done: L_norm_var1 = L_var1 << norm( L_var1 );
  116.  *
  117.  * (That's 'ffs', only from the left, not the right..)
  118.  */
  119. {
  120. assert(a != 0);
  121. if (a < 0) {
  122. if (a <= -1073741824) return 0;
  123. a = ~a;
  124. }
  125. return    a & 0xffff0000 
  126. ? ( a & 0xff000000
  127.   ?  -1 + bitoff[ 0xFF & (a >> 24) ]
  128.   :   7 + bitoff[ 0xFF & (a >> 16) ] )
  129. : ( a & 0xff00
  130.   ?  15 + bitoff[ 0xFF & (a >> 8) ]
  131.   :  23 + bitoff[ 0xFF & a ] );
  132. }
  133. longword gsm_L_asl (longword a, int n)
  134. {
  135. if (n >= 32) return 0;
  136. if (n <= -32) return -(a < 0);
  137. if (n < 0) return gsm_L_asr(a, -n);
  138. return a << n;
  139. }
  140. word gsm_asr (word a, int n)
  141. {
  142. if (n >= 16) return -(a < 0);
  143. if (n <= -16) return 0;
  144. if (n < 0) return a << -n;
  145. # ifdef SASR
  146. return a >> n;
  147. # else
  148. if (a >= 0) return a >> n;
  149. else return -(word)( -(uword)a >> n );
  150. # endif
  151. }
  152. word gsm_asl (word a, int n)
  153. {
  154. if (n >= 16) return 0;
  155. if (n <= -16) return -(a < 0);
  156. if (n < 0) return gsm_asr(a, -n);
  157. return a << n;
  158. }
  159. longword gsm_L_asr (longword a, int n)
  160. {
  161. if (n >= 32) return -(a < 0);
  162. if (n <= -32) return 0;
  163. if (n < 0) return a << -n;
  164. # ifdef SASR
  165. return a >> n;
  166. # else
  167. if (a >= 0) return a >> n;
  168. else return -(longword)( -(ulongword)a >> n );
  169. # endif
  170. }
  171. /*
  172. ** word gsm_asr (word a, int n)
  173. ** {
  174. ** if (n >= 16) return -(a < 0);
  175. ** if (n <= -16) return 0;
  176. ** if (n < 0) return a << -n;
  177. **
  178. ** # ifdef SASR
  179. ** return a >> n;
  180. ** # else
  181. ** if (a >= 0) return a >> n;
  182. ** else return -(word)( -(uword)a >> n );
  183. ** # endif
  184. ** }
  185. **
  186. */
  187. /* 
  188.  *  (From p. 46, end of section 4.2.5)
  189.  *
  190.  *  NOTE: The following lines gives [sic] one correct implementation
  191.  *     of the div(num, denum) arithmetic operation.  Compute div
  192.  *        which is the integer division of num by denum: with denum
  193.  *   >= num > 0
  194.  */
  195. word gsm_div P2((num,denum), word num, word denum)
  196. {
  197. longword L_num   = num;
  198. longword L_denum = denum;
  199. word div  = 0;
  200. int k  = 15;
  201. /* The parameter num sometimes becomes zero.
  202.  * Although this is explicitly guarded against in 4.2.5,
  203.  * we assume that the result should then be zero as well.
  204.  */
  205. /* assert(num != 0); */
  206. assert(num >= 0 && denum >= num);
  207. if (num == 0)
  208.     return 0;
  209. while (k--) {
  210. div   <<= 1;
  211. L_num <<= 1;
  212. if (L_num >= L_denum) {
  213. L_num -= L_denum;
  214. div++;
  215. }
  216. }
  217. return div;
  218. }