/media/libvpx/vp8/decoder/reconintra_mt.c

http://github.com/zpao/v8monkey · C · 937 lines · 765 code · 147 blank · 25 comment · 88 complexity · 3fcca6d2543e021554284991cccb45d9 MD5 · raw file

  1. /*
  2. * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  3. *
  4. * Use of this source code is governed by a BSD-style license
  5. * that can be found in the LICENSE file in the root of the source
  6. * tree. An additional intellectual property rights grant can be found
  7. * in the file PATENTS. All contributing project authors may
  8. * be found in the AUTHORS file in the root of the source tree.
  9. */
  10. #include "vpx_ports/config.h"
  11. #include "vp8/common/recon.h"
  12. #include "vp8/common/reconintra.h"
  13. #include "vpx_mem/vpx_mem.h"
  14. #include "onyxd_int.h"
  15. /* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *x) and
  16. * vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x).
  17. */
  18. void vp8mt_build_intra_predictors_mby(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
  19. {
  20. unsigned char *yabove_row; /* = x->dst.y_buffer - x->dst.y_stride; */
  21. unsigned char *yleft_col;
  22. unsigned char yleft_buf[16];
  23. unsigned char ytop_left; /* = yabove_row[-1]; */
  24. unsigned char *ypred_ptr = x->predictor;
  25. int r, c, i;
  26. if (pbi->common.filter_level)
  27. {
  28. yabove_row = pbi->mt_yabove_row[mb_row] + mb_col*16 +32;
  29. yleft_col = pbi->mt_yleft_col[mb_row];
  30. } else
  31. {
  32. yabove_row = x->dst.y_buffer - x->dst.y_stride;
  33. for (i = 0; i < 16; i++)
  34. yleft_buf[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
  35. yleft_col = yleft_buf;
  36. }
  37. ytop_left = yabove_row[-1];
  38. /* for Y */
  39. switch (x->mode_info_context->mbmi.mode)
  40. {
  41. case DC_PRED:
  42. {
  43. int expected_dc;
  44. int i;
  45. int shift;
  46. int average = 0;
  47. if (x->up_available || x->left_available)
  48. {
  49. if (x->up_available)
  50. {
  51. for (i = 0; i < 16; i++)
  52. {
  53. average += yabove_row[i];
  54. }
  55. }
  56. if (x->left_available)
  57. {
  58. for (i = 0; i < 16; i++)
  59. {
  60. average += yleft_col[i];
  61. }
  62. }
  63. shift = 3 + x->up_available + x->left_available;
  64. expected_dc = (average + (1 << (shift - 1))) >> shift;
  65. }
  66. else
  67. {
  68. expected_dc = 128;
  69. }
  70. vpx_memset(ypred_ptr, expected_dc, 256);
  71. }
  72. break;
  73. case V_PRED:
  74. {
  75. for (r = 0; r < 16; r++)
  76. {
  77. ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
  78. ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
  79. ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
  80. ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
  81. ypred_ptr += 16;
  82. }
  83. }
  84. break;
  85. case H_PRED:
  86. {
  87. for (r = 0; r < 16; r++)
  88. {
  89. vpx_memset(ypred_ptr, yleft_col[r], 16);
  90. ypred_ptr += 16;
  91. }
  92. }
  93. break;
  94. case TM_PRED:
  95. {
  96. for (r = 0; r < 16; r++)
  97. {
  98. for (c = 0; c < 16; c++)
  99. {
  100. int pred = yleft_col[r] + yabove_row[ c] - ytop_left;
  101. if (pred < 0)
  102. pred = 0;
  103. if (pred > 255)
  104. pred = 255;
  105. ypred_ptr[c] = pred;
  106. }
  107. ypred_ptr += 16;
  108. }
  109. }
  110. break;
  111. case B_PRED:
  112. case NEARESTMV:
  113. case NEARMV:
  114. case ZEROMV:
  115. case NEWMV:
  116. case SPLITMV:
  117. case MB_MODE_COUNT:
  118. break;
  119. }
  120. }
  121. void vp8mt_build_intra_predictors_mby_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
  122. {
  123. unsigned char *yabove_row; /* = x->dst.y_buffer - x->dst.y_stride; */
  124. unsigned char *yleft_col;
  125. unsigned char yleft_buf[16];
  126. unsigned char ytop_left; /* = yabove_row[-1]; */
  127. unsigned char *ypred_ptr = x->predictor;
  128. int r, c, i;
  129. int y_stride = x->dst.y_stride;
  130. ypred_ptr = x->dst.y_buffer; /*x->predictor;*/
  131. if (pbi->common.filter_level)
  132. {
  133. yabove_row = pbi->mt_yabove_row[mb_row] + mb_col*16 +32;
  134. yleft_col = pbi->mt_yleft_col[mb_row];
  135. } else
  136. {
  137. yabove_row = x->dst.y_buffer - x->dst.y_stride;
  138. for (i = 0; i < 16; i++)
  139. yleft_buf[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
  140. yleft_col = yleft_buf;
  141. }
  142. ytop_left = yabove_row[-1];
  143. /* for Y */
  144. switch (x->mode_info_context->mbmi.mode)
  145. {
  146. case DC_PRED:
  147. {
  148. int expected_dc;
  149. int i;
  150. int shift;
  151. int average = 0;
  152. if (x->up_available || x->left_available)
  153. {
  154. if (x->up_available)
  155. {
  156. for (i = 0; i < 16; i++)
  157. {
  158. average += yabove_row[i];
  159. }
  160. }
  161. if (x->left_available)
  162. {
  163. for (i = 0; i < 16; i++)
  164. {
  165. average += yleft_col[i];
  166. }
  167. }
  168. shift = 3 + x->up_available + x->left_available;
  169. expected_dc = (average + (1 << (shift - 1))) >> shift;
  170. }
  171. else
  172. {
  173. expected_dc = 128;
  174. }
  175. /*vpx_memset(ypred_ptr, expected_dc, 256);*/
  176. for (r = 0; r < 16; r++)
  177. {
  178. vpx_memset(ypred_ptr, expected_dc, 16);
  179. ypred_ptr += y_stride; /*16;*/
  180. }
  181. }
  182. break;
  183. case V_PRED:
  184. {
  185. for (r = 0; r < 16; r++)
  186. {
  187. ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
  188. ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
  189. ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
  190. ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
  191. ypred_ptr += y_stride; /*16;*/
  192. }
  193. }
  194. break;
  195. case H_PRED:
  196. {
  197. for (r = 0; r < 16; r++)
  198. {
  199. vpx_memset(ypred_ptr, yleft_col[r], 16);
  200. ypred_ptr += y_stride; /*16;*/
  201. }
  202. }
  203. break;
  204. case TM_PRED:
  205. {
  206. for (r = 0; r < 16; r++)
  207. {
  208. for (c = 0; c < 16; c++)
  209. {
  210. int pred = yleft_col[r] + yabove_row[ c] - ytop_left;
  211. if (pred < 0)
  212. pred = 0;
  213. if (pred > 255)
  214. pred = 255;
  215. ypred_ptr[c] = pred;
  216. }
  217. ypred_ptr += y_stride; /*16;*/
  218. }
  219. }
  220. break;
  221. case B_PRED:
  222. case NEARESTMV:
  223. case NEARMV:
  224. case ZEROMV:
  225. case NEWMV:
  226. case SPLITMV:
  227. case MB_MODE_COUNT:
  228. break;
  229. }
  230. }
  231. void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
  232. {
  233. unsigned char *uabove_row; /* = x->dst.u_buffer - x->dst.uv_stride; */
  234. unsigned char *uleft_col; /*[16];*/
  235. unsigned char uleft_buf[8];
  236. unsigned char utop_left; /* = uabove_row[-1]; */
  237. unsigned char *vabove_row; /* = x->dst.v_buffer - x->dst.uv_stride; */
  238. unsigned char *vleft_col; /*[20];*/
  239. unsigned char vleft_buf[8];
  240. unsigned char vtop_left; /* = vabove_row[-1]; */
  241. unsigned char *upred_ptr = &x->predictor[256];
  242. unsigned char *vpred_ptr = &x->predictor[320];
  243. int i, j;
  244. if (pbi->common.filter_level)
  245. {
  246. uabove_row = pbi->mt_uabove_row[mb_row] + mb_col*8 +16;
  247. vabove_row = pbi->mt_vabove_row[mb_row] + mb_col*8 +16;
  248. uleft_col = pbi->mt_uleft_col[mb_row];
  249. vleft_col = pbi->mt_vleft_col[mb_row];
  250. } else
  251. {
  252. uabove_row = x->dst.u_buffer - x->dst.uv_stride;
  253. vabove_row = x->dst.v_buffer - x->dst.uv_stride;
  254. for (i = 0; i < 8; i++)
  255. {
  256. uleft_buf[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
  257. vleft_buf[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
  258. }
  259. uleft_col = uleft_buf;
  260. vleft_col = vleft_buf;
  261. }
  262. utop_left = uabove_row[-1];
  263. vtop_left = vabove_row[-1];
  264. switch (x->mode_info_context->mbmi.uv_mode)
  265. {
  266. case DC_PRED:
  267. {
  268. int expected_udc;
  269. int expected_vdc;
  270. int i;
  271. int shift;
  272. int Uaverage = 0;
  273. int Vaverage = 0;
  274. if (x->up_available)
  275. {
  276. for (i = 0; i < 8; i++)
  277. {
  278. Uaverage += uabove_row[i];
  279. Vaverage += vabove_row[i];
  280. }
  281. }
  282. if (x->left_available)
  283. {
  284. for (i = 0; i < 8; i++)
  285. {
  286. Uaverage += uleft_col[i];
  287. Vaverage += vleft_col[i];
  288. }
  289. }
  290. if (!x->up_available && !x->left_available)
  291. {
  292. expected_udc = 128;
  293. expected_vdc = 128;
  294. }
  295. else
  296. {
  297. shift = 2 + x->up_available + x->left_available;
  298. expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
  299. expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
  300. }
  301. vpx_memset(upred_ptr, expected_udc, 64);
  302. vpx_memset(vpred_ptr, expected_vdc, 64);
  303. }
  304. break;
  305. case V_PRED:
  306. {
  307. int i;
  308. for (i = 0; i < 8; i++)
  309. {
  310. vpx_memcpy(upred_ptr, uabove_row, 8);
  311. vpx_memcpy(vpred_ptr, vabove_row, 8);
  312. upred_ptr += 8;
  313. vpred_ptr += 8;
  314. }
  315. }
  316. break;
  317. case H_PRED:
  318. {
  319. int i;
  320. for (i = 0; i < 8; i++)
  321. {
  322. vpx_memset(upred_ptr, uleft_col[i], 8);
  323. vpx_memset(vpred_ptr, vleft_col[i], 8);
  324. upred_ptr += 8;
  325. vpred_ptr += 8;
  326. }
  327. }
  328. break;
  329. case TM_PRED:
  330. {
  331. int i;
  332. for (i = 0; i < 8; i++)
  333. {
  334. for (j = 0; j < 8; j++)
  335. {
  336. int predu = uleft_col[i] + uabove_row[j] - utop_left;
  337. int predv = vleft_col[i] + vabove_row[j] - vtop_left;
  338. if (predu < 0)
  339. predu = 0;
  340. if (predu > 255)
  341. predu = 255;
  342. if (predv < 0)
  343. predv = 0;
  344. if (predv > 255)
  345. predv = 255;
  346. upred_ptr[j] = predu;
  347. vpred_ptr[j] = predv;
  348. }
  349. upred_ptr += 8;
  350. vpred_ptr += 8;
  351. }
  352. }
  353. break;
  354. case B_PRED:
  355. case NEARESTMV:
  356. case NEARMV:
  357. case ZEROMV:
  358. case NEWMV:
  359. case SPLITMV:
  360. case MB_MODE_COUNT:
  361. break;
  362. }
  363. }
  364. void vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
  365. {
  366. unsigned char *uabove_row; /* = x->dst.u_buffer - x->dst.uv_stride; */
  367. unsigned char *uleft_col; /*[16];*/
  368. unsigned char uleft_buf[8];
  369. unsigned char utop_left; /* = uabove_row[-1]; */
  370. unsigned char *vabove_row; /* = x->dst.v_buffer - x->dst.uv_stride; */
  371. unsigned char *vleft_col; /*[20];*/
  372. unsigned char vleft_buf[8];
  373. unsigned char vtop_left; /* = vabove_row[-1]; */
  374. unsigned char *upred_ptr = x->dst.u_buffer; /*&x->predictor[256];*/
  375. unsigned char *vpred_ptr = x->dst.v_buffer; /*&x->predictor[320];*/
  376. int uv_stride = x->dst.uv_stride;
  377. int i, j;
  378. if (pbi->common.filter_level)
  379. {
  380. uabove_row = pbi->mt_uabove_row[mb_row] + mb_col*8 +16;
  381. vabove_row = pbi->mt_vabove_row[mb_row] + mb_col*8 +16;
  382. uleft_col = pbi->mt_uleft_col[mb_row];
  383. vleft_col = pbi->mt_vleft_col[mb_row];
  384. } else
  385. {
  386. uabove_row = x->dst.u_buffer - x->dst.uv_stride;
  387. vabove_row = x->dst.v_buffer - x->dst.uv_stride;
  388. for (i = 0; i < 8; i++)
  389. {
  390. uleft_buf[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
  391. vleft_buf[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
  392. }
  393. uleft_col = uleft_buf;
  394. vleft_col = vleft_buf;
  395. }
  396. utop_left = uabove_row[-1];
  397. vtop_left = vabove_row[-1];
  398. switch (x->mode_info_context->mbmi.uv_mode)
  399. {
  400. case DC_PRED:
  401. {
  402. int expected_udc;
  403. int expected_vdc;
  404. int i;
  405. int shift;
  406. int Uaverage = 0;
  407. int Vaverage = 0;
  408. if (x->up_available)
  409. {
  410. for (i = 0; i < 8; i++)
  411. {
  412. Uaverage += uabove_row[i];
  413. Vaverage += vabove_row[i];
  414. }
  415. }
  416. if (x->left_available)
  417. {
  418. for (i = 0; i < 8; i++)
  419. {
  420. Uaverage += uleft_col[i];
  421. Vaverage += vleft_col[i];
  422. }
  423. }
  424. if (!x->up_available && !x->left_available)
  425. {
  426. expected_udc = 128;
  427. expected_vdc = 128;
  428. }
  429. else
  430. {
  431. shift = 2 + x->up_available + x->left_available;
  432. expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
  433. expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
  434. }
  435. /*vpx_memset(upred_ptr,expected_udc,64);
  436. vpx_memset(vpred_ptr,expected_vdc,64);*/
  437. for (i = 0; i < 8; i++)
  438. {
  439. vpx_memset(upred_ptr, expected_udc, 8);
  440. vpx_memset(vpred_ptr, expected_vdc, 8);
  441. upred_ptr += uv_stride; /*8;*/
  442. vpred_ptr += uv_stride; /*8;*/
  443. }
  444. }
  445. break;
  446. case V_PRED:
  447. {
  448. int i;
  449. for (i = 0; i < 8; i++)
  450. {
  451. vpx_memcpy(upred_ptr, uabove_row, 8);
  452. vpx_memcpy(vpred_ptr, vabove_row, 8);
  453. upred_ptr += uv_stride; /*8;*/
  454. vpred_ptr += uv_stride; /*8;*/
  455. }
  456. }
  457. break;
  458. case H_PRED:
  459. {
  460. int i;
  461. for (i = 0; i < 8; i++)
  462. {
  463. vpx_memset(upred_ptr, uleft_col[i], 8);
  464. vpx_memset(vpred_ptr, vleft_col[i], 8);
  465. upred_ptr += uv_stride; /*8;*/
  466. vpred_ptr += uv_stride; /*8;*/
  467. }
  468. }
  469. break;
  470. case TM_PRED:
  471. {
  472. int i;
  473. for (i = 0; i < 8; i++)
  474. {
  475. for (j = 0; j < 8; j++)
  476. {
  477. int predu = uleft_col[i] + uabove_row[j] - utop_left;
  478. int predv = vleft_col[i] + vabove_row[j] - vtop_left;
  479. if (predu < 0)
  480. predu = 0;
  481. if (predu > 255)
  482. predu = 255;
  483. if (predv < 0)
  484. predv = 0;
  485. if (predv > 255)
  486. predv = 255;
  487. upred_ptr[j] = predu;
  488. vpred_ptr[j] = predv;
  489. }
  490. upred_ptr += uv_stride; /*8;*/
  491. vpred_ptr += uv_stride; /*8;*/
  492. }
  493. }
  494. break;
  495. case B_PRED:
  496. case NEARESTMV:
  497. case NEARMV:
  498. case ZEROMV:
  499. case NEWMV:
  500. case SPLITMV:
  501. case MB_MODE_COUNT:
  502. break;
  503. }
  504. }
  505. void vp8mt_predict_intra4x4(VP8D_COMP *pbi,
  506. MACROBLOCKD *xd,
  507. int b_mode,
  508. unsigned char *predictor,
  509. int mb_row,
  510. int mb_col,
  511. int num)
  512. {
  513. int i, r, c;
  514. unsigned char *Above; /* = *(x->base_dst) + x->dst - x->dst_stride; */
  515. unsigned char Left[4];
  516. unsigned char top_left; /* = Above[-1]; */
  517. BLOCKD *x = &xd->block[num];
  518. /*Caution: For some b_mode, it needs 8 pixels (4 above + 4 above-right).*/
  519. if (num < 4 && pbi->common.filter_level)
  520. Above = pbi->mt_yabove_row[mb_row] + mb_col*16 + num*4 + 32;
  521. else
  522. Above = *(x->base_dst) + x->dst - x->dst_stride;
  523. if (num%4==0 && pbi->common.filter_level)
  524. {
  525. for (i=0; i<4; i++)
  526. Left[i] = pbi->mt_yleft_col[mb_row][num + i];
  527. }else
  528. {
  529. Left[0] = (*(x->base_dst))[x->dst - 1];
  530. Left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride];
  531. Left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride];
  532. Left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride];
  533. }
  534. if ((num==4 || num==8 || num==12) && pbi->common.filter_level)
  535. top_left = pbi->mt_yleft_col[mb_row][num-1];
  536. else
  537. top_left = Above[-1];
  538. switch (b_mode)
  539. {
  540. case B_DC_PRED:
  541. {
  542. int expected_dc = 0;
  543. for (i = 0; i < 4; i++)
  544. {
  545. expected_dc += Above[i];
  546. expected_dc += Left[i];
  547. }
  548. expected_dc = (expected_dc + 4) >> 3;
  549. for (r = 0; r < 4; r++)
  550. {
  551. for (c = 0; c < 4; c++)
  552. {
  553. predictor[c] = expected_dc;
  554. }
  555. predictor += 16;
  556. }
  557. }
  558. break;
  559. case B_TM_PRED:
  560. {
  561. /* prediction similar to true_motion prediction */
  562. for (r = 0; r < 4; r++)
  563. {
  564. for (c = 0; c < 4; c++)
  565. {
  566. int pred = Above[c] - top_left + Left[r];
  567. if (pred < 0)
  568. pred = 0;
  569. if (pred > 255)
  570. pred = 255;
  571. predictor[c] = pred;
  572. }
  573. predictor += 16;
  574. }
  575. }
  576. break;
  577. case B_VE_PRED:
  578. {
  579. unsigned int ap[4];
  580. ap[0] = (top_left + 2 * Above[0] + Above[1] + 2) >> 2;
  581. ap[1] = (Above[0] + 2 * Above[1] + Above[2] + 2) >> 2;
  582. ap[2] = (Above[1] + 2 * Above[2] + Above[3] + 2) >> 2;
  583. ap[3] = (Above[2] + 2 * Above[3] + Above[4] + 2) >> 2;
  584. for (r = 0; r < 4; r++)
  585. {
  586. for (c = 0; c < 4; c++)
  587. {
  588. predictor[c] = ap[c];
  589. }
  590. predictor += 16;
  591. }
  592. }
  593. break;
  594. case B_HE_PRED:
  595. {
  596. unsigned int lp[4];
  597. lp[0] = (top_left + 2 * Left[0] + Left[1] + 2) >> 2;
  598. lp[1] = (Left[0] + 2 * Left[1] + Left[2] + 2) >> 2;
  599. lp[2] = (Left[1] + 2 * Left[2] + Left[3] + 2) >> 2;
  600. lp[3] = (Left[2] + 2 * Left[3] + Left[3] + 2) >> 2;
  601. for (r = 0; r < 4; r++)
  602. {
  603. for (c = 0; c < 4; c++)
  604. {
  605. predictor[c] = lp[r];
  606. }
  607. predictor += 16;
  608. }
  609. }
  610. break;
  611. case B_LD_PRED:
  612. {
  613. unsigned char *ptr = Above;
  614. predictor[0 * 16 + 0] = (ptr[0] + ptr[1] * 2 + ptr[2] + 2) >> 2;
  615. predictor[0 * 16 + 1] =
  616. predictor[1 * 16 + 0] = (ptr[1] + ptr[2] * 2 + ptr[3] + 2) >> 2;
  617. predictor[0 * 16 + 2] =
  618. predictor[1 * 16 + 1] =
  619. predictor[2 * 16 + 0] = (ptr[2] + ptr[3] * 2 + ptr[4] + 2) >> 2;
  620. predictor[0 * 16 + 3] =
  621. predictor[1 * 16 + 2] =
  622. predictor[2 * 16 + 1] =
  623. predictor[3 * 16 + 0] = (ptr[3] + ptr[4] * 2 + ptr[5] + 2) >> 2;
  624. predictor[1 * 16 + 3] =
  625. predictor[2 * 16 + 2] =
  626. predictor[3 * 16 + 1] = (ptr[4] + ptr[5] * 2 + ptr[6] + 2) >> 2;
  627. predictor[2 * 16 + 3] =
  628. predictor[3 * 16 + 2] = (ptr[5] + ptr[6] * 2 + ptr[7] + 2) >> 2;
  629. predictor[3 * 16 + 3] = (ptr[6] + ptr[7] * 2 + ptr[7] + 2) >> 2;
  630. }
  631. break;
  632. case B_RD_PRED:
  633. {
  634. unsigned char pp[9];
  635. pp[0] = Left[3];
  636. pp[1] = Left[2];
  637. pp[2] = Left[1];
  638. pp[3] = Left[0];
  639. pp[4] = top_left;
  640. pp[5] = Above[0];
  641. pp[6] = Above[1];
  642. pp[7] = Above[2];
  643. pp[8] = Above[3];
  644. predictor[3 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
  645. predictor[3 * 16 + 1] =
  646. predictor[2 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
  647. predictor[3 * 16 + 2] =
  648. predictor[2 * 16 + 1] =
  649. predictor[1 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
  650. predictor[3 * 16 + 3] =
  651. predictor[2 * 16 + 2] =
  652. predictor[1 * 16 + 1] =
  653. predictor[0 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
  654. predictor[2 * 16 + 3] =
  655. predictor[1 * 16 + 2] =
  656. predictor[0 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
  657. predictor[1 * 16 + 3] =
  658. predictor[0 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
  659. predictor[0 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2;
  660. }
  661. break;
  662. case B_VR_PRED:
  663. {
  664. unsigned char pp[9];
  665. pp[0] = Left[3];
  666. pp[1] = Left[2];
  667. pp[2] = Left[1];
  668. pp[3] = Left[0];
  669. pp[4] = top_left;
  670. pp[5] = Above[0];
  671. pp[6] = Above[1];
  672. pp[7] = Above[2];
  673. pp[8] = Above[3];
  674. predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
  675. predictor[2 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
  676. predictor[3 * 16 + 1] =
  677. predictor[1 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
  678. predictor[2 * 16 + 1] =
  679. predictor[0 * 16 + 0] = (pp[4] + pp[5] + 1) >> 1;
  680. predictor[3 * 16 + 2] =
  681. predictor[1 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
  682. predictor[2 * 16 + 2] =
  683. predictor[0 * 16 + 1] = (pp[5] + pp[6] + 1) >> 1;
  684. predictor[3 * 16 + 3] =
  685. predictor[1 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
  686. predictor[2 * 16 + 3] =
  687. predictor[0 * 16 + 2] = (pp[6] + pp[7] + 1) >> 1;
  688. predictor[1 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2;
  689. predictor[0 * 16 + 3] = (pp[7] + pp[8] + 1) >> 1;
  690. }
  691. break;
  692. case B_VL_PRED:
  693. {
  694. unsigned char *pp = Above;
  695. predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
  696. predictor[1 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
  697. predictor[2 * 16 + 0] =
  698. predictor[0 * 16 + 1] = (pp[1] + pp[2] + 1) >> 1;
  699. predictor[1 * 16 + 1] =
  700. predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
  701. predictor[2 * 16 + 1] =
  702. predictor[0 * 16 + 2] = (pp[2] + pp[3] + 1) >> 1;
  703. predictor[3 * 16 + 1] =
  704. predictor[1 * 16 + 2] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
  705. predictor[0 * 16 + 3] =
  706. predictor[2 * 16 + 2] = (pp[3] + pp[4] + 1) >> 1;
  707. predictor[1 * 16 + 3] =
  708. predictor[3 * 16 + 2] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
  709. predictor[2 * 16 + 3] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
  710. predictor[3 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
  711. }
  712. break;
  713. case B_HD_PRED:
  714. {
  715. unsigned char pp[9];
  716. pp[0] = Left[3];
  717. pp[1] = Left[2];
  718. pp[2] = Left[1];
  719. pp[3] = Left[0];
  720. pp[4] = top_left;
  721. pp[5] = Above[0];
  722. pp[6] = Above[1];
  723. pp[7] = Above[2];
  724. pp[8] = Above[3];
  725. predictor[3 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
  726. predictor[3 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
  727. predictor[2 * 16 + 0] =
  728. predictor[3 * 16 + 2] = (pp[1] + pp[2] + 1) >> 1;
  729. predictor[2 * 16 + 1] =
  730. predictor[3 * 16 + 3] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
  731. predictor[2 * 16 + 2] =
  732. predictor[1 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1;
  733. predictor[2 * 16 + 3] =
  734. predictor[1 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
  735. predictor[1 * 16 + 2] =
  736. predictor[0 * 16 + 0] = (pp[3] + pp[4] + 1) >> 1;
  737. predictor[1 * 16 + 3] =
  738. predictor[0 * 16 + 1] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
  739. predictor[0 * 16 + 2] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
  740. predictor[0 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
  741. }
  742. break;
  743. case B_HU_PRED:
  744. {
  745. unsigned char *pp = Left;
  746. predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
  747. predictor[0 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
  748. predictor[0 * 16 + 2] =
  749. predictor[1 * 16 + 0] = (pp[1] + pp[2] + 1) >> 1;
  750. predictor[0 * 16 + 3] =
  751. predictor[1 * 16 + 1] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
  752. predictor[1 * 16 + 2] =
  753. predictor[2 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1;
  754. predictor[1 * 16 + 3] =
  755. predictor[2 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[3] + 2) >> 2;
  756. predictor[2 * 16 + 2] =
  757. predictor[2 * 16 + 3] =
  758. predictor[3 * 16 + 0] =
  759. predictor[3 * 16 + 1] =
  760. predictor[3 * 16 + 2] =
  761. predictor[3 * 16 + 3] = pp[3];
  762. }
  763. break;
  764. }
  765. }
  766. /* copy 4 bytes from the above right down so that the 4x4 prediction modes using pixels above and
  767. * to the right prediction have filled in pixels to use.
  768. */
  769. void vp8mt_intra_prediction_down_copy(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
  770. {
  771. unsigned char *above_right; /* = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16; */
  772. unsigned int *src_ptr;
  773. unsigned int *dst_ptr0;
  774. unsigned int *dst_ptr1;
  775. unsigned int *dst_ptr2;
  776. if (pbi->common.filter_level)
  777. above_right = pbi->mt_yabove_row[mb_row] + mb_col*16 + 32 +16;
  778. else
  779. above_right = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16;
  780. src_ptr = (unsigned int *)above_right;
  781. /*dst_ptr0 = (unsigned int *)(above_right + 4 * x->block[0].dst_stride);
  782. dst_ptr1 = (unsigned int *)(above_right + 8 * x->block[0].dst_stride);
  783. dst_ptr2 = (unsigned int *)(above_right + 12 * x->block[0].dst_stride);*/
  784. dst_ptr0 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 3 * x->block[0].dst_stride);
  785. dst_ptr1 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 7 * x->block[0].dst_stride);
  786. dst_ptr2 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 11 * x->block[0].dst_stride);
  787. *dst_ptr0 = *src_ptr;
  788. *dst_ptr1 = *src_ptr;
  789. *dst_ptr2 = *src_ptr;
  790. }