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

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

Windows CE

开发平台：

C/C++

idct_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: idct_c.c 323 2005-11-01 20:52:32Z 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. #define W1 2841  // 2048*sqrt(2)*cos(1*pi/16) 
  28. #define W2 2676  // 2048*sqrt(2)*cos(2*pi/16) 
  29. #define W3 2408  // 2048*sqrt(2)*cos(3*pi/16) 
  30. #define W5 1609  // 2048*sqrt(2)*cos(5*pi/16) 
  31. #define W6 1108  // 2048*sqrt(2)*cos(6*pi/16) 
  32. #define W7 565   // 2048*sqrt(2)*cos(7*pi/16) 
  34. #define ADDSAT32(a,Dst,Add32)
  35. b = a + Add32;
  36. c = a & Add32;
  37. a ^= Add32;
  38. a &= ~b;
  39. a |= c;
  40. a &= MaskCarry;
  41. c = a << 1;
  42. b -= c; /* adjust neighbour */
  43. b |= c - (a >> 7); /* mask */
  44. Dst = b;
  46. #define SUBSAT32(a,Dst,Add32)
  47. a = ~a;
  48. b = a + Add32;
  49. c = a & Add32;
  50. a ^= Add32;
  51. a &= ~b;
  52. a |= c;
  53. a &= MaskCarry;
  54. c = a << 1;
  55. b -= c; /* adjust neighbour */
  56. b |= c - (a >> 7); /* mask */
  57. Dst = ~b;
  59. #if !defined(ARM) 
  61. #define SPLIT(d0,d1,d2)
  62. d0 = d1 + d2;
  63. d1 -= d2;
  65. #define BUTTERFLY(d0,d1,W0,W1,tmp)
  66.     tmp = W0 * (d0 + d1);
  67.     d0 = tmp + (W1 - W0) * d0;
  68.     d1 = tmp - (W1 + W0) * d1;
  70. #ifdef MIPSVR41XX
  71. #define WRITEBACK(Dst,n)
  72. __asm(  "andi $7,%0,0x8;"
  73. "beq $7,$0, skipwb" #n ";" 
  74. ".set noreorder;"
  75. "cache 25,-8(%0);"
  76. ".set reorder;"
  77. "skipwb" #n ":",Dst);
  78. #else
  79. #define WRITEBACK(Dst,n)
  80. #endif
  83. static void IDCT_Col8(idct_block_t *Blk)
  84. {
  85. int d0,d1,d2,d3,d4,d5,d6,d7,d8;
  87. d0 = Blk[0];
  88. d4 = Blk[8];
  89. d3 = Blk[16];
  90. d7 = Blk[24];
  91. d1 = Blk[32];
  92. d6 = Blk[40];
  93. d2 = Blk[48];
  94. d5 = Blk[56];
  96. d8 = d5|d6|d7;
  97. if (!(d1|d2|d3|d8))
  98. {
  99. if (!d4) 
  100. { 
  101. // d0
  102. if (d0) 
  103. {
  104. d0 <<= 3;
  105. Blk[0]  = (idct_block_t)d0;
  106. Blk[8]  = (idct_block_t)d0;
  107. Blk[16] = (idct_block_t)d0;
  108. Blk[24] = (idct_block_t)d0;
  109. Blk[32] = (idct_block_t)d0;
  110. Blk[40] = (idct_block_t)d0;
  111. Blk[48] = (idct_block_t)d0;
  112. Blk[56] = (idct_block_t)d0;
  113. }
  114. }
  115. else 
  116. { 
  117. // d0,d4
  118. d0 = (d0 << 11) + 128; //+final rounding
  119. //d1 = (d1 << 11);
  121. d1 = W7 * d4;
  122. d2 = W1 * d4;
  123. d3 = W3 * d4;
  124. d4 = W5 * d4;
  126. Blk[0]  = (idct_block_t)((d0 + d2) >> 8);
  127. Blk[8]  = (idct_block_t)((d0 + d3) >> 8);
  128. Blk[16] = (idct_block_t)((d0 + d4) >> 8);
  129. Blk[24] = (idct_block_t)((d0 + d1) >> 8);
  130. Blk[32] = (idct_block_t)((d0 - d1) >> 8);
  131. Blk[40] = (idct_block_t)((d0 - d4) >> 8);
  132. Blk[48] = (idct_block_t)((d0 - d3) >> 8);
  133. Blk[56] = (idct_block_t)((d0 - d2) >> 8);
  134. }
  135. }
  136. else if (!(d4|d8)) 
  137. { 
  138. // d0,d1,d2,d3
  140. d0 = (d0 << 11) + 128; //+final rounding
  141. d1 = (d1 << 11);
  143. SPLIT(d4,d0,d1) //d1->d4
  144. BUTTERFLY(d3,d2,W6,W2,d1)
  145. SPLIT(d5,d4,d3) //d3->d5
  146. SPLIT(d3,d0,d2) //d2->d3
  148. Blk[0]  = (idct_block_t)(d5 >> 8);
  149. Blk[8]  = (idct_block_t)(d3 >> 8);
  150. Blk[16] = (idct_block_t)(d0 >> 8);
  151. Blk[24] = (idct_block_t)(d4 >> 8);
  152. Blk[32] = (idct_block_t)(d4 >> 8);
  153. Blk[40] = (idct_block_t)(d0 >> 8);
  154. Blk[48] = (idct_block_t)(d3 >> 8);
  155. Blk[56] = (idct_block_t)(d5 >> 8);
  156. }
  157. else 
  158. { 
  159. // d0,d1,d2,d3,d4,d5,d6,d7
  161. d0 = (d0 << 11) + 128; //+final rounding
  162. d1 = (d1 << 11);
  164. BUTTERFLY(d4,d5,W7,W1,d8)
  165. BUTTERFLY(d6,d7,W3,W5,d8)
  167. SPLIT(d8,d0,d1) //d1->d8
  168. BUTTERFLY(d3,d2,W6,W2,d1)
  169. SPLIT(d1,d4,d6) //d6->d1
  170. SPLIT(d6,d5,d7) //d7->d6
  171. SPLIT(d7,d8,d3) //d3->d7
  172. SPLIT(d3,d0,d2) //d2->d3
  174. d2 = (181 * (d4+d5) + 128) >> 8;
  175. d4 = (181 * (d4-d5) + 128) >> 8;
  177. Blk[0]  = (idct_block_t)((d7 + d1) >> 8);
  178. Blk[8]  = (idct_block_t)((d3 + d2) >> 8);
  179. Blk[16] = (idct_block_t)((d0 + d4) >> 8);
  180. Blk[24] = (idct_block_t)((d8 + d6) >> 8);
  181. Blk[32] = (idct_block_t)((d8 - d6) >> 8);
  182. Blk[40] = (idct_block_t)((d0 - d4) >> 8);
  183. Blk[48] = (idct_block_t)((d3 - d2) >> 8);
  184. Blk[56] = (idct_block_t)((d7 - d1) >> 8);
  185. }
  186. }
  188. static void IDCT_Row8(idct_block_t *Blk, uint8_t *Dst, const uint8_t *Src)
  189. {
  190. int d0,d1,d2,d3,d4,d5,d6,d7,d8;
  192. d4 = Blk[1];
  193.    d3 = Blk[2];
  194.    d7 = Blk[3];
  195. d1 = Blk[4];
  196. d6 = Blk[5];
  197. d2 = Blk[6];
  198. d5 = Blk[7];
  200. if (!(d1|d2|d3|d4|d5|d6|d7))
  201. {
  202. d0 = (Blk[0] + 32) >> 6;
  203. if (!Src)
  204. {
  205. SAT(d0);
  207. d0 &= 255;
  208. d0 |= d0 << 8;
  209. d0 |= d0 << 16;
  211. ((uint32_t*)Dst)[0] = d0;
  212. ((uint32_t*)Dst)[1] = d0;
  213. WRITEBACK(Dst,0);
  214. return;
  215. }
  216. d1 = d2 = d3 = d4 = d5 = d6 = d7 = d0;
  217. }
  218. else
  219. {
  220. d0 = (Blk[0] << 11) + 65536; // +final rounding
  221. d1 <<= 11;
  223. BUTTERFLY(d4,d5,W7,W1,d8)
  224. BUTTERFLY(d6,d7,W3,W5,d8)
  226. SPLIT(d8,d0,d1) //d1->d8
  227. BUTTERFLY(d3,d2,W6,W2,d1)
  228. SPLIT(d1,d4,d6) //d6->d1
  229. SPLIT(d6,d5,d7) //d7->d6
  230. SPLIT(d7,d8,d3) //d3->d7
  231. SPLIT(d3,d0,d2) //d2->d3
  233. d2 = 181 * ((d4 + d5 + 128) >> 8);
  234. d4 = 181 * ((d4 - d5 + 128) >> 8);
  236. d5 = (d7 + d1) >> 17;
  237. d1 = (d7 - d1) >> 17;
  238. d7 = (d3 + d2) >> 17;
  239. d2 = (d3 - d2) >> 17;
  240. d3 = (d0 + d4) >> 17;
  241. d4 = (d0 - d4) >> 17;
  242. d0 = (d8 + d6) >> 17;
  243. d6 = (d8 - d6) >> 17;
  244. }
  246. if (Src)
  247. {
  248. d5 += Src[0];
  249. d1 += Src[7];
  250. d7 += Src[1];
  251. d2 += Src[6];
  252. d3 += Src[2];
  253. d4 += Src[5];
  254. d0 += Src[3];
  255. d6 += Src[4];
  256. }
  258. if ((d5|d1|d7|d2|d3|d4|d0|d6)>>8)
  259. {
  260. SAT(d5)
  261. SAT(d7)
  262. SAT(d3)
  263. SAT(d0)
  264. SAT(d6)
  265. SAT(d4)
  266. SAT(d2)
  267. SAT(d1)
  268. }
  270. Dst[0] = (uint8_t)d5;
  271. Dst[1] = (uint8_t)d7;
  272. Dst[2] = (uint8_t)d3;
  273. Dst[3] = (uint8_t)d0;
  274. Dst[4] = (uint8_t)d6;
  275. Dst[5] = (uint8_t)d4;
  276. Dst[6] = (uint8_t)d2;
  277. Dst[7] = (uint8_t)d1;
  278. WRITEBACK(Dst,1);
  279. }
  281. static void IDCT_Row4(idct_block_t *Blk, uint8_t *Dst, const uint8_t *Src)
  282. {
  283. int d0,d1,d2,d3,d4,d5,d6,d7,d8;
  284.   
  285. d4 = Blk[1];
  286.    d3 = Blk[2];
  287.    d7 = Blk[3];
  289. if (!(d3|d4|d7))
  290. {
  291. d0 = (Blk[0] + 32) >> 6;
  292. if (!Src)
  293. {
  294. SAT(d0);
  296. d0 &= 255;
  297. d0 |= d0 << 8;
  298. d0 |= d0 << 16;
  300. ((uint32_t*)Dst)[0] = d0;
  301. ((uint32_t*)Dst)[1] = d0;
  302. WRITEBACK(Dst,2);
  303. return;
  304. }
  305. d1 = d2 = d3 = d4 = d5 = d6 = d7 = d0;
  306. }
  307. else
  308. {
  309. d0 = (Blk[0] << 11) + 65536; // +final rounding
  311. d5 = W7 * d4;
  312. d4 = W1 * d4;
  313. d6 = W3 * d7;
  314. d7 = -W5 * d7;
  315. d2 = W6 * d3;
  316. d3 = W2 * d3;
  318. SPLIT(d1,d4,d6)
  319. SPLIT(d6,d5,d7)
  321. d8 = d0;
  322. SPLIT(d7,d8,d3)
  323. SPLIT(d3,d0,d2)
  325. d2 = 181 * ((d4 + d5 + 128) >> 8);
  326. d4 = 181 * ((d4 - d5 + 128) >> 8);
  328. d5 = (d7 + d1) >> 17;
  329. d1 = (d7 - d1) >> 17;
  330. d7 = (d3 + d2) >> 17;
  331. d2 = (d3 - d2) >> 17;
  332. d3 = (d0 + d4) >> 17;
  333. d4 = (d0 - d4) >> 17;
  334. d0 = (d8 + d6) >> 17;
  335. d6 = (d8 - d6) >> 17;
  336. }
  338. if (Src)
  339. {
  340. d5 += Src[0];
  341. d1 += Src[7];
  342. d7 += Src[1];
  343. d2 += Src[6];
  344. d3 += Src[2];
  345. d4 += Src[5];
  346. d0 += Src[3];
  347. d6 += Src[4];
  348. }
  350. if ((d5|d1|d7|d2|d3|d4|d0|d6)>>8)
  351. {
  352. SAT(d5)
  353. SAT(d7)
  354. SAT(d3)
  355. SAT(d0)
  356. SAT(d6)
  357. SAT(d4)
  358. SAT(d2)
  359. SAT(d1)
  360. }
  362. Dst[0] = (uint8_t)d5;
  363. Dst[1] = (uint8_t)d7;
  364. Dst[2] = (uint8_t)d3;
  365. Dst[3] = (uint8_t)d0;
  366. Dst[4] = (uint8_t)d6;
  367. Dst[5] = (uint8_t)d4;
  368. Dst[6] = (uint8_t)d2;
  369. Dst[7] = (uint8_t)d1;
  370. WRITEBACK(Dst,3);
  371. }
  373. void STDCALL IDCT_Block8x8(idct_block_t *Block, uint8_t *Dest, int DestStride, const uint8_t *Src)
  374. {
  375. int SrcStride;
  377. IDCT_Col8(Block);
  378. IDCT_Col8(Block+1);
  379. IDCT_Col8(Block+2);
  380. IDCT_Col8(Block+3);
  381. IDCT_Col8(Block+4);
  382. IDCT_Col8(Block+5);
  383. IDCT_Col8(Block+6);
  384. IDCT_Col8(Block+7);
  386. SrcStride = 0;
  387. #ifdef MIPS64
  388. if (Src) SrcStride = DestStride;
  389. #else
  390. if (Src) SrcStride = 8;
  391. #endif
  393. IDCT_Row8(Block,Dest,Src);
  394. Dest+=DestStride;
  395. Src+=SrcStride;
  396. IDCT_Row8(Block+8,Dest,Src);
  397. Dest+=DestStride;
  398. Src+=SrcStride;
  399. IDCT_Row8(Block+16,Dest,Src);
  400. Dest+=DestStride;
  401. Src+=SrcStride;
  402. IDCT_Row8(Block+24,Dest,Src);
  403. Dest+=DestStride;
  404. Src+=SrcStride;
  405. IDCT_Row8(Block+32,Dest,Src);
  406. Dest+=DestStride;
  407. Src+=SrcStride;
  408. IDCT_Row8(Block+40,Dest,Src);
  409. Dest+=DestStride;
  410. Src+=SrcStride;
  411. IDCT_Row8(Block+48,Dest,Src);
  412. Dest+=DestStride;
  413. Src+=SrcStride;
  414. IDCT_Row8(Block+56,Dest,Src);
  415. }
  417. void STDCALL IDCT_Block4x8(idct_block_t *Block, uint8_t *Dest, int DestStride, const uint8_t *Src)
  418. {
  419. int SrcStride;
  421. IDCT_Col8(Block);
  422. IDCT_Col8(Block+1);
  423. IDCT_Col8(Block+2);
  424. IDCT_Col8(Block+3);
  426. SrcStride = 0;
  427. #ifdef MIPS64
  428. if (Src) SrcStride = DestStride;
  429. #else
  430. if (Src) SrcStride = 8;
  431. #endif
  433. IDCT_Row4(Block,Dest,Src);
  434. Dest+=DestStride;
  435. Src+=SrcStride;
  436. IDCT_Row4(Block+8,Dest,Src);
  437. Dest+=DestStride;
  438. Src+=SrcStride;
  439. IDCT_Row4(Block+16,Dest,Src);
  440. Dest+=DestStride;
  441. Src+=SrcStride;
  442. IDCT_Row4(Block+24,Dest,Src);
  443. Dest+=DestStride;
  444. Src+=SrcStride;
  445. IDCT_Row4(Block+32,Dest,Src);
  446. Dest+=DestStride;
  447. Src+=SrcStride;
  448. IDCT_Row4(Block+40,Dest,Src);
  449. Dest+=DestStride;
  450. Src+=SrcStride;
  451. IDCT_Row4(Block+48,Dest,Src);
  452. Dest+=DestStride;
  453. Src+=SrcStride;
  454. IDCT_Row4(Block+56,Dest,Src);
  455. }
  457. #ifdef CONFIG_IDCT_SWAP
  458. // just for testing
  459. void STDCALL IDCT_Block4x8Swap(idct_block_t *Block, uint8_t *Dest, int DestStride, const uint8_t *Src)
  460. {
  461. int x;
  462. for (x=0;x<64;++x)
  463. Block[64+x] = Block[((x&7)<<3)+(x>>3)];
  465. IDCT_Block4x8(Block+64,Dest,DestStride,Src);
  466. }
  467. void STDCALL IDCT_Block8x8Swap(idct_block_t *Block, uint8_t *Dest, int DestStride, const uint8_t *Src)
  468. {
  469. int x;
  470. for (x=0;x<64;++x)
  471. Block[64+x] = Block[((x&7)<<3)+(x>>3)];
  473. IDCT_Block8x8(Block+64,Dest,DestStride,Src);
  474. }
  475. #endif
  477. #endif
  479. #ifndef MMX
  481. void STDCALL IDCT_Const8x8(int v,uint8_t * Dst, int DstPitch, uint8_t * Src)
  482. {
  483. #ifndef MIPS64
  484. int SrcPitch = 8;
  485. #else
  486. int SrcPitch = DstPitch;
  487. #endif
  488. const uint8_t* SrcEnd = Src + 8*SrcPitch;
  489. uint32_t MaskCarry = 0x80808080U;
  490. uint32_t a,b,c,d;
  492. if (v>0)
  493. {
  494. v |= v << 8;
  495. v |= v << 16;
  497. do
  498. {
  499. a = ((uint32_t*)Src)[0];
  500. d = ((uint32_t*)Src)[1];
  501. ADDSAT32(a,((uint32_t*)Dst)[0],v);
  502. ADDSAT32(d,((uint32_t*)Dst)[1],v);
  503. Dst += DstPitch;
  504. Src += SrcPitch;
  505. }
  506. while (Src != SrcEnd);
  507. }
  508. else
  509. if (v<0)
  510. {
  511. v = -v;
  512. v |= v << 8;
  513. v |= v << 16;
  515. do
  516. {
  517. a = ((uint32_t*)Src)[0];
  518. d = ((uint32_t*)Src)[1];
  519. SUBSAT32(a,((uint32_t*)Dst)[0],v);
  520. SUBSAT32(d,((uint32_t*)Dst)[1],v);
  521. Dst += DstPitch;
  522. Src += SrcPitch;
  523. }
  524. while (Src != SrcEnd);
  525. }
  526. #ifndef MIPS64
  527. else
  528. CopyBlock8x8(Src,Dst,SrcPitch,DstPitch);
  529. #endif
  530. }
  532. #endif