开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
fixed_asm.nasm
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：12k
源码类别：

Windows CE

开发平台：

C/C++

fixed_asm.nasm：源码内容
  1. ;  libFLAC - Free Lossless Audio Codec library
  2. ;  Copyright (C) 2001,2002,2003,2004,2005  Josh Coalson
  3. ;
  4. ;  Redistribution and use in source and binary forms, with or without
  5. ;  modification, are permitted provided that the following conditions
  6. ;  are met:
  7. ;
  8. ;  - Redistributions of source code must retain the above copyright
  9. ;  notice, this list of conditions and the following disclaimer.
  10. ;
  11. ;  - Redistributions in binary form must reproduce the above copyright
  12. ;  notice, this list of conditions and the following disclaimer in the
  13. ;  documentation and/or other materials provided with the distribution.
  14. ;
  15. ;  - Neither the name of the Xiph.org Foundation nor the names of its
  16. ;  contributors may be used to endorse or promote products derived from
  17. ;  this software without specific prior written permission.
  18. ;
  19. ;  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20. ;  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21. ;  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22. ;  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  23. ;  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24. ;  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25. ;  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26. ;  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27. ;  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28. ;  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29. ;  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31. %include "nasm.h"
  33. data_section
  35. cglobal FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov
  37. code_section
  39. ; **********************************************************************
  40. ;
  41. ; unsigned FLAC__fixed_compute_best_predictor(const FLAC__int32 *data, unsigned data_len, FLAC__float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
  42. ; {
  43. ;  FLAC__int32 last_error_0 = data[-1];
  44. ;  FLAC__int32 last_error_1 = data[-1] - data[-2];
  45. ;  FLAC__int32 last_error_2 = last_error_1 - (data[-2] - data[-3]);
  46. ;  FLAC__int32 last_error_3 = last_error_2 - (data[-2] - 2*data[-3] + data[-4]);
  47. ;  FLAC__int32 error, save;
  48. ;  FLAC__uint32 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
  49. ;  unsigned i, order;
  50. ;
  51. ;  for(i = 0; i < data_len; i++) {
  52. ;  error  = data[i]     ; total_error_0 += local_abs(error);                      save = error;
  53. ;  error -= last_error_0; total_error_1 += local_abs(error); last_error_0 = save; save = error;
  54. ;  error -= last_error_1; total_error_2 += local_abs(error); last_error_1 = save; save = error;
  55. ;  error -= last_error_2; total_error_3 += local_abs(error); last_error_2 = save; save = error;
  56. ;  error -= last_error_3; total_error_4 += local_abs(error); last_error_3 = save;
  57. ;  }
  58. ;
  59. ;  if(total_error_0 < min(min(min(total_error_1, total_error_2), total_error_3), total_error_4))
  60. ;  order = 0;
  61. ;  else if(total_error_1 < min(min(total_error_2, total_error_3), total_error_4))
  62. ;  order = 1;
  63. ;  else if(total_error_2 < min(total_error_3, total_error_4))
  64. ;  order = 2;
  65. ;  else if(total_error_3 < total_error_4)
  66. ;  order = 3;
  67. ;  else
  68. ;  order = 4;
  69. ;
  70. ;  residual_bits_per_sample[0] = (FLAC__float)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (FLAC__double)total_error_0 / (FLAC__double)data_len) / M_LN2 : 0.0);
  71. ;  residual_bits_per_sample[1] = (FLAC__float)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (FLAC__double)total_error_1 / (FLAC__double)data_len) / M_LN2 : 0.0);
  72. ;  residual_bits_per_sample[2] = (FLAC__float)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (FLAC__double)total_error_2 / (FLAC__double)data_len) / M_LN2 : 0.0);
  73. ;  residual_bits_per_sample[3] = (FLAC__float)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (FLAC__double)total_error_3 / (FLAC__double)data_len) / M_LN2 : 0.0);
  74. ;  residual_bits_per_sample[4] = (FLAC__float)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (FLAC__double)total_error_4 / (FLAC__double)data_len) / M_LN2 : 0.0);
  75. ;
  76. ;  return order;
  77. ; }
  78. ALIGN 16
  79. cident FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov
  81. ; esp + 36 == data[]
  82. ; esp + 40 == data_len
  83. ; esp + 44 == residual_bits_per_sample[]
  85. push ebp
  86. push ebx
  87. push esi
  88. push edi
  89. sub esp, byte 16
  90. ; qword [esp] == temp space for loading FLAC__uint64s to FPU regs
  92. ; ebx == &data[i]
  93. ; ecx == loop counter (i)
  94. ; ebp == order
  95. ; mm0 == total_error_1:total_error_0
  96. ; mm1 == total_error_2:total_error_3
  97. ; mm2 == :total_error_4
  98. ; mm3 == last_error_1:last_error_0
  99. ; mm4 == last_error_2:last_error_3
  101. mov ecx, [esp + 40] ; ecx = data_len
  102. test ecx, ecx
  103. jz near .data_len_is_0
  105. mov ebx, [esp + 36] ; ebx = data[]
  106. movd mm3, [ebx - 4] ; mm3 = 0:last_error_0
  107. movd mm2, [ebx - 8] ; mm2 = 0:data[-2]
  108. movd mm1, [ebx - 12] ; mm1 = 0:data[-3]
  109. movd mm0, [ebx - 16] ; mm0 = 0:data[-4]
  110. movq mm5, mm3 ; mm5 = 0:last_error_0
  111. psubd mm5, mm2 ; mm5 = 0:last_error_1
  112. punpckldq mm3, mm5 ; mm3 = last_error_1:last_error_0
  113. psubd mm2, mm1 ; mm2 = 0:data[-2] - data[-3]
  114. psubd mm5, mm2 ; mm5 = 0:last_error_2
  115. movq mm4, mm5 ; mm4 = 0:last_error_2
  116. psubd mm4, mm2 ; mm4 = 0:last_error_2 - (data[-2] - data[-3])
  117. paddd mm4, mm1 ; mm4 = 0:last_error_2 - (data[-2] - 2 * data[-3])
  118. psubd mm4, mm0 ; mm4 = 0:last_error_3
  119. punpckldq mm4, mm5 ; mm4 = last_error_2:last_error_3
  120. pxor mm0, mm0 ; mm0 = total_error_1:total_error_0
  121. pxor mm1, mm1 ; mm1 = total_error_2:total_error_3
  122. pxor mm2, mm2 ; mm2 = 0:total_error_4
  124. ALIGN 16
  125. .loop:
  126. movd mm7, [ebx] ; mm7 = 0:error_0
  127. add ebx, byte 4
  128. movq mm6, mm7 ; mm6 = 0:error_0
  129. psubd mm7, mm3 ; mm7 = :error_1
  130. punpckldq mm6, mm7 ; mm6 = error_1:error_0
  131. movq mm5, mm6 ; mm5 = error_1:error_0
  132. movq mm7, mm6 ; mm7 = error_1:error_0
  133. psubd mm5, mm3 ; mm5 = error_2:
  134. movq mm3, mm6 ; mm3 = error_1:error_0
  135. psrad mm6, 31
  136. pxor mm7, mm6
  137. psubd mm7, mm6 ; mm7 = abs(error_1):abs(error_0)
  138. paddd mm0, mm7 ; mm0 = total_error_1:total_error_0
  139. movq mm6, mm5 ; mm6 = error_2:
  140. psubd mm5, mm4 ; mm5 = error_3:
  141. punpckhdq mm5, mm6 ; mm5 = error_2:error_3
  142. movq mm7, mm5 ; mm7 = error_2:error_3
  143. movq mm6, mm5 ; mm6 = error_2:error_3
  144. psubd mm5, mm4 ; mm5 = :error_4
  145. movq mm4, mm6 ; mm4 = error_2:error_3
  146. psrad mm6, 31
  147. pxor mm7, mm6
  148. psubd mm7, mm6 ; mm7 = abs(error_2):abs(error_3)
  149. paddd mm1, mm7 ; mm1 = total_error_2:total_error_3
  150. movq mm6, mm5 ; mm6 = :error_4
  151. psrad mm5, 31
  152. pxor mm6, mm5
  153. psubd mm6, mm5 ; mm6 = :abs(error_4)
  154. paddd mm2, mm6 ; mm2 = :total_error_4
  156. dec ecx
  157. jnz short .loop
  159. ;  if(total_error_0 < min(min(min(total_error_1, total_error_2), total_error_3), total_error_4))
  160. ;  order = 0;
  161. ;  else if(total_error_1 < min(min(total_error_2, total_error_3), total_error_4))
  162. ;  order = 1;
  163. ;  else if(total_error_2 < min(total_error_3, total_error_4))
  164. ;  order = 2;
  165. ;  else if(total_error_3 < total_error_4)
  166. ;  order = 3;
  167. ;  else
  168. ;  order = 4;
  169. movq mm3, mm0 ; mm3 = total_error_1:total_error_0
  170. movd edi, mm2 ; edi = total_error_4
  171. movd esi, mm1 ; esi = total_error_3
  172. movd eax, mm0 ; eax = total_error_0
  173. punpckhdq mm1, mm1 ; mm1 = total_error_2:total_error_2
  174. punpckhdq mm3, mm3 ; mm3 = total_error_1:total_error_1
  175. movd edx, mm1 ; edx = total_error_2
  176. movd ecx, mm3 ; ecx = total_error_1
  178. xor ebx, ebx
  179. xor ebp, ebp
  180. inc ebx
  181. cmp ecx, eax
  182. cmovb eax, ecx ; eax = min(total_error_0, total_error_1)
  183. cmovbe ebp, ebx
  184. inc ebx
  185. cmp edx, eax
  186. cmovb eax, edx ; eax = min(total_error_0, total_error_1, total_error_2)
  187. cmovbe ebp, ebx
  188. inc ebx
  189. cmp esi, eax
  190. cmovb eax, esi ; eax = min(total_error_0, total_error_1, total_error_2, total_error_3)
  191. cmovbe ebp, ebx
  192. inc ebx
  193. cmp edi, eax
  194. cmovb eax, edi ; eax = min(total_error_0, total_error_1, total_error_2, total_error_3, total_error_4)
  195. cmovbe ebp, ebx
  196. movd ebx, mm0 ; ebx = total_error_0
  197. emms
  199. ;  residual_bits_per_sample[0] = (FLAC__float)((data_len > 0 && total_error_0 > 0) ? log(M_LN2 * (FLAC__double)total_error_0 / (FLAC__double)data_len) / M_LN2 : 0.0);
  200. ;  residual_bits_per_sample[1] = (FLAC__float)((data_len > 0 && total_error_1 > 0) ? log(M_LN2 * (FLAC__double)total_error_1 / (FLAC__double)data_len) / M_LN2 : 0.0);
  201. ;  residual_bits_per_sample[2] = (FLAC__float)((data_len > 0 && total_error_2 > 0) ? log(M_LN2 * (FLAC__double)total_error_2 / (FLAC__double)data_len) / M_LN2 : 0.0);
  202. ;  residual_bits_per_sample[3] = (FLAC__float)((data_len > 0 && total_error_3 > 0) ? log(M_LN2 * (FLAC__double)total_error_3 / (FLAC__double)data_len) / M_LN2 : 0.0);
  203. ;  residual_bits_per_sample[4] = (FLAC__float)((data_len > 0 && total_error_4 > 0) ? log(M_LN2 * (FLAC__double)total_error_4 / (FLAC__double)data_len) / M_LN2 : 0.0);
  204. xor eax, eax
  205. fild dword [esp + 40] ; ST = data_len (NOTE: assumes data_len is <2gigs)
  206. .rbps_0:
  207. test ebx, ebx
  208. jz .total_error_0_is_0
  209. fld1 ; ST = 1.0 data_len
  210. mov [esp], ebx
  211. mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_0
  212. mov ebx, [esp + 44]
  213. fild qword [esp] ; ST = total_error_0 1.0 data_len
  214. fdiv st2 ; ST = total_error_0/data_len 1.0 data_len
  215. fldln2 ; ST = ln2 total_error_0/data_len 1.0 data_len
  216. fmulp st1 ; ST = ln2*total_error_0/data_len 1.0 data_len
  217. fyl2x ; ST = log2(ln2*total_error_0/data_len) data_len
  218. fstp dword [ebx] ; residual_bits_per_sample[0] = log2(ln2*total_error_0/data_len)   ST = data_len
  219. jmp short .rbps_1
  220. .total_error_0_is_0:
  221. mov ebx, [esp + 44]
  222. mov [ebx], eax ; residual_bits_per_sample[0] = 0.0
  223. .rbps_1:
  224. test ecx, ecx
  225. jz .total_error_1_is_0
  226. fld1 ; ST = 1.0 data_len
  227. mov [esp], ecx
  228. mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_1
  229. fild qword [esp] ; ST = total_error_1 1.0 data_len
  230. fdiv st2 ; ST = total_error_1/data_len 1.0 data_len
  231. fldln2 ; ST = ln2 total_error_1/data_len 1.0 data_len
  232. fmulp st1 ; ST = ln2*total_error_1/data_len 1.0 data_len
  233. fyl2x ; ST = log2(ln2*total_error_1/data_len) data_len
  234. fstp dword [ebx + 4] ; residual_bits_per_sample[1] = log2(ln2*total_error_1/data_len)   ST = data_len
  235. jmp short .rbps_2
  236. .total_error_1_is_0:
  237. mov [ebx + 4], eax ; residual_bits_per_sample[1] = 0.0
  238. .rbps_2:
  239. test edx, edx
  240. jz .total_error_2_is_0
  241. fld1 ; ST = 1.0 data_len
  242. mov [esp], edx
  243. mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_2
  244. fild qword [esp] ; ST = total_error_2 1.0 data_len
  245. fdiv st2 ; ST = total_error_2/data_len 1.0 data_len
  246. fldln2 ; ST = ln2 total_error_2/data_len 1.0 data_len
  247. fmulp st1 ; ST = ln2*total_error_2/data_len 1.0 data_len
  248. fyl2x ; ST = log2(ln2*total_error_2/data_len) data_len
  249. fstp dword [ebx + 8] ; residual_bits_per_sample[2] = log2(ln2*total_error_2/data_len)   ST = data_len
  250. jmp short .rbps_3
  251. .total_error_2_is_0:
  252. mov [ebx + 8], eax ; residual_bits_per_sample[2] = 0.0
  253. .rbps_3:
  254. test esi, esi
  255. jz .total_error_3_is_0
  256. fld1 ; ST = 1.0 data_len
  257. mov [esp], esi
  258. mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_3
  259. fild qword [esp] ; ST = total_error_3 1.0 data_len
  260. fdiv st2 ; ST = total_error_3/data_len 1.0 data_len
  261. fldln2 ; ST = ln2 total_error_3/data_len 1.0 data_len
  262. fmulp st1 ; ST = ln2*total_error_3/data_len 1.0 data_len
  263. fyl2x ; ST = log2(ln2*total_error_3/data_len) data_len
  264. fstp dword [ebx + 12] ; residual_bits_per_sample[3] = log2(ln2*total_error_3/data_len)   ST = data_len
  265. jmp short .rbps_4
  266. .total_error_3_is_0:
  267. mov [ebx + 12], eax ; residual_bits_per_sample[3] = 0.0
  268. .rbps_4:
  269. test edi, edi
  270. jz .total_error_4_is_0
  271. fld1 ; ST = 1.0 data_len
  272. mov [esp], edi
  273. mov [esp + 4], eax ; [esp] = (FLAC__uint64)total_error_4
  274. fild qword [esp] ; ST = total_error_4 1.0 data_len
  275. fdiv st2 ; ST = total_error_4/data_len 1.0 data_len
  276. fldln2 ; ST = ln2 total_error_4/data_len 1.0 data_len
  277. fmulp st1 ; ST = ln2*total_error_4/data_len 1.0 data_len
  278. fyl2x ; ST = log2(ln2*total_error_4/data_len) data_len
  279. fstp dword [ebx + 16] ; residual_bits_per_sample[4] = log2(ln2*total_error_4/data_len)   ST = data_len
  280. jmp short .rbps_end
  281. .total_error_4_is_0:
  282. mov [ebx + 16], eax ; residual_bits_per_sample[4] = 0.0
  283. .rbps_end:
  284. fstp st0 ; ST = [empty]
  285. jmp short .end
  286. .data_len_is_0:
  287. ; data_len == 0, so residual_bits_per_sample[*] = 0.0
  288. xor ebp, ebp
  289. mov edi, [esp + 44]
  290. mov [edi], ebp
  291. mov [edi + 4], ebp
  292. mov [edi + 8], ebp
  293. mov [edi + 12], ebp
  294. mov [edi + 16], ebp
  295. add ebp, byte 4 ; order = 4
  297. .end:
  298. mov eax, ebp ; return order
  299. add esp, byte 16
  300. pop edi
  301. pop esi
  302. pop ebx
  303. pop ebp
  304. ret
  306. end