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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
postprocess.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：17k
源码类别：

多媒体编程

开发平台：

Visual C++

postprocess.c：源码内容
  3. #include "postprocess.h"
  5. #ifdef PP_SELF_CHECK
  6. #include <stdio.h>
  7. #endif
  10. #define ABS(a)     ( (a)>0 ? (a) : -(a) )
  11. #define SIGN(a)    ( (a)<0 ? -1 : 1 )
  12. #define MIN(a, b)  ( (a)<(b) ? (a) : (b) )
  13. #define MAX(a, b)  ( (a)>(b) ? (a) : (b) )
  16. static int deblock_horiz_useDC(uint8_t *v, int stride) {
  17. int eq_cnt, useDC;
  18. int x, y;
  19. #ifdef PP_SELF_CHECK
  20. int eq_cnt2, j, k;
  21. #endif
  23. eq_cnt = 0;
  24. for (y=0; y<4; y++) {
  25. for (x=1; x<=7; x++) {
  26. if (ABS(v[x+y*stride]-v[1+x+y*stride]) <= 1) eq_cnt--;
  27. }
  28. }
  30. #ifdef PP_SELF_CHECK
  31. eq_cnt2 = 0;
  32. for (k=0; k<4; k++) {
  33. for (j=1; j<=7; j++) {
  34. if (ABS(v[j+k*stride]-v[1+j+k*stride]) <= 1) eq_cnt2--;
  35. }
  36. }
  37. if (eq_cnt2 != eq_cnt) printf("ERROR: C version of useDC is incorrectn");
  38. #endif
  40. useDC = eq_cnt <= -DEBLOCK_HORIZ_USEDC_THR;
  42. return useDC;
  43. }
  47. static int deblock_horiz_DC_on(uint8_t *v, int stride, int QP) {
  48. return (ABS(v[1]-v[8]) < 2*QP);
  49. }
  56. static void deblock_horiz_lpf9(uint8_t *v, int stride, int QP) {
  57. int x, y, p1, p2, psum;
  58. uint8_t *vv, vnew[9];
  59. #ifdef PP_SELF_CHECK
  60. uint8_t selfcheck[9];
  61. int psum2;
  62. uint8_t *vv2; 
  63. #endif
  65. for (y=0; y<4; y++) {
  66. p1 = (ABS(v[0+y*stride]-v[1+y*stride]) < QP ) ?  v[0+y*stride] : v[1+y*stride];
  67. p2 = (ABS(v[8+y*stride]-v[9+y*stride]) < QP ) ?  v[9+y*stride] : v[8+y*stride];
  70. #ifdef PP_SELF_CHECK
  72. vv2 = &(v[y*stride]);
  73. psum2 = p1 + p1 + p1 + vv2[1] + vv2[2] + vv2[3] + vv2[4] + 4;
  74. selfcheck[1] = (((psum2 + vv2[1]) << 1) - (vv2[4] - vv2[5])) >> 4;
  75. psum2 += vv2[5] - p1; 
  76. selfcheck[2] = (((psum2 + vv2[2]) << 1) - (vv2[5] - vv2[6])) >> 4;
  77. psum2 += vv2[6] - p1; 
  78. selfcheck[3] = (((psum2 + vv2[3]) << 1) - (vv2[6] - vv2[7])) >> 4;
  79. psum2 += vv2[7] - p1; 
  80. selfcheck[4] = (((psum2 + vv2[4]) << 1) + p1 - vv2[1] - (vv2[7] - vv2[8])) >> 4;
  81. psum2 += vv2[8] - vv2[1]; 
  82. selfcheck[5] = (((psum2 + vv2[5]) << 1) + (vv2[1] - vv2[2]) - vv2[8] + p2) >> 4;
  83. psum2 += p2 - vv2[2]; 
  84. selfcheck[6] = (((psum2 + vv2[6]) << 1) + (vv2[2] - vv2[3])) >> 4;
  85. psum2 += p2 - vv2[3]; 
  86. selfcheck[7] = (((psum2 + vv2[7]) << 1) + (vv2[3] - vv2[4])) >> 4;
  87. psum2 += p2 - vv2[4]; 
  88. selfcheck[8] = (((psum2 + vv2[8]) << 1) + (vv2[4] - vv2[5])) >> 4;
  89. #endif
  91. vv = &(v[y*stride]);
  92. psum = p1 + p1 + p1 + vv[1] + vv[2] + vv[3] + vv[4] + 4;
  93. vnew[1] = (((psum + vv[1]) << 1) - (vv[4] - vv[5])) >> 4;
  94. psum += vv[5] - p1; 
  95. vnew[2] = (((psum + vv[2]) << 1) - (vv[5] - vv[6])) >> 4;
  96. psum += vv[6] - p1; 
  97. vnew[3] = (((psum + vv[3]) << 1) - (vv[6] - vv[7])) >> 4;
  98. psum += vv[7] - p1; 
  99. vnew[4] = (((psum + vv[4]) << 1) + p1 - vv[1] - (vv[7] - vv[8])) >> 4;
  100. psum += vv[8] - vv[1]; 
  101. vnew[5] = (((psum + vv[5]) << 1) + (vv[1] - vv[2]) - vv[8] + p2) >> 4;
  102. psum += p2 - vv[2]; 
  103. vnew[6] = (((psum + vv[6]) << 1) + (vv[2] - vv[3])) >> 4;
  104. psum += p2 - vv[3]; 
  105. vnew[7] = (((psum + vv[7]) << 1) + (vv[3] - vv[4])) >> 4;
  106. psum += p2 - vv[4]; 
  107. vnew[8] = (((psum + vv[8]) << 1) + (vv[4] - vv[5])) >> 4;
  108. for (x=1; x<=8; x++) {
  109. vv[x] = vnew[x];
  110. }
  112. #ifdef PP_SELF_CHECK
  113. for (x=1; x<=8; x++) {
  114. if (selfcheck[x] != v[x+y*stride]) printf("ERROR: C version of horiz lpf9 is incorrectn");
  115. }
  116. #endif
  118. }
  120. }
  124. static void deblock_horiz_default_filter(uint8_t *v, int stride, int QP) {
  125. int a3_0, a3_1, a3_2, d;
  126. int q1, q;
  127. int y;
  129. for (y=0; y<4; y++) {
  131. q1 = v[4] - v[5];
  132. q = q1 / 2;
  133. if (q) {
  135. a3_0 = 2*(v[3]-v[6]) - 5*q1;
  137. if (ABS(a3_0) < 8*QP) {
  139. a3_1 = 2*(v[1]-v[4]) + 5*(v[3]-v[2]);
  140. a3_2 = 2*(v[5]-v[8]) + 5*(v[7]-v[8]);
  141. d = ABS(a3_0) - MIN(ABS(a3_1), ABS(a3_2));
  143. if (d > 0) { 
  144. d += d<<2;
  145. d = (d + 32) >> 6; 
  147. if (d > 0) {
  149. d *= SIGN(-a3_0);
  152. if (q > 0) {
  153. d = d<0 ? 0 : d;
  154. d = d>q ? q : d;
  155. } else {
  156. d = d>0 ? 0 : d;
  157. d = d<q ? q : d;
  158. }
  160. v[4] -= d;
  161. v[5] += d;
  163. }
  164. }
  165. }
  166. }
  168. #ifdef PP_SELF_CHECK
  170. #endif;
  172. v += stride;
  173. }
  176. }
  181. void deblock_horiz(uint8_t *image, int width, int height, int stride, QP_STORE_T *QP_store, int QP_stride, int chroma) {
  182. int x, y;
  183. int QP;
  184. uint8_t *v;
  185. int useDC, DC_on;
  188. for (y=0; y<height; y+=4) {
  191. for (x=8; x<width; x+=8) {
  194. QP = chroma ? QP_store[y/8*QP_stride+x/8]
  195.                 : QP_store[y/16*QP_stride+x/16];
  198. v = &(image[y*stride + x]) - 5;
  201. useDC = deblock_horiz_useDC(v, stride);
  203. if (useDC) { 
  205. DC_on = deblock_horiz_DC_on(v, stride, QP);
  207. if (DC_on) {
  209. deblock_horiz_lpf9(v, stride, QP); 
  211. #ifdef SHOWDECISIONS_H
  212. if (!chromaFlag) {
  213. v[0*stride + 4] = 
  214. v[1*stride + 4] = 
  215. v[2*stride + 4] = 
  216. v[3*stride + 4] = 255;  
  217. }
  218. #endif
  219. }
  221. } else {     
  223. deblock_horiz_default_filter(v, stride, QP);
  225. #ifdef SHOWDECISIONS_H
  226. if (!chromaFlag) {
  227. v[0*stride + 4] = 
  228. v[1*stride + 4] = 
  229. v[2*stride + 4] = 
  230. v[3*stride + 4] = 0;  
  231. }
  232. #endif
  234. }
  235. }
  236. }
  237. }
  243. static int deblock_vert_useDC(uint8_t *v, int stride) {
  244. int eq_cnt, useDC, x, y;
  245. #ifdef PP_SELF_CHECK
  246. int useDC2, j, i;
  247. #endif
  249. #ifdef PP_SELF_CHECK
  251. eq_cnt = 0;
  252. for (j=1; j<8; j++) {
  253. for (i=0; i<8; i++) {
  254. if (ABS(v[j*stride+i] - v[(j+1)*stride+i]) <= 1) eq_cnt++;
  255. }
  256. }
  257. useDC2 = (eq_cnt > DEBLOCK_VERT_USEDC_THR); 
  258. #endif
  261. eq_cnt = 0;
  262. for (y=1; y<8; y++) {
  263. for (x=0; x<8; x++) {
  264. if (ABS(v[y*stride+x] - v[(y+1)*stride+x]) <= 1) eq_cnt++;
  265. }
  266. }
  267. useDC = (eq_cnt  > DEBLOCK_VERT_USEDC_THR);
  269. #ifdef PP_SELF_CHECK
  270. if (useDC != useDC2) printf("ERROR: C version of useDC is incorrectn");
  271. #endif
  273. return useDC;
  274. }
  281. static int deblock_vert_DC_on(uint8_t *v, int stride, int QP) {
  282. int DC_on, x;
  283. #ifdef PP_SELF_CHECK
  284. int i, DC_on2;
  285. #endif
  287. #ifdef PP_SELF_CHECK
  288. DC_on2 = 1;
  289. for (i=0; i<8; i++) {
  290. if (ABS(v[i+1*stride]-v[i+8*stride]) > 2 *QP) DC_on2 = 0;
  291. }
  292. #endif
  294. DC_on = 1;
  295. for (x=0; x<8; x++) {
  296. if (ABS(v[x+1*stride]-v[x+8*stride]) > 2 *QP) DC_on = 0;
  297. }
  299. #ifdef PP_SELF_CHECK
  300. if (DC_on != DC_on2) printf("ERROR: C version of DC_on is incorrectn");
  301. #endif
  303. return DC_on;
  304. }
  312. void deblock_vert_lpf9(uint64_t *v_local, uint64_t *p1p2, uint8_t *v, int stride, int QP) {
  313. int x, y;
  314. int p1, p2, psum;
  315. uint8_t  *vv, vnew[9];
  316. int l1 = 1 * stride;
  317. int l2 = 2 * stride;
  318. int l3 = 3 * stride;
  319. int l4 = 4 * stride;
  320. int l5 = 5 * stride;
  321. int l6 = 6 * stride;
  322. int l7 = 7 * stride;
  323. int l8 = 8 * stride;
  324. #ifdef PP_SELF_CHECK
  325. int j, k;
  326. uint8_t selfcheck[64];
  327. #endif
  330. #ifdef PP_SELF_CHECK
  331. for (j=0; j<8; j++) { 
  332. vv = &(v[j]);
  333. p1 = (ABS(vv[0*stride]-vv[1*stride]) < QP ) ?  vv[0*stride] : vv[1*stride];
  334. p2 = (ABS(vv[8*stride]-vv[9*stride]) < QP ) ?  vv[9*stride] : vv[8*stride];
  336. psum = p1 + p1 + p1 + vv[l1] + vv[l2] + vv[l3] + vv[l4] + 4; 
  337. selfcheck[j+8*0] = (((psum + vv[l1]) << 1) - (vv[l4] - vv[l5])) >> 4; 
  338. psum += vv[l5] - p1; 
  339. selfcheck[j+8*1] = (((psum + vv[l2]) << 1) - (vv[l5] - vv[l6])) >> 4; 
  340. psum += vv[l6] - p1; 
  341. selfcheck[j+8*2] = (((psum + vv[l3]) << 1) - (vv[l6] - vv[l7])) >> 4; 
  342. psum += vv[l7] - p1; 
  343. selfcheck[j+8*3] = (((psum + vv[l4]) << 1) + p1 - vv[l1] - (vv[l7] - vv[l8])) >> 4; 
  344. psum += vv[l8] - vv[l1];  
  345. selfcheck[j+8*4] = (((psum + vv[l5]) << 1) + (vv[l1] - vv[l2]) - vv[l8] + p2) >> 4; 
  346. psum += p2 - vv[l2];  
  347. selfcheck[j+8*5] = (((psum + vv[l6]) << 1) + (vv[l2] - vv[l3])) >> 4; 
  348. psum += p2 - vv[l3]; 
  349. selfcheck[j+8*6] = (((psum + vv[l7]) << 1) + (vv[l3] - vv[l4])) >> 4; 
  350. psum += p2 - vv[l4]; 
  351. selfcheck[j+8*7] = (((psum + vv[l8]) << 1) + (vv[l4] - vv[l5])) >> 4; 
  352. }
  353. #endif
  356. for (x=0; x<8; x++) { 
  357. vv = &(v[x]);
  358. p1 = (ABS(vv[0*stride]-vv[1*stride]) < QP ) ?  vv[0*stride] : vv[1*stride];
  359. p2 = (ABS(vv[8*stride]-vv[9*stride]) < QP ) ?  vv[9*stride] : vv[8*stride];
  361. psum = p1 + p1 + p1 + vv[l1] + vv[l2] + vv[l3] + vv[l4] + 4; 
  362. vnew[1] = (((psum + vv[l1]) << 1) - (vv[l4] - vv[l5])) >> 4; 
  363. psum += vv[l5] - p1; 
  364. vnew[2] = (((psum + vv[l2]) << 1) - (vv[l5] - vv[l6])) >> 4; 
  365. psum += vv[l6] - p1; 
  366. vnew[3] = (((psum + vv[l3]) << 1) - (vv[l6] - vv[l7])) >> 4; 
  367. psum += vv[l7] - p1; 
  368. vnew[4] = (((psum + vv[l4]) << 1) + p1 - vv[l1] - (vv[l7] - vv[l8])) >> 4; 
  369. psum += vv[l8] - vv[l1];  
  370. vnew[5] = (((psum + vv[l5]) << 1) + (vv[l1] - vv[l2]) - vv[l8] + p2) >> 4; 
  371. psum += p2 - vv[l2];  
  372. vnew[6] = (((psum + vv[l6]) << 1) + (vv[l2] - vv[l3])) >> 4; 
  373. psum += p2 - vv[l3]; 
  374. vnew[7] = (((psum + vv[l7]) << 1) + (vv[l3] - vv[l4])) >> 4; 
  375. psum += p2 - vv[l4]; 
  376. vnew[8] = (((psum + vv[l8]) << 1) + (vv[l4] - vv[l5])) >> 4;
  377. for (y=1; y<=8; y++) {
  378. vv[y*stride] = vnew[y];
  379. }  
  380. }
  382. #ifdef PP_SELF_CHECK
  383. for (k=0; k<8; k++) {
  384. for (j=0; j<8; j++) { 
  385. if (v[(k+1)*stride + j] != selfcheck[j+8*k]) printf("ERROR: problem with C filter in row %dn", k+1);
  386. }
  387. }
  388. #endif
  390. }
  396. static void deblock_vert_default_filter(uint8_t *v, int stride, int QP) {
  397. int x, a3_0, a3_1, a3_2, d, q;
  398. int l1 = 1 * stride;
  399. int l2 = 2 * stride;
  400. int l3 = 3 * stride;
  401. int l4 = 4 * stride;
  402. int l5 = 5 * stride;
  403. int l6 = 6 * stride;
  404. int l7 = 7 * stride;
  405. int l8 = 8 * stride;
  407. #ifdef PP_SELF_CHECK
  408. int j, k, a3_0_SC, a3_1_SC, a3_2_SC, d_SC, q_SC;
  409. uint8_t selfcheck[8][2];
  410. #endif
  412. #ifdef PP_SELF_CHECK
  413. for (j=0; j<8; j++) {
  414. a3_0_SC = 2*v[l3+j] - 5*v[l4+j] + 5*v[l5+j] - 2*v[l6+j];
  415. a3_1_SC = 2*v[l1+j] - 5*v[l2+j] + 5*v[l3+j] - 2*v[l4+j];
  416. a3_2_SC = 2*v[l5+j] - 5*v[l6+j] + 5*v[l7+j] - 2*v[l8+j];
  417. q_SC    = (v[l4+j] - v[l5+j]) / 2;
  419. if (ABS(a3_0_SC) < 8*QP) {
  421. d_SC = ABS(a3_0_SC) - MIN(ABS(a3_1_SC), ABS(a3_2_SC));
  422. if (d_SC < 0) d_SC=0;
  424. d_SC = (5*d_SC + 32) >> 6; 
  425. d_SC *= SIGN(-a3_0_SC);
  427. if (q_SC > 0) {
  428. d_SC = d_SC<0    ? 0    : d_SC;
  429. d_SC = d_SC>q_SC ? q_SC : d_SC;
  430. } else {
  431. d_SC = d_SC>0    ? 0    : d_SC;
  432. d_SC = d_SC<q_SC ? q_SC : d_SC;
  433. }
  435. } else {
  436. d_SC = 0;
  437. }
  438. selfcheck[j][0] = v[l4+j] - d_SC;
  439. selfcheck[j][1] = v[l5+j] + d_SC;
  440. }
  441. #endif
  443. for (x=0; x<8; x++) {
  444. a3_0 = 2*v[l3+x] - 5*v[l4+x] + 5*v[l5+x] - 2*v[l6+x];
  445. a3_1 = 2*v[l1+x] - 5*v[l2+x] + 5*v[l3+x] - 2*v[l4+x];
  446. a3_2 = 2*v[l5+x] - 5*v[l6+x] + 5*v[l7+x] - 2*v[l8+x];
  447. q    = (v[l4+x] - v[l5+x]) / 2;
  449. if (ABS(a3_0) < 8*QP) {
  451. d = ABS(a3_0) - MIN(ABS(a3_1), ABS(a3_2));
  452. if (d < 0) d=0;
  454. d = (5*d + 32) >> 6; 
  455. d *= SIGN(-a3_0);
  457. if (q > 0) {
  458. d = d<0    ? 0    : d;
  459. d = d>q ? q : d;
  460. } else {
  461. d = d>0    ? 0    : d;
  462. d = d<q ? q : d;
  463. }
  465. } else {
  466. d = 0;
  467. }
  468. v[l4+x] -= d;
  469. v[l5+x] += d;
  470. }
  476. #ifdef PP_SELF_CHECK
  477. for (j=0; j<8; j++) {
  478. for (k=0; k<2; k++) {
  479. if (selfcheck[j][k] != v[l4+j+k*stride]) {
  480. printf("ERROR: problem with vertical default filter in col %d, row %dn", j, k);
  481. printf("%d should be %dn", v[l4+j+k*stride], selfcheck[j][k]);
  483. }
  484. }
  485. }
  486. #endif
  491. }
  502. void deblock_vert( uint8_t *image, int width, int height, int stride, QP_STORE_T *QP_store, int QP_stride, int chroma) {
  503. uint64_t v_local[20];
  504. uint64_t p1p2[4];
  505. int Bx, y;
  506. int QP, QPx16;
  507. uint8_t *v;
  508. int useDC, DC_on;
  510. for (y=8; y<height; y+=8) {
  512. for (Bx=0; Bx<width; Bx+=8) {
  514. QP = chroma ? QP_store[y/8*QP_stride+Bx/8]
  515.             : QP_store[y/16*QP_stride+Bx/16];
  516. QPx16 = 16 * QP;
  517. v = &(image[y*stride + Bx]) - 5*stride;
  519. useDC = deblock_vert_useDC(v, stride);
  521. if (useDC) {
  522. DC_on = deblock_vert_DC_on(v, stride, QP);
  524. if (DC_on) { 
  526. v = &(image[y*stride + Bx])- 5*stride;
  529. deblock_vert_lpf9(v_local, p1p2, v, stride, QP); 
  531. #ifdef SHOWDECISIONS_V
  532. if (!chromaFlag) {
  533. v[4*stride  ] = 
  534. v[4*stride+1] = 
  535. v[4*stride+2] = 
  536. v[4*stride+3] = 
  537. v[4*stride+4] = 
  538. v[4*stride+5] = 
  539. v[4*stride+6] = 
  540. v[4*stride+7] = 255;
  541. }  
  542. #endif
  543. }
  544. }
  546. if (!useDC) { 
  547. v = &(image[y*stride + Bx])- 5*stride;
  549. deblock_vert_default_filter(v, stride, QP);
  551. #ifdef SHOWDECISIONS_V
  552. if (!chromaFlag) {
  553. v[4*stride  ] = 
  554. v[4*stride+1] = 
  555. v[4*stride+2] = 
  556. v[4*stride+3] = 
  557. v[4*stride+4] = 
  558. v[4*stride+5] = 
  559. v[4*stride+6] = 
  560. v[4*stride+7] = 0;
  561. }  
  562. #endif
  563. }
  564. } 
  565. }
  566. }
  574. void dering( uint8_t *image, int width, int height, int stride, QP_STORE_T *QP_store, int QP_stride, int chroma) {
  575. int x, y, h, v, i, j;
  576. uint8_t *b8x8, *b10x10;
  577. uint8_t b8x8filtered[64];
  578. int QP, max_diff;
  579. uint8_t min, max, thr, range;
  580. uint16_t indicesP[10];  
  581. uint16_t indicesN[10];  
  582. uint16_t indices3x3[8]; 
  583. uint16_t sr;
  586. for (y=8; y<height-8; y+=8) {
  587. for (x=8; x< width-8; x+=8) {
  589. QP = chroma ? QP_store[y/8*QP_stride+x/8]
  590.             : QP_store[y/16*QP_stride+x/16];
  593. b8x8   = &(image[stride*y + x]);
  595. b10x10 = &(image[stride*(y-1) + (x-1)]);
  598. min = 255; max = 0;
  599. for (v=0; v<8; v++) {
  600. for (h=0; h<8; h++) {
  601. min = b8x8[stride*v + h] < min ? b8x8[stride*v + h] : min;
  602. max = b8x8[stride*v + h] > max ? b8x8[stride*v + h] : max;
  603. }
  604. } 
  606. thr = (max + min + 1) / 2;
  607. range = max - min;
  610. for (j=0; j<10; j++) {
  611. indicesP[j] = 0;
  612. for (i=0; i<10; i++) {
  613. if (b10x10[j*stride+i] >= thr) indicesP[j] |= (2 << i);
  614. }
  615. indicesN[j] = ~indicesP[j];
  616. }
  618. for (j=0; j<10; j++) {
  619. indicesP[j] = (indicesP[j]<<1) & indicesP[j] & (indicesP[j]>>1);
  620. indicesN[j] = (indicesN[j]<<1) & indicesN[j] & (indicesN[j]>>1);
  621. }
  622. for (j=1; j<9; j++) {
  623. indices3x3[j-1]  = indicesP[j-1] & indicesP[j] & indicesP[j+1];
  624. indices3x3[j-1] |= indicesN[j-1] & indicesN[j] & indicesN[j+1];
  625. }
  627. for (v=0; v<8; v++) {
  628. sr = 4;
  629. for (h=0; h<8; h++) {
  630. if (indices3x3[v] & sr) {
  631. b8x8filtered[8*v + h] = ( 8
  632.  + 1 * b10x10[stride*(v+0) + (h+0)] + 2 * b10x10[stride*(v+0) + (h+1)] + 1 * b10x10[stride*(v+0) + (h+2)]
  633.  + 2 * b10x10[stride*(v+1) + (h+0)] + 4 * b10x10[stride*(v+1) + (h+1)] + 2 * b10x10[stride*(v+1) + (h+2)]
  634.  + 1 * b10x10[stride*(v+2) + (h+0)] + 2 * b10x10[stride*(v+2) + (h+1)] + 1 * b10x10[stride*(v+2) + (h+2)]
  635. ) / 16;
  636. }
  637. sr <<= 1;
  638. }
  639. }
  642. max_diff = QP/2;
  643. for (v=0; v<8; v++) {
  644. sr = 4;
  645. for (h=0; h<8; h++) {
  646. if (indices3x3[v] & sr) {
  647. if        (b8x8filtered[8*v + h] - b8x8[stride*v + h] >  max_diff) {
  648. b8x8[stride*v + h] = b8x8[stride*v + h] + max_diff;
  649. } else if (b8x8filtered[8*v + h] - b8x8[stride*v + h] < -max_diff) {
  650. b8x8[stride*v + h] = b8x8[stride*v + h] - max_diff;
  651. } else {
  652. b8x8[stride*v + h] = b8x8filtered[8*v + h];
  653. }  
  654. }
  655. sr <<= 1;
  656. }
  657. }
  659. }
  660. }
  663. }
  670. void postprocess(unsigned char * src[], int src_stride,
  671.                  unsigned char * dst[], int dst_stride, 
  672.                  int horizontal_size,   int vertical_size, 
  673.                  QP_STORE_T *QP_store,  int QP_stride,
  674.   int mode) {
  675.   
  676. uint8_t *Y, *U, *V;
  677. int x, y;
  679. if (!(mode & PP_DONT_COPY)) {
  681. for (y=0; y<vertical_size; y++) {
  682. for (x=0; x<horizontal_size; x++) {
  683. (dst[0])[y*dst_stride + x] = (src[0])[y*src_stride + x];
  684. }
  685. }
  686. for (y=0; y<vertical_size/2; y++) {
  687. for (x=0; x<horizontal_size/2; x++) {
  688. (dst[1])[y*dst_stride/2 + x] = (src[1])[y*src_stride/2 + x];
  689. (dst[2])[y*dst_stride/2 + x] = (src[2])[y*src_stride/2 + x];
  690. }
  691. }
  692. }
  693.   
  694. Y = dst[0];
  695. U = dst[1];
  696. V = dst[2];
  698. if (mode & PP_DEBLOCK_Y_H) {
  699. deblock_horiz(Y, horizontal_size,   vertical_size,   dst_stride, QP_store, QP_stride, 0);
  700. }
  701. if (mode & PP_DEBLOCK_Y_V) {
  702. deblock_vert( Y, horizontal_size,   vertical_size,   dst_stride, QP_store, QP_stride, 0);
  703. }
  704. if (mode & PP_DEBLOCK_C_H) {
  705. deblock_horiz(U, horizontal_size/2, vertical_size/2, dst_stride/2, QP_store, QP_stride, 1);
  706. deblock_horiz(V, horizontal_size/2, vertical_size/2, dst_stride/2, QP_store, QP_stride, 1);
  707. }
  708. if (mode & PP_DEBLOCK_C_V) {
  709. deblock_vert( U, horizontal_size/2, vertical_size/2, dst_stride/2, QP_store, QP_stride, 1);
  710. deblock_vert( V, horizontal_size/2, vertical_size/2, dst_stride/2, QP_store, QP_stride, 1);
  711. }
  712. if (mode & PP_DERING_Y) {
  713. dering(       Y, horizontal_size,   vertical_size,   dst_stride, QP_store, QP_stride, 0);
  714. }
  715. if (mode & PP_DERING_C) {
  716. dering(       U, horizontal_size/2, vertical_size/2, dst_stride/2, QP_store, QP_stride, 1);
  717. dering(       V, horizontal_size/2, vertical_size/2, dst_stride/2, QP_store, QP_stride, 1);
  718. }
  720. }