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

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

Windows CE

开发平台：

C/C++

mcomp_c.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: mcomp_c.c 329 2005-11-04 17:17:55Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  25. #include "softidct.h"
  27. #if !defined(ARM) && !defined(MIPS64) && !defined(MIPS32) && !defined(MMX)
  29. #define LoadRow(a,b,ofs) 
  30. { 
  31. a=LOAD32(Src+ofs+0); 
  32. b=LOAD32(Src+ofs+4); 
  33. }
  34. #define LoadMRow(a,b,c,d,ofs) 
  35. { 
  36. a=LOAD32(Src+ofs+0); 
  37. b=LOAD32(Src+ofs+4); 
  38. c=LOAD32(Src+ofs+8); 
  39. d=LOAD32(Src+ofs+12); 
  40. }
  41. #define SaveRow(a,b) 
  42. { 
  43. ((uint32_t*)Dst)[0]=a; 
  44. ((uint32_t*)Dst)[1]=b; 
  45. }
  46. #define SaveMRow(a,b,c,d)
  47. {
  48. ((uint32_t*)Dst)[0]=a;
  49. ((uint32_t*)Dst)[1]=b;
  50. ((uint32_t*)Dst)[2]=c;
  51. ((uint32_t*)Dst)[3]=d;
  52. }
  53. #define AddRow(a,b,t0,t1)
  54. { 
  55. t0=((uint32_t*)Dst)[0]; 
  56. t1=((uint32_t*)Dst)[1]; 
  57. AVG32R(a,b,t0,t1); 
  58. ((uint32_t*)Dst)[0]=a; 
  59. ((uint32_t*)Dst)[1]=b; 
  60. }
  61. #define PrepareAvg4(a,b,c,d)
  62. {
  63. uint32_t q,w;
  64. q=(a & 0x03030303);
  65. w=(b & 0x03030303);
  66. q+=(c & 0x03030303);
  67. w+=(d & 0x03030303);
  68. a=(a>>2) & 0x3F3F3F3F;
  69. b=(b>>2) & 0x3F3F3F3F;
  70. a+=(c>>2) & 0x3F3F3F3F;
  71. b+=(d>>2) & 0x3F3F3F3F;
  72. c=q;
  73. d=w;
  74. }
  75. #define Avg4(a,b,c,d,g,h,i,j)
  76. {
  77. a+=g;
  78. b+=h;
  79. c+=i+0x02020202;
  80. d+=j+0x02020202;
  81. a+=(c>>2) & 0x03030303;
  82. b+=(d>>2) & 0x03030303;
  83. }
  84. #define Avg4Round(a,b,c,d,g,h,i,j)
  85. {
  86. a+=g;
  87. b+=h;
  88. c+=i+0x01010101;
  89. d+=j+0x01010101;
  90. a+=(c>>2) & 0x03030303;
  91. b+=(d>>2) & 0x03030303;
  92. }
  94. // Dst[p] = Src[p]
  95. void STDCALL CopyBlock(uint8_t *Src, uint8_t *Dst, int SrcPitch, int DstPitch)
  96. {
  97. uint8_t *SrcEnd = Src + 8*SrcPitch;
  98. uint32_t a,b;
  99. do
  100. {
  101. LoadRow(a,b,0)
  102. SaveRow(a,b)
  103. Dst += DstPitch;
  104. Src += SrcPitch;
  105. }
  106. while (Src != SrcEnd);
  107. }
  109. // Dst[p] = (Src[p] + Src[p+1]+1) >> 1;
  110. void STDCALL CopyBlockHor(uint8_t *Src, uint8_t *Dst, int SrcPitch, int DstPitch)
  111. {
  112. uint8_t *SrcEnd = Src + 8*SrcPitch;
  113. uint32_t a,b,c,d;
  114. do
  115. {
  116. LoadRow(a,b,0)
  117. LoadRow(c,d,1)
  118. AVG32R(a,b,c,d)
  119. SaveRow(a,b)
  120. Dst += DstPitch;
  121. Src += SrcPitch;
  122. }
  123. while (Src != SrcEnd);
  124. }
  126. // Dst[p] = (Src[p] + Src[p+SrcPitch]+1) >> 1;
  127. void STDCALL CopyBlockVer(uint8_t *Src, uint8_t *Dst, int SrcPitch, int DstPitch)
  128. {
  129. uint8_t *SrcEnd = Src + 8*SrcPitch;
  130. uint32_t a,b,c,d,e,f;
  131. LoadRow(a,b,0)
  132. do
  133. {
  134. Src += SrcPitch;
  135. LoadRow(c,d,0)
  136. e = c;
  137. f = d;
  138. AVG32R(a,b,e,f)
  139. SaveRow(a,b)
  140. Dst += DstPitch;
  142. Src += SrcPitch;
  143. LoadRow(a,b,0)
  144. e = c;
  145. f = d;
  146. AVG32R(c,d,e,f)
  147. SaveRow(c,d)
  148. Dst += DstPitch;
  149. }
  150. while (Src != SrcEnd);
  151. }
  153. // Dst[p] = (Src[p] + Src[p+1] + Src[p+SrcPitch] + Src[p+SrcPitch+1] + 2) >> 2;
  154. void STDCALL CopyBlockHorVer(uint8_t *Src, uint8_t *Dst, int SrcPitch, int DstPitch)
  155. {
  156. uint8_t *SrcEnd = Src + 8*SrcPitch;
  157. uint32_t a,b,c,d,g,h,i,j;
  158. LoadRow(a,b,0)
  159. LoadRow(c,d,1)
  160. PrepareAvg4(a,b,c,d)
  161. do
  162. {
  163. Src += SrcPitch;
  164. LoadRow(g,h,0)
  165. LoadRow(i,j,1)
  166. PrepareAvg4(g,h,i,j)
  167. Avg4(a,b,c,d,g,h,i,j)
  168. SaveRow(a,b)
  169. Dst += DstPitch;
  171. Src += SrcPitch;
  172. LoadRow(a,b,0)
  173. LoadRow(c,d,1)
  174. PrepareAvg4(a,b,c,d)
  175. Avg4(g,h,i,j,a,b,c,d)
  176. SaveRow(g,h)
  177. Dst += DstPitch;
  178. }
  179. while (Src != SrcEnd);
  180. }
  182. // Dst[p] = (Src[p] + Src[p+1]) >> 1;
  183. void STDCALL CopyBlockHorRound(uint8_t *Src, uint8_t *Dst, int SrcPitch, int DstPitch)
  184. {
  185. uint8_t *SrcEnd = Src + 8*SrcPitch;
  186. uint32_t a,b,c,d;
  187. do
  188. {
  189. LoadRow(a,b,0)
  190. LoadRow(c,d,1)
  191. AVG32NR(a,b,c,d)
  192. SaveRow(a,b)
  193. Dst += DstPitch;
  194. Src += SrcPitch;
  195. }
  196. while (Src != SrcEnd);
  197. }
  199. // Dst[p] = (Src[p] + Src[p+SrcPitch]) >> 1;
  200. void STDCALL CopyBlockVerRound(uint8_t *Src, uint8_t *Dst, int SrcPitch, int DstPitch)
  201. {
  202. uint8_t *SrcEnd = Src + 8*SrcPitch;
  203. uint32_t a,b,c,d,e,f;
  204. LoadRow(a,b,0)
  205. do
  206. {
  207. Src += SrcPitch;
  208. LoadRow(c,d,0)
  209. e = c;
  210. f = d;
  211. AVG32NR(a,b,e,f)
  212. SaveRow(a,b)
  213. Dst += DstPitch;
  215. Src += SrcPitch;
  216. LoadRow(a,b,0)
  217. e = a;
  218. f = b;
  219. AVG32NR(c,d,e,f)
  220. SaveRow(c,d)
  221. Dst += DstPitch;
  222. }
  223. while (Src != SrcEnd);
  224. }
  226. // Dst[p] = (Src[p] + Src[p+1] + Src[p+SrcPitch] + Src[p+SrcPitch+1] + 1) >> 2;
  227. void STDCALL CopyBlockHorVerRound(uint8_t *Src, uint8_t *Dst, int SrcPitch, int DstPitch)
  228. {
  229. uint8_t *SrcEnd = Src + 8*SrcPitch;
  230. uint32_t a,b,c,d,g,h,i,j;
  231. LoadRow(a,b,0)
  232. LoadRow(c,d,1)
  233. PrepareAvg4(a,b,c,d)
  234. do
  235. {
  236. Src += SrcPitch;
  237. LoadRow(g,h,0)
  238. LoadRow(i,j,1)
  239. PrepareAvg4(g,h,i,j)
  240. Avg4Round(a,b,c,d,g,h,i,j)
  241. SaveRow(a,b)
  242. Dst += DstPitch;
  244. Src += SrcPitch;
  245. LoadRow(a,b,0)
  246. LoadRow(c,d,1)
  247. PrepareAvg4(a,b,c,d)
  248. Avg4Round(g,h,i,j,a,b,c,d)
  249. SaveRow(g,h)
  250. Dst += DstPitch;
  251. }
  252. while (Src != SrcEnd);
  253. }
  255. // Dst[p] = (Src[p] + Dst[p] + 1) >> 1
  256. void STDCALL AddBlock(uint8_t *Src, uint8_t *Dst, int SrcPitch)
  257. {
  258. uint8_t *SrcEnd = Src + 8*SrcPitch;
  259. uint32_t a,b,c,d;
  260. do
  261. {
  262. LoadRow(a,b,0)
  263. AddRow(a,b,c,d)
  264. Dst += 8;
  265. Src += SrcPitch;
  266. }
  267. while (Src != SrcEnd);
  268. }
  270. // Dst[p] = (((Src[p] + Src[p+1]+1) >> 1) + Dst[p] + 1) >> 1
  271. void STDCALL AddBlockHor(uint8_t *Src, uint8_t *Dst, int SrcPitch)
  272. {
  273. uint8_t *SrcEnd = Src + 8*SrcPitch;
  274. uint32_t a,b,c,d;
  275. do
  276. {
  277. LoadRow(a,b,0)
  278. LoadRow(c,d,1)
  279. AVG32R(a,b,c,d)
  280. AddRow(a,b,c,d)
  281. Dst += 8;
  282. Src += SrcPitch;
  283. }
  284. while (Src != SrcEnd);
  285. }
  287. // Dst[p] = (((Src[p] + Src[p+SrcPitch]+1) >> 1) + Dst[p] + 1) >> 1
  288. void STDCALL AddBlockVer(uint8_t *Src, uint8_t *Dst, int SrcPitch)
  289. {
  290. uint8_t *SrcEnd = Src + 8*SrcPitch;
  291. uint32_t a,b,c,d,e,f;
  292. LoadRow(a,b,0)
  293. do
  294. {
  295. Src += SrcPitch;
  296. c=a;
  297. d=b;
  298. LoadRow(a,b,0)
  299. e=a;
  300. f=b;
  301. AVG32R(c,d,e,f)
  302. AddRow(c,d,e,f)
  303. Dst += 8;
  304. }
  305. while (Src != SrcEnd);
  306. }
  308. // Dst[p] = (((Src[p] + Src[p+1] + Src[p+SrcPitch] + Src[p+SrcPitch+1] + 2) >> 2) + Dst[p] + 1) >> 1
  309. void STDCALL AddBlockHorVer(uint8_t *Src, uint8_t *Dst, int SrcPitch)
  310. {
  311. uint8_t *SrcEnd = Src + 8*SrcPitch;
  312. uint32_t a,b,c,d,g,h,i,j;
  313. LoadRow(a,b,0)
  314. LoadRow(c,d,1)
  315. PrepareAvg4(a,b,c,d)
  316. do
  317. {
  318. Src += SrcPitch;
  319. LoadRow(g,h,0)
  320. LoadRow(i,j,1)
  321. PrepareAvg4(g,h,i,j)
  322. Avg4(a,b,c,d,g,h,i,j)
  323. AddRow(a,b,c,d)
  324. a=g;
  325. b=h;
  326. c=i;
  327. d=j;
  328. Dst += 8;
  329. }
  330. while (Src != SrcEnd);
  331. }
  333. // Dst[p] = Src[p]
  334. void STDCALL CopyBlock16x16(uint8_t *Src, uint8_t *Dst, int SrcPitch,int DstPitch)
  335. {
  336. uint8_t *SrcEnd = Src + 16*SrcPitch;
  337. uint32_t a,b,c,d;
  338. do
  339. {
  340. a=((uint32_t*)Src)[0];
  341. b=((uint32_t*)Src)[1];
  342. c=((uint32_t*)Src)[2];
  343. d=((uint32_t*)Src)[3];
  344. ((uint32_t*)Dst)[0]=a;
  345. ((uint32_t*)Dst)[1]=b;
  346. ((uint32_t*)Dst)[2]=c;
  347. ((uint32_t*)Dst)[3]=d;
  348. Dst += DstPitch;
  349. Src += SrcPitch;
  350. }
  351. while (Src != SrcEnd);
  352. }
  354. // Dst[p] = Src[p]
  355. void STDCALL CopyBlock8x8(uint8_t *Src, uint8_t *Dst, int SrcPitch,int DstPitch)
  356. {
  357. uint8_t *SrcEnd = Src + 8*SrcPitch;
  358. uint32_t a,b,c,d;
  359. do
  360. {
  361. a=((uint32_t*)Src)[0];
  362. b=((uint32_t*)Src)[1];
  363. Src += SrcPitch;
  364. c=((uint32_t*)Src)[0];
  365. d=((uint32_t*)Src)[1];
  366. Src += SrcPitch;
  367. ((uint32_t*)Dst)[0]=a;
  368. ((uint32_t*)Dst)[1]=b;
  369. Dst += DstPitch;
  370. ((uint32_t*)Dst)[0]=c;
  371. ((uint32_t*)Dst)[1]=d;
  372. Dst += DstPitch;
  373. }
  374. while (Src != SrcEnd);
  375. }
  377. // Dst[p] = Src[p]
  378. void STDCALL CopyBlockM(uint8_t *Src, uint8_t *Dst, int SrcPitch, int DstPitch)
  379. {
  380. uint8_t *SrcEnd = Src + 16*SrcPitch;
  381. uint32_t a,b,c,d;
  382. do
  383. {
  384. LoadMRow(a,b,c,d,0)
  385. SaveMRow(a,b,c,d)
  386. Dst += DstPitch;
  387. Src += SrcPitch;
  388. }
  389. while (Src != SrcEnd);
  390. }
  392. #endif