pred_template.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553
  1. /*
  2. * HEVC video decoder
  3. *
  4. * Copyright (C) 2012 - 2013 Guillaume Martres
  5. *
  6. * This file is part of FFmpeg.
  7. *
  8. * FFmpeg is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU Lesser General Public
  10. * License as published by the Free Software Foundation; either
  11. * version 2.1 of the License, or (at your option) any later version.
  12. *
  13. * FFmpeg is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16. * Lesser General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU Lesser General Public
  19. * License along with FFmpeg; if not, write to the Free Software
  20. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21. */
  22. #include "libavutil/pixdesc.h"
  23. #include "bit_depth_template.c"
  24. #include "pred.h"
  25. #define POS(x, y) src[(x) + stride * (y)]
  26. static av_always_inline void FUNC(intra_pred)(HEVCLocalContext *lc,
  27. const HEVCPPS *pps,
  28. int x0, int y0,
  29. int log2_size, int c_idx)
  30. {
  31. #define PU(x) \
  32. ((x) >> sps->log2_min_pu_size)
  33. #define MVF(x, y) \
  34. (s->cur_frame->tab_mvf[(x) + (y) * min_pu_width])
  35. #define MVF_PU(x, y) \
  36. MVF(PU(x0 + ((x) * (1 << hshift))), PU(y0 + ((y) * (1 << vshift))))
  37. #define IS_INTRA(x, y) \
  38. (MVF_PU(x, y).pred_flag == PF_INTRA)
  39. #define MIN_TB_ADDR_ZS(x, y) \
  40. pps->min_tb_addr_zs[(y) * (sps->tb_mask+2) + (x)]
  41. #define EXTEND(ptr, val, len) \
  42. do { \
  43. pixel4 pix = PIXEL_SPLAT_X4(val); \
  44. for (i = 0; i < (len); i += 4) \
  45. AV_WN4P(ptr + i, pix); \
  46. } while (0)
  47. #define EXTEND_RIGHT_CIP(ptr, start, length) \
  48. for (i = start; i < (start) + (length); i += 4) \
  49. if (!IS_INTRA(i, -1)) \
  50. AV_WN4P(&ptr[i], a); \
  51. else \
  52. a = PIXEL_SPLAT_X4(ptr[i+3])
  53. #define EXTEND_LEFT_CIP(ptr, start, length) \
  54. for (i = start; i > (start) - (length); i--) \
  55. if (!IS_INTRA(i - 1, -1)) \
  56. ptr[i - 1] = ptr[i]
  57. #define EXTEND_UP_CIP(ptr, start, length) \
  58. for (i = (start); i > (start) - (length); i -= 4) \
  59. if (!IS_INTRA(-1, i - 3)) \
  60. AV_WN4P(&ptr[i - 3], a); \
  61. else \
  62. a = PIXEL_SPLAT_X4(ptr[i - 3])
  63. #define EXTEND_DOWN_CIP(ptr, start, length) \
  64. for (i = start; i < (start) + (length); i += 4) \
  65. if (!IS_INTRA(-1, i)) \
  66. AV_WN4P(&ptr[i], a); \
  67. else \
  68. a = PIXEL_SPLAT_X4(ptr[i + 3])
  69. const HEVCSPS *const sps = pps->sps;
  70. const HEVCContext *const s = lc->parent;
  71. int i;
  72. int hshift = sps->hshift[c_idx];
  73. int vshift = sps->vshift[c_idx];
  74. int size = (1 << log2_size);
  75. int size_in_luma_h = size << hshift;
  76. int size_in_tbs_h = size_in_luma_h >> sps->log2_min_tb_size;
  77. int size_in_luma_v = size << vshift;
  78. int size_in_tbs_v = size_in_luma_v >> sps->log2_min_tb_size;
  79. int x = x0 >> hshift;
  80. int y = y0 >> vshift;
  81. int x_tb = (x0 >> sps->log2_min_tb_size) & sps->tb_mask;
  82. int y_tb = (y0 >> sps->log2_min_tb_size) & sps->tb_mask;
  83. int spin = c_idx && !size_in_tbs_v && ((2 * y0) & (1 << sps->log2_min_tb_size));
  84. int cur_tb_addr = MIN_TB_ADDR_ZS(x_tb, y_tb);
  85. ptrdiff_t stride = s->cur_frame->f->linesize[c_idx] / sizeof(pixel);
  86. pixel *src = (pixel*)s->cur_frame->f->data[c_idx] + x + y * stride;
  87. int min_pu_width = sps->min_pu_width;
  88. enum IntraPredMode mode = c_idx ? lc->tu.intra_pred_mode_c :
  89. lc->tu.intra_pred_mode;
  90. pixel4 a;
  91. pixel left_array[2 * MAX_TB_SIZE + 1];
  92. pixel filtered_left_array[2 * MAX_TB_SIZE + 1];
  93. pixel top_array[2 * MAX_TB_SIZE + 1];
  94. pixel filtered_top_array[2 * MAX_TB_SIZE + 1];
  95. pixel *left = left_array + 1;
  96. pixel *top = top_array + 1;
  97. pixel *filtered_left = filtered_left_array + 1;
  98. pixel *filtered_top = filtered_top_array + 1;
  99. int cand_bottom_left = lc->na.cand_bottom_left && cur_tb_addr > MIN_TB_ADDR_ZS( x_tb - 1, (y_tb + size_in_tbs_v + spin) & sps->tb_mask);
  100. int cand_left = lc->na.cand_left;
  101. int cand_up_left = lc->na.cand_up_left;
  102. int cand_up = lc->na.cand_up;
  103. int cand_up_right = lc->na.cand_up_right && !spin && cur_tb_addr > MIN_TB_ADDR_ZS((x_tb + size_in_tbs_h) & sps->tb_mask, y_tb - 1);
  104. int bottom_left_size = (FFMIN(y0 + 2 * size_in_luma_v, sps->height) -
  105. (y0 + size_in_luma_v)) >> vshift;
  106. int top_right_size = (FFMIN(x0 + 2 * size_in_luma_h, sps->width) -
  107. (x0 + size_in_luma_h)) >> hshift;
  108. if (pps->constrained_intra_pred_flag == 1) {
  109. int size_in_luma_pu_v = PU(size_in_luma_v);
  110. int size_in_luma_pu_h = PU(size_in_luma_h);
  111. int on_pu_edge_x = !av_zero_extend(x0, sps->log2_min_pu_size);
  112. int on_pu_edge_y = !av_zero_extend(y0, sps->log2_min_pu_size);
  113. if (!size_in_luma_pu_h)
  114. size_in_luma_pu_h++;
  115. if (cand_bottom_left == 1 && on_pu_edge_x) {
  116. int x_left_pu = PU(x0 - 1);
  117. int y_bottom_pu = PU(y0 + size_in_luma_v);
  118. int max = FFMIN(size_in_luma_pu_v, sps->min_pu_height - y_bottom_pu);
  119. cand_bottom_left = 0;
  120. for (i = 0; i < max; i += 2)
  121. cand_bottom_left |= (MVF(x_left_pu, y_bottom_pu + i).pred_flag == PF_INTRA);
  122. }
  123. if (cand_left == 1 && on_pu_edge_x) {
  124. int x_left_pu = PU(x0 - 1);
  125. int y_left_pu = PU(y0);
  126. int max = FFMIN(size_in_luma_pu_v, sps->min_pu_height - y_left_pu);
  127. cand_left = 0;
  128. for (i = 0; i < max; i += 2)
  129. cand_left |= (MVF(x_left_pu, y_left_pu + i).pred_flag == PF_INTRA);
  130. }
  131. if (cand_up_left == 1) {
  132. int x_left_pu = PU(x0 - 1);
  133. int y_top_pu = PU(y0 - 1);
  134. cand_up_left = MVF(x_left_pu, y_top_pu).pred_flag == PF_INTRA;
  135. }
  136. if (cand_up == 1 && on_pu_edge_y) {
  137. int x_top_pu = PU(x0);
  138. int y_top_pu = PU(y0 - 1);
  139. int max = FFMIN(size_in_luma_pu_h, sps->min_pu_width - x_top_pu);
  140. cand_up = 0;
  141. for (i = 0; i < max; i += 2)
  142. cand_up |= (MVF(x_top_pu + i, y_top_pu).pred_flag == PF_INTRA);
  143. }
  144. if (cand_up_right == 1 && on_pu_edge_y) {
  145. int y_top_pu = PU(y0 - 1);
  146. int x_right_pu = PU(x0 + size_in_luma_h);
  147. int max = FFMIN(size_in_luma_pu_h, sps->min_pu_width - x_right_pu);
  148. cand_up_right = 0;
  149. for (i = 0; i < max; i += 2)
  150. cand_up_right |= (MVF(x_right_pu + i, y_top_pu).pred_flag == PF_INTRA);
  151. }
  152. memset(left, 128, 2 * MAX_TB_SIZE*sizeof(pixel));
  153. memset(top , 128, 2 * MAX_TB_SIZE*sizeof(pixel));
  154. top[-1] = 128;
  155. }
  156. if (cand_up_left) {
  157. left[-1] = POS(-1, -1);
  158. top[-1] = left[-1];
  159. }
  160. if (cand_up)
  161. memcpy(top, src - stride, size * sizeof(pixel));
  162. if (cand_up_right) {
  163. memcpy(top + size, src - stride + size, size * sizeof(pixel));
  164. EXTEND(top + size + top_right_size, POS(size + top_right_size - 1, -1),
  165. size - top_right_size);
  166. }
  167. if (cand_left)
  168. for (i = 0; i < size; i++)
  169. left[i] = POS(-1, i);
  170. if (cand_bottom_left) {
  171. for (i = size; i < size + bottom_left_size; i++)
  172. left[i] = POS(-1, i);
  173. EXTEND(left + size + bottom_left_size, POS(-1, size + bottom_left_size - 1),
  174. size - bottom_left_size);
  175. }
  176. if (pps->constrained_intra_pred_flag == 1) {
  177. if (cand_bottom_left || cand_left || cand_up_left || cand_up || cand_up_right) {
  178. int size_max_x = x0 + ((2 * size) << hshift) < sps->width ?
  179. 2 * size : (sps->width - x0) >> hshift;
  180. int size_max_y = y0 + ((2 * size) << vshift) < sps->height ?
  181. 2 * size : (sps->height - y0) >> vshift;
  182. int j = size + (cand_bottom_left? bottom_left_size: 0) -1;
  183. if (!cand_up_right) {
  184. size_max_x = x0 + ((size) << hshift) < sps->width ?
  185. size : (sps->width - x0) >> hshift;
  186. }
  187. if (!cand_bottom_left) {
  188. size_max_y = y0 + (( size) << vshift) < sps->height ?
  189. size : (sps->height - y0) >> vshift;
  190. }
  191. if (cand_bottom_left || cand_left || cand_up_left) {
  192. while (j > -1 && !IS_INTRA(-1, j))
  193. j--;
  194. if (!IS_INTRA(-1, j)) {
  195. j = 0;
  196. while (j < size_max_x && !IS_INTRA(j, -1))
  197. j++;
  198. EXTEND_LEFT_CIP(top, j, j + 1);
  199. left[-1] = top[-1];
  200. }
  201. } else {
  202. j = 0;
  203. while (j < size_max_x && !IS_INTRA(j, -1))
  204. j++;
  205. if (j > 0) {
  206. EXTEND_LEFT_CIP(top, j, j);
  207. top[-1] = top[0];
  208. }
  209. left[-1] = top[-1];
  210. }
  211. left[-1] = top[-1];
  212. if (cand_bottom_left || cand_left) {
  213. a = PIXEL_SPLAT_X4(left[-1]);
  214. EXTEND_DOWN_CIP(left, 0, size_max_y);
  215. }
  216. if (!cand_left)
  217. EXTEND(left, left[-1], size);
  218. if (!cand_bottom_left)
  219. EXTEND(left + size, left[size - 1], size);
  220. if (x0 != 0 && y0 != 0) {
  221. a = PIXEL_SPLAT_X4(left[size_max_y - 1]);
  222. EXTEND_UP_CIP(left, size_max_y - 1, size_max_y);
  223. if (!IS_INTRA(-1, - 1))
  224. left[-1] = left[0];
  225. } else if (x0 == 0) {
  226. EXTEND(left, 0, size_max_y);
  227. } else {
  228. a = PIXEL_SPLAT_X4(left[size_max_y - 1]);
  229. EXTEND_UP_CIP(left, size_max_y - 1, size_max_y);
  230. }
  231. top[-1] = left[-1];
  232. if (y0 != 0) {
  233. a = PIXEL_SPLAT_X4(left[-1]);
  234. EXTEND_RIGHT_CIP(top, 0, size_max_x);
  235. }
  236. }
  237. }
  238. // Infer the unavailable samples
  239. if (!cand_bottom_left) {
  240. if (cand_left) {
  241. EXTEND(left + size, left[size - 1], size);
  242. } else if (cand_up_left) {
  243. EXTEND(left, left[-1], 2 * size);
  244. cand_left = 1;
  245. } else if (cand_up) {
  246. left[-1] = top[0];
  247. EXTEND(left, left[-1], 2 * size);
  248. cand_up_left = 1;
  249. cand_left = 1;
  250. } else if (cand_up_right) {
  251. EXTEND(top, top[size], size);
  252. left[-1] = top[size];
  253. EXTEND(left, left[-1], 2 * size);
  254. cand_up = 1;
  255. cand_up_left = 1;
  256. cand_left = 1;
  257. } else { // No samples available
  258. left[-1] = (1 << (BIT_DEPTH - 1));
  259. EXTEND(top, left[-1], 2 * size);
  260. EXTEND(left, left[-1], 2 * size);
  261. }
  262. }
  263. if (!cand_left)
  264. EXTEND(left, left[size], size);
  265. if (!cand_up_left) {
  266. left[-1] = left[0];
  267. }
  268. if (!cand_up)
  269. EXTEND(top, left[-1], size);
  270. if (!cand_up_right)
  271. EXTEND(top + size, top[size - 1], size);
  272. top[-1] = left[-1];
  273. // Filtering process
  274. if (!sps->intra_smoothing_disabled && (c_idx == 0 || sps->chroma_format_idc == 3)) {
  275. if (mode != INTRA_DC && size != 4){
  276. int intra_hor_ver_dist_thresh[] = { 7, 1, 0 };
  277. int min_dist_vert_hor = FFMIN(FFABS((int)(mode - 26U)),
  278. FFABS((int)(mode - 10U)));
  279. if (min_dist_vert_hor > intra_hor_ver_dist_thresh[log2_size - 3]) {
  280. int threshold = 1 << (BIT_DEPTH - 5);
  281. if (sps->strong_intra_smoothing_enabled && c_idx == 0 &&
  282. log2_size == 5 &&
  283. FFABS(top[-1] + top[63] - 2 * top[31]) < threshold &&
  284. FFABS(left[-1] + left[63] - 2 * left[31]) < threshold) {
  285. // We can't just overwrite values in top because it could be
  286. // a pointer into src
  287. filtered_top[-1] = top[-1];
  288. filtered_top[63] = top[63];
  289. for (i = 0; i < 63; i++)
  290. filtered_top[i] = ((64 - (i + 1)) * top[-1] +
  291. (i + 1) * top[63] + 32) >> 6;
  292. for (i = 0; i < 63; i++)
  293. left[i] = ((64 - (i + 1)) * left[-1] +
  294. (i + 1) * left[63] + 32) >> 6;
  295. top = filtered_top;
  296. } else {
  297. filtered_left[2 * size - 1] = left[2 * size - 1];
  298. filtered_top[2 * size - 1] = top[2 * size - 1];
  299. for (i = 2 * size - 2; i >= 0; i--)
  300. filtered_left[i] = (left[i + 1] + 2 * left[i] +
  301. left[i - 1] + 2) >> 2;
  302. filtered_top[-1] =
  303. filtered_left[-1] = (left[0] + 2 * left[-1] + top[0] + 2) >> 2;
  304. for (i = 2 * size - 2; i >= 0; i--)
  305. filtered_top[i] = (top[i + 1] + 2 * top[i] +
  306. top[i - 1] + 2) >> 2;
  307. left = filtered_left;
  308. top = filtered_top;
  309. }
  310. }
  311. }
  312. }
  313. switch (mode) {
  314. case INTRA_PLANAR:
  315. s->hpc.pred_planar[log2_size - 2]((uint8_t *)src, (uint8_t *)top,
  316. (uint8_t *)left, stride);
  317. break;
  318. case INTRA_DC:
  319. s->hpc.pred_dc((uint8_t *)src, (uint8_t *)top,
  320. (uint8_t *)left, stride, log2_size, c_idx);
  321. break;
  322. default:
  323. s->hpc.pred_angular[log2_size - 2]((uint8_t *)src, (uint8_t *)top,
  324. (uint8_t *)left, stride, c_idx,
  325. mode);
  326. break;
  327. }
  328. }
  329. #define INTRA_PRED(size) \
  330. static void FUNC(intra_pred_ ## size)(HEVCLocalContext *lc, const HEVCPPS *pps, \
  331. int x0, int y0, int c_idx) \
  332. { \
  333. FUNC(intra_pred)(lc, pps, x0, y0, size, c_idx); \
  334. }
  335. INTRA_PRED(2)
  336. INTRA_PRED(3)
  337. INTRA_PRED(4)
  338. INTRA_PRED(5)
  339. #undef INTRA_PRED
  340. static av_always_inline void FUNC(pred_planar)(uint8_t *_src, const uint8_t *_top,
  341. const uint8_t *_left, ptrdiff_t stride,
  342. int trafo_size)
  343. {
  344. int x, y;
  345. pixel *src = (pixel *)_src;
  346. const pixel *top = (const pixel *)_top;
  347. const pixel *left = (const pixel *)_left;
  348. int size = 1 << trafo_size;
  349. for (y = 0; y < size; y++)
  350. for (x = 0; x < size; x++)
  351. POS(x, y) = ((size - 1 - x) * left[y] + (x + 1) * top[size] +
  352. (size - 1 - y) * top[x] + (y + 1) * left[size] + size) >> (trafo_size + 1);
  353. }
  354. #define PRED_PLANAR(size)\
  355. static void FUNC(pred_planar_ ## size)(uint8_t *src, const uint8_t *top, \
  356. const uint8_t *left, ptrdiff_t stride) \
  357. { \
  358. FUNC(pred_planar)(src, top, left, stride, size + 2); \
  359. }
  360. PRED_PLANAR(0)
  361. PRED_PLANAR(1)
  362. PRED_PLANAR(2)
  363. PRED_PLANAR(3)
  364. #undef PRED_PLANAR
  365. static void FUNC(pred_dc)(uint8_t *_src, const uint8_t *_top,
  366. const uint8_t *_left,
  367. ptrdiff_t stride, int log2_size, int c_idx)
  368. {
  369. int i, j, x, y;
  370. int size = (1 << log2_size);
  371. pixel *src = (pixel *)_src;
  372. const pixel *top = (const pixel *)_top;
  373. const pixel *left = (const pixel *)_left;
  374. int dc = size;
  375. pixel4 a;
  376. for (i = 0; i < size; i++)
  377. dc += left[i] + top[i];
  378. dc >>= log2_size + 1;
  379. a = PIXEL_SPLAT_X4(dc);
  380. for (i = 0; i < size; i++)
  381. for (j = 0; j < size; j+=4)
  382. AV_WN4P(&POS(j, i), a);
  383. if (c_idx == 0 && size < 32) {
  384. POS(0, 0) = (left[0] + 2 * dc + top[0] + 2) >> 2;
  385. for (x = 1; x < size; x++)
  386. POS(x, 0) = (top[x] + 3 * dc + 2) >> 2;
  387. for (y = 1; y < size; y++)
  388. POS(0, y) = (left[y] + 3 * dc + 2) >> 2;
  389. }
  390. }
  391. static av_always_inline void FUNC(pred_angular)(uint8_t *_src,
  392. const uint8_t *_top,
  393. const uint8_t *_left,
  394. ptrdiff_t stride, int c_idx,
  395. int mode, int size)
  396. {
  397. int x, y;
  398. pixel *src = (pixel *)_src;
  399. const pixel *top = (const pixel *)_top;
  400. const pixel *left = (const pixel *)_left;
  401. static const int intra_pred_angle[] = {
  402. 32, 26, 21, 17, 13, 9, 5, 2, 0, -2, -5, -9, -13, -17, -21, -26, -32,
  403. -26, -21, -17, -13, -9, -5, -2, 0, 2, 5, 9, 13, 17, 21, 26, 32
  404. };
  405. static const int inv_angle[] = {
  406. -4096, -1638, -910, -630, -482, -390, -315, -256, -315, -390, -482,
  407. -630, -910, -1638, -4096
  408. };
  409. int angle = intra_pred_angle[mode - 2];
  410. pixel ref_array[3 * MAX_TB_SIZE + 4];
  411. pixel *ref_tmp = ref_array + size;
  412. const pixel *ref;
  413. int last = (size * angle) >> 5;
  414. if (mode >= 18) {
  415. ref = top - 1;
  416. if (angle < 0 && last < -1) {
  417. for (x = 0; x <= size; x += 4)
  418. AV_WN4P(&ref_tmp[x], AV_RN4P(&top[x - 1]));
  419. for (x = last; x <= -1; x++)
  420. ref_tmp[x] = left[-1 + ((x * inv_angle[mode - 11] + 128) >> 8)];
  421. ref = ref_tmp;
  422. }
  423. for (y = 0; y < size; y++) {
  424. int idx = ((y + 1) * angle) >> 5;
  425. int fact = ((y + 1) * angle) & 31;
  426. if (fact) {
  427. for (x = 0; x < size; x += 4) {
  428. POS(x , y) = ((32 - fact) * ref[x + idx + 1] +
  429. fact * ref[x + idx + 2] + 16) >> 5;
  430. POS(x + 1, y) = ((32 - fact) * ref[x + 1 + idx + 1] +
  431. fact * ref[x + 1 + idx + 2] + 16) >> 5;
  432. POS(x + 2, y) = ((32 - fact) * ref[x + 2 + idx + 1] +
  433. fact * ref[x + 2 + idx + 2] + 16) >> 5;
  434. POS(x + 3, y) = ((32 - fact) * ref[x + 3 + idx + 1] +
  435. fact * ref[x + 3 + idx + 2] + 16) >> 5;
  436. }
  437. } else {
  438. for (x = 0; x < size; x += 4)
  439. AV_WN4P(&POS(x, y), AV_RN4P(&ref[x + idx + 1]));
  440. }
  441. }
  442. if (mode == 26 && c_idx == 0 && size < 32) {
  443. for (y = 0; y < size; y++)
  444. POS(0, y) = av_clip_pixel(top[0] + ((left[y] - left[-1]) >> 1));
  445. }
  446. } else {
  447. ref = left - 1;
  448. if (angle < 0 && last < -1) {
  449. for (x = 0; x <= size; x += 4)
  450. AV_WN4P(&ref_tmp[x], AV_RN4P(&left[x - 1]));
  451. for (x = last; x <= -1; x++)
  452. ref_tmp[x] = top[-1 + ((x * inv_angle[mode - 11] + 128) >> 8)];
  453. ref = ref_tmp;
  454. }
  455. for (x = 0; x < size; x++) {
  456. int idx = ((x + 1) * angle) >> 5;
  457. int fact = ((x + 1) * angle) & 31;
  458. if (fact) {
  459. for (y = 0; y < size; y++) {
  460. POS(x, y) = ((32 - fact) * ref[y + idx + 1] +
  461. fact * ref[y + idx + 2] + 16) >> 5;
  462. }
  463. } else {
  464. for (y = 0; y < size; y++)
  465. POS(x, y) = ref[y + idx + 1];
  466. }
  467. }
  468. if (mode == 10 && c_idx == 0 && size < 32) {
  469. for (x = 0; x < size; x += 4) {
  470. POS(x, 0) = av_clip_pixel(left[0] + ((top[x ] - top[-1]) >> 1));
  471. POS(x + 1, 0) = av_clip_pixel(left[0] + ((top[x + 1] - top[-1]) >> 1));
  472. POS(x + 2, 0) = av_clip_pixel(left[0] + ((top[x + 2] - top[-1]) >> 1));
  473. POS(x + 3, 0) = av_clip_pixel(left[0] + ((top[x + 3] - top[-1]) >> 1));
  474. }
  475. }
  476. }
  477. }
  478. static void FUNC(pred_angular_0)(uint8_t *src, const uint8_t *top,
  479. const uint8_t *left,
  480. ptrdiff_t stride, int c_idx, int mode)
  481. {
  482. FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 2);
  483. }
  484. static void FUNC(pred_angular_1)(uint8_t *src, const uint8_t *top,
  485. const uint8_t *left,
  486. ptrdiff_t stride, int c_idx, int mode)
  487. {
  488. FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 3);
  489. }
  490. static void FUNC(pred_angular_2)(uint8_t *src, const uint8_t *top,
  491. const uint8_t *left,
  492. ptrdiff_t stride, int c_idx, int mode)
  493. {
  494. FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 4);
  495. }
  496. static void FUNC(pred_angular_3)(uint8_t *src, const uint8_t *top,
  497. const uint8_t *left,
  498. ptrdiff_t stride, int c_idx, int mode)
  499. {
  500. FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 5);
  501. }
  502. #undef EXTEND_LEFT_CIP
  503. #undef EXTEND_RIGHT_CIP
  504. #undef EXTEND_UP_CIP
  505. #undef EXTEND_DOWN_CIP
  506. #undef IS_INTRA
  507. #undef MVF_PU
  508. #undef MVF
  509. #undef PU
  510. #undef EXTEND
  511. #undef MIN_TB_ADDR_ZS
  512. #undef POS