FFmpeg
hevcpred_template.c
Go to the documentation of this file.
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 
23 #include "libavutil/pixdesc.h"
24 
25 #include "bit_depth_template.c"
26 #include "hevcpred.h"
27 
28 #define POS(x, y) src[(x) + stride * (y)]
29 
30 static av_always_inline void FUNC(intra_pred)(HEVCLocalContext *lc, int x0, int y0,
31  int log2_size, int c_idx)
32 {
33 #define PU(x) \
34  ((x) >> s->ps.sps->log2_min_pu_size)
35 #define MVF(x, y) \
36  (s->ref->tab_mvf[(x) + (y) * min_pu_width])
37 #define MVF_PU(x, y) \
38  MVF(PU(x0 + ((x) * (1 << hshift))), PU(y0 + ((y) * (1 << vshift))))
39 #define IS_INTRA(x, y) \
40  (MVF_PU(x, y).pred_flag == PF_INTRA)
41 #define MIN_TB_ADDR_ZS(x, y) \
42  s->ps.pps->min_tb_addr_zs[(y) * (s->ps.sps->tb_mask+2) + (x)]
43 #define EXTEND(ptr, val, len) \
44 do { \
45  pixel4 pix = PIXEL_SPLAT_X4(val); \
46  for (i = 0; i < (len); i += 4) \
47  AV_WN4P(ptr + i, pix); \
48 } while (0)
49 
50 #define EXTEND_RIGHT_CIP(ptr, start, length) \
51  for (i = start; i < (start) + (length); i += 4) \
52  if (!IS_INTRA(i, -1)) \
53  AV_WN4P(&ptr[i], a); \
54  else \
55  a = PIXEL_SPLAT_X4(ptr[i+3])
56 #define EXTEND_LEFT_CIP(ptr, start, length) \
57  for (i = start; i > (start) - (length); i--) \
58  if (!IS_INTRA(i - 1, -1)) \
59  ptr[i - 1] = ptr[i]
60 #define EXTEND_UP_CIP(ptr, start, length) \
61  for (i = (start); i > (start) - (length); i -= 4) \
62  if (!IS_INTRA(-1, i - 3)) \
63  AV_WN4P(&ptr[i - 3], a); \
64  else \
65  a = PIXEL_SPLAT_X4(ptr[i - 3])
66 #define EXTEND_DOWN_CIP(ptr, start, length) \
67  for (i = start; i < (start) + (length); i += 4) \
68  if (!IS_INTRA(-1, i)) \
69  AV_WN4P(&ptr[i], a); \
70  else \
71  a = PIXEL_SPLAT_X4(ptr[i + 3])
72 
73  const HEVCContext *const s = lc->parent;
74  int i;
75  int hshift = s->ps.sps->hshift[c_idx];
76  int vshift = s->ps.sps->vshift[c_idx];
77  int size = (1 << log2_size);
78  int size_in_luma_h = size << hshift;
79  int size_in_tbs_h = size_in_luma_h >> s->ps.sps->log2_min_tb_size;
80  int size_in_luma_v = size << vshift;
81  int size_in_tbs_v = size_in_luma_v >> s->ps.sps->log2_min_tb_size;
82  int x = x0 >> hshift;
83  int y = y0 >> vshift;
84  int x_tb = (x0 >> s->ps.sps->log2_min_tb_size) & s->ps.sps->tb_mask;
85  int y_tb = (y0 >> s->ps.sps->log2_min_tb_size) & s->ps.sps->tb_mask;
86  int spin = c_idx && !size_in_tbs_v && ((2 * y0) & (1 << s->ps.sps->log2_min_tb_size));
87 
88  int cur_tb_addr = MIN_TB_ADDR_ZS(x_tb, y_tb);
89 
90  ptrdiff_t stride = s->frame->linesize[c_idx] / sizeof(pixel);
91  pixel *src = (pixel*)s->frame->data[c_idx] + x + y * stride;
92 
93  int min_pu_width = s->ps.sps->min_pu_width;
94 
95  enum IntraPredMode mode = c_idx ? lc->tu.intra_pred_mode_c :
96  lc->tu.intra_pred_mode;
97  pixel4 a;
98  pixel left_array[2 * MAX_TB_SIZE + 1];
99  pixel filtered_left_array[2 * MAX_TB_SIZE + 1];
100  pixel top_array[2 * MAX_TB_SIZE + 1];
101  pixel filtered_top_array[2 * MAX_TB_SIZE + 1];
102 
103  pixel *left = left_array + 1;
104  pixel *top = top_array + 1;
105  pixel *filtered_left = filtered_left_array + 1;
106  pixel *filtered_top = filtered_top_array + 1;
107  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) & s->ps.sps->tb_mask);
108  int cand_left = lc->na.cand_left;
109  int cand_up_left = lc->na.cand_up_left;
110  int cand_up = lc->na.cand_up;
111  int cand_up_right = lc->na.cand_up_right && !spin && cur_tb_addr > MIN_TB_ADDR_ZS((x_tb + size_in_tbs_h) & s->ps.sps->tb_mask, y_tb - 1);
112 
113  int bottom_left_size = (FFMIN(y0 + 2 * size_in_luma_v, s->ps.sps->height) -
114  (y0 + size_in_luma_v)) >> vshift;
115  int top_right_size = (FFMIN(x0 + 2 * size_in_luma_h, s->ps.sps->width) -
116  (x0 + size_in_luma_h)) >> hshift;
117 
118  if (s->ps.pps->constrained_intra_pred_flag == 1) {
119  int size_in_luma_pu_v = PU(size_in_luma_v);
120  int size_in_luma_pu_h = PU(size_in_luma_h);
121  int on_pu_edge_x = !av_mod_uintp2(x0, s->ps.sps->log2_min_pu_size);
122  int on_pu_edge_y = !av_mod_uintp2(y0, s->ps.sps->log2_min_pu_size);
123  if (!size_in_luma_pu_h)
124  size_in_luma_pu_h++;
125  if (cand_bottom_left == 1 && on_pu_edge_x) {
126  int x_left_pu = PU(x0 - 1);
127  int y_bottom_pu = PU(y0 + size_in_luma_v);
128  int max = FFMIN(size_in_luma_pu_v, s->ps.sps->min_pu_height - y_bottom_pu);
129  cand_bottom_left = 0;
130  for (i = 0; i < max; i += 2)
131  cand_bottom_left |= (MVF(x_left_pu, y_bottom_pu + i).pred_flag == PF_INTRA);
132  }
133  if (cand_left == 1 && on_pu_edge_x) {
134  int x_left_pu = PU(x0 - 1);
135  int y_left_pu = PU(y0);
136  int max = FFMIN(size_in_luma_pu_v, s->ps.sps->min_pu_height - y_left_pu);
137  cand_left = 0;
138  for (i = 0; i < max; i += 2)
139  cand_left |= (MVF(x_left_pu, y_left_pu + i).pred_flag == PF_INTRA);
140  }
141  if (cand_up_left == 1) {
142  int x_left_pu = PU(x0 - 1);
143  int y_top_pu = PU(y0 - 1);
144  cand_up_left = MVF(x_left_pu, y_top_pu).pred_flag == PF_INTRA;
145  }
146  if (cand_up == 1 && on_pu_edge_y) {
147  int x_top_pu = PU(x0);
148  int y_top_pu = PU(y0 - 1);
149  int max = FFMIN(size_in_luma_pu_h, s->ps.sps->min_pu_width - x_top_pu);
150  cand_up = 0;
151  for (i = 0; i < max; i += 2)
152  cand_up |= (MVF(x_top_pu + i, y_top_pu).pred_flag == PF_INTRA);
153  }
154  if (cand_up_right == 1 && on_pu_edge_y) {
155  int y_top_pu = PU(y0 - 1);
156  int x_right_pu = PU(x0 + size_in_luma_h);
157  int max = FFMIN(size_in_luma_pu_h, s->ps.sps->min_pu_width - x_right_pu);
158  cand_up_right = 0;
159  for (i = 0; i < max; i += 2)
160  cand_up_right |= (MVF(x_right_pu + i, y_top_pu).pred_flag == PF_INTRA);
161  }
162  memset(left, 128, 2 * MAX_TB_SIZE*sizeof(pixel));
163  memset(top , 128, 2 * MAX_TB_SIZE*sizeof(pixel));
164  top[-1] = 128;
165  }
166  if (cand_up_left) {
167  left[-1] = POS(-1, -1);
168  top[-1] = left[-1];
169  }
170  if (cand_up)
171  memcpy(top, src - stride, size * sizeof(pixel));
172  if (cand_up_right) {
173  memcpy(top + size, src - stride + size, size * sizeof(pixel));
174  EXTEND(top + size + top_right_size, POS(size + top_right_size - 1, -1),
175  size - top_right_size);
176  }
177  if (cand_left)
178  for (i = 0; i < size; i++)
179  left[i] = POS(-1, i);
180  if (cand_bottom_left) {
181  for (i = size; i < size + bottom_left_size; i++)
182  left[i] = POS(-1, i);
183  EXTEND(left + size + bottom_left_size, POS(-1, size + bottom_left_size - 1),
184  size - bottom_left_size);
185  }
186 
187  if (s->ps.pps->constrained_intra_pred_flag == 1) {
188  if (cand_bottom_left || cand_left || cand_up_left || cand_up || cand_up_right) {
189  int size_max_x = x0 + ((2 * size) << hshift) < s->ps.sps->width ?
190  2 * size : (s->ps.sps->width - x0) >> hshift;
191  int size_max_y = y0 + ((2 * size) << vshift) < s->ps.sps->height ?
192  2 * size : (s->ps.sps->height - y0) >> vshift;
193  int j = size + (cand_bottom_left? bottom_left_size: 0) -1;
194  if (!cand_up_right) {
195  size_max_x = x0 + ((size) << hshift) < s->ps.sps->width ?
196  size : (s->ps.sps->width - x0) >> hshift;
197  }
198  if (!cand_bottom_left) {
199  size_max_y = y0 + (( size) << vshift) < s->ps.sps->height ?
200  size : (s->ps.sps->height - y0) >> vshift;
201  }
202  if (cand_bottom_left || cand_left || cand_up_left) {
203  while (j > -1 && !IS_INTRA(-1, j))
204  j--;
205  if (!IS_INTRA(-1, j)) {
206  j = 0;
207  while (j < size_max_x && !IS_INTRA(j, -1))
208  j++;
209  EXTEND_LEFT_CIP(top, j, j + 1);
210  left[-1] = top[-1];
211  }
212  } else {
213  j = 0;
214  while (j < size_max_x && !IS_INTRA(j, -1))
215  j++;
216  if (j > 0) {
217  EXTEND_LEFT_CIP(top, j, j);
218  top[-1] = top[0];
219  }
220  left[-1] = top[-1];
221  }
222  left[-1] = top[-1];
223  if (cand_bottom_left || cand_left) {
224  a = PIXEL_SPLAT_X4(left[-1]);
225  EXTEND_DOWN_CIP(left, 0, size_max_y);
226  }
227  if (!cand_left)
228  EXTEND(left, left[-1], size);
229  if (!cand_bottom_left)
230  EXTEND(left + size, left[size - 1], size);
231  if (x0 != 0 && y0 != 0) {
232  a = PIXEL_SPLAT_X4(left[size_max_y - 1]);
233  EXTEND_UP_CIP(left, size_max_y - 1, size_max_y);
234  if (!IS_INTRA(-1, - 1))
235  left[-1] = left[0];
236  } else if (x0 == 0) {
237  EXTEND(left, 0, size_max_y);
238  } else {
239  a = PIXEL_SPLAT_X4(left[size_max_y - 1]);
240  EXTEND_UP_CIP(left, size_max_y - 1, size_max_y);
241  }
242  top[-1] = left[-1];
243  if (y0 != 0) {
244  a = PIXEL_SPLAT_X4(left[-1]);
245  EXTEND_RIGHT_CIP(top, 0, size_max_x);
246  }
247  }
248  }
249  // Infer the unavailable samples
250  if (!cand_bottom_left) {
251  if (cand_left) {
252  EXTEND(left + size, left[size - 1], size);
253  } else if (cand_up_left) {
254  EXTEND(left, left[-1], 2 * size);
255  cand_left = 1;
256  } else if (cand_up) {
257  left[-1] = top[0];
258  EXTEND(left, left[-1], 2 * size);
259  cand_up_left = 1;
260  cand_left = 1;
261  } else if (cand_up_right) {
262  EXTEND(top, top[size], size);
263  left[-1] = top[size];
264  EXTEND(left, left[-1], 2 * size);
265  cand_up = 1;
266  cand_up_left = 1;
267  cand_left = 1;
268  } else { // No samples available
269  left[-1] = (1 << (BIT_DEPTH - 1));
270  EXTEND(top, left[-1], 2 * size);
271  EXTEND(left, left[-1], 2 * size);
272  }
273  }
274 
275  if (!cand_left)
276  EXTEND(left, left[size], size);
277  if (!cand_up_left) {
278  left[-1] = left[0];
279  }
280  if (!cand_up)
281  EXTEND(top, left[-1], size);
282  if (!cand_up_right)
283  EXTEND(top + size, top[size - 1], size);
284 
285  top[-1] = left[-1];
286 
287  // Filtering process
288  if (!s->ps.sps->intra_smoothing_disabled_flag && (c_idx == 0 || s->ps.sps->chroma_format_idc == 3)) {
289  if (mode != INTRA_DC && size != 4){
290  int intra_hor_ver_dist_thresh[] = { 7, 1, 0 };
291  int min_dist_vert_hor = FFMIN(FFABS((int)(mode - 26U)),
292  FFABS((int)(mode - 10U)));
293  if (min_dist_vert_hor > intra_hor_ver_dist_thresh[log2_size - 3]) {
294  int threshold = 1 << (BIT_DEPTH - 5);
295  if (s->ps.sps->sps_strong_intra_smoothing_enable_flag && c_idx == 0 &&
296  log2_size == 5 &&
297  FFABS(top[-1] + top[63] - 2 * top[31]) < threshold &&
298  FFABS(left[-1] + left[63] - 2 * left[31]) < threshold) {
299  // We can't just overwrite values in top because it could be
300  // a pointer into src
301  filtered_top[-1] = top[-1];
302  filtered_top[63] = top[63];
303  for (i = 0; i < 63; i++)
304  filtered_top[i] = ((64 - (i + 1)) * top[-1] +
305  (i + 1) * top[63] + 32) >> 6;
306  for (i = 0; i < 63; i++)
307  left[i] = ((64 - (i + 1)) * left[-1] +
308  (i + 1) * left[63] + 32) >> 6;
309  top = filtered_top;
310  } else {
311  filtered_left[2 * size - 1] = left[2 * size - 1];
312  filtered_top[2 * size - 1] = top[2 * size - 1];
313  for (i = 2 * size - 2; i >= 0; i--)
314  filtered_left[i] = (left[i + 1] + 2 * left[i] +
315  left[i - 1] + 2) >> 2;
316  filtered_top[-1] =
317  filtered_left[-1] = (left[0] + 2 * left[-1] + top[0] + 2) >> 2;
318  for (i = 2 * size - 2; i >= 0; i--)
319  filtered_top[i] = (top[i + 1] + 2 * top[i] +
320  top[i - 1] + 2) >> 2;
321  left = filtered_left;
322  top = filtered_top;
323  }
324  }
325  }
326  }
327 
328  switch (mode) {
329  case INTRA_PLANAR:
330  s->hpc.pred_planar[log2_size - 2]((uint8_t *)src, (uint8_t *)top,
331  (uint8_t *)left, stride);
332  break;
333  case INTRA_DC:
334  s->hpc.pred_dc((uint8_t *)src, (uint8_t *)top,
335  (uint8_t *)left, stride, log2_size, c_idx);
336  break;
337  default:
338  s->hpc.pred_angular[log2_size - 2]((uint8_t *)src, (uint8_t *)top,
339  (uint8_t *)left, stride, c_idx,
340  mode);
341  break;
342  }
343 }
344 
345 #define INTRA_PRED(size) \
346 static void FUNC(intra_pred_ ## size)(HEVCLocalContext *lc, int x0, int y0, int c_idx) \
347 { \
348  FUNC(intra_pred)(lc, x0, y0, size, c_idx); \
349 }
350 
351 INTRA_PRED(2)
352 INTRA_PRED(3)
353 INTRA_PRED(4)
354 INTRA_PRED(5)
355 
356 #undef INTRA_PRED
357 
358 static av_always_inline void FUNC(pred_planar)(uint8_t *_src, const uint8_t *_top,
359  const uint8_t *_left, ptrdiff_t stride,
360  int trafo_size)
361 {
362  int x, y;
363  pixel *src = (pixel *)_src;
364  const pixel *top = (const pixel *)_top;
365  const pixel *left = (const pixel *)_left;
366  int size = 1 << trafo_size;
367  for (y = 0; y < size; y++)
368  for (x = 0; x < size; x++)
369  POS(x, y) = ((size - 1 - x) * left[y] + (x + 1) * top[size] +
370  (size - 1 - y) * top[x] + (y + 1) * left[size] + size) >> (trafo_size + 1);
371 }
372 
373 #define PRED_PLANAR(size)\
374 static void FUNC(pred_planar_ ## size)(uint8_t *src, const uint8_t *top, \
375  const uint8_t *left, ptrdiff_t stride) \
376 { \
377  FUNC(pred_planar)(src, top, left, stride, size + 2); \
378 }
379 
380 PRED_PLANAR(0)
381 PRED_PLANAR(1)
382 PRED_PLANAR(2)
383 PRED_PLANAR(3)
384 
385 #undef PRED_PLANAR
386 
387 static void FUNC(pred_dc)(uint8_t *_src, const uint8_t *_top,
388  const uint8_t *_left,
389  ptrdiff_t stride, int log2_size, int c_idx)
390 {
391  int i, j, x, y;
392  int size = (1 << log2_size);
393  pixel *src = (pixel *)_src;
394  const pixel *top = (const pixel *)_top;
395  const pixel *left = (const pixel *)_left;
396  int dc = size;
397  pixel4 a;
398  for (i = 0; i < size; i++)
399  dc += left[i] + top[i];
400 
401  dc >>= log2_size + 1;
402 
403  a = PIXEL_SPLAT_X4(dc);
404 
405  for (i = 0; i < size; i++)
406  for (j = 0; j < size; j+=4)
407  AV_WN4P(&POS(j, i), a);
408 
409  if (c_idx == 0 && size < 32) {
410  POS(0, 0) = (left[0] + 2 * dc + top[0] + 2) >> 2;
411  for (x = 1; x < size; x++)
412  POS(x, 0) = (top[x] + 3 * dc + 2) >> 2;
413  for (y = 1; y < size; y++)
414  POS(0, y) = (left[y] + 3 * dc + 2) >> 2;
415  }
416 }
417 
418 static av_always_inline void FUNC(pred_angular)(uint8_t *_src,
419  const uint8_t *_top,
420  const uint8_t *_left,
421  ptrdiff_t stride, int c_idx,
422  int mode, int size)
423 {
424  int x, y;
425  pixel *src = (pixel *)_src;
426  const pixel *top = (const pixel *)_top;
427  const pixel *left = (const pixel *)_left;
428 
429  static const int intra_pred_angle[] = {
430  32, 26, 21, 17, 13, 9, 5, 2, 0, -2, -5, -9, -13, -17, -21, -26, -32,
431  -26, -21, -17, -13, -9, -5, -2, 0, 2, 5, 9, 13, 17, 21, 26, 32
432  };
433  static const int inv_angle[] = {
434  -4096, -1638, -910, -630, -482, -390, -315, -256, -315, -390, -482,
435  -630, -910, -1638, -4096
436  };
437 
438  int angle = intra_pred_angle[mode - 2];
439  pixel ref_array[3 * MAX_TB_SIZE + 4];
440  pixel *ref_tmp = ref_array + size;
441  const pixel *ref;
442  int last = (size * angle) >> 5;
443 
444  if (mode >= 18) {
445  ref = top - 1;
446  if (angle < 0 && last < -1) {
447  for (x = 0; x <= size; x += 4)
448  AV_WN4P(&ref_tmp[x], AV_RN4P(&top[x - 1]));
449  for (x = last; x <= -1; x++)
450  ref_tmp[x] = left[-1 + ((x * inv_angle[mode - 11] + 128) >> 8)];
451  ref = ref_tmp;
452  }
453 
454  for (y = 0; y < size; y++) {
455  int idx = ((y + 1) * angle) >> 5;
456  int fact = ((y + 1) * angle) & 31;
457  if (fact) {
458  for (x = 0; x < size; x += 4) {
459  POS(x , y) = ((32 - fact) * ref[x + idx + 1] +
460  fact * ref[x + idx + 2] + 16) >> 5;
461  POS(x + 1, y) = ((32 - fact) * ref[x + 1 + idx + 1] +
462  fact * ref[x + 1 + idx + 2] + 16) >> 5;
463  POS(x + 2, y) = ((32 - fact) * ref[x + 2 + idx + 1] +
464  fact * ref[x + 2 + idx + 2] + 16) >> 5;
465  POS(x + 3, y) = ((32 - fact) * ref[x + 3 + idx + 1] +
466  fact * ref[x + 3 + idx + 2] + 16) >> 5;
467  }
468  } else {
469  for (x = 0; x < size; x += 4)
470  AV_WN4P(&POS(x, y), AV_RN4P(&ref[x + idx + 1]));
471  }
472  }
473  if (mode == 26 && c_idx == 0 && size < 32) {
474  for (y = 0; y < size; y++)
475  POS(0, y) = av_clip_pixel(top[0] + ((left[y] - left[-1]) >> 1));
476  }
477  } else {
478  ref = left - 1;
479  if (angle < 0 && last < -1) {
480  for (x = 0; x <= size; x += 4)
481  AV_WN4P(&ref_tmp[x], AV_RN4P(&left[x - 1]));
482  for (x = last; x <= -1; x++)
483  ref_tmp[x] = top[-1 + ((x * inv_angle[mode - 11] + 128) >> 8)];
484  ref = ref_tmp;
485  }
486 
487  for (x = 0; x < size; x++) {
488  int idx = ((x + 1) * angle) >> 5;
489  int fact = ((x + 1) * angle) & 31;
490  if (fact) {
491  for (y = 0; y < size; y++) {
492  POS(x, y) = ((32 - fact) * ref[y + idx + 1] +
493  fact * ref[y + idx + 2] + 16) >> 5;
494  }
495  } else {
496  for (y = 0; y < size; y++)
497  POS(x, y) = ref[y + idx + 1];
498  }
499  }
500  if (mode == 10 && c_idx == 0 && size < 32) {
501  for (x = 0; x < size; x += 4) {
502  POS(x, 0) = av_clip_pixel(left[0] + ((top[x ] - top[-1]) >> 1));
503  POS(x + 1, 0) = av_clip_pixel(left[0] + ((top[x + 1] - top[-1]) >> 1));
504  POS(x + 2, 0) = av_clip_pixel(left[0] + ((top[x + 2] - top[-1]) >> 1));
505  POS(x + 3, 0) = av_clip_pixel(left[0] + ((top[x + 3] - top[-1]) >> 1));
506  }
507  }
508  }
509 }
510 
511 static void FUNC(pred_angular_0)(uint8_t *src, const uint8_t *top,
512  const uint8_t *left,
513  ptrdiff_t stride, int c_idx, int mode)
514 {
515  FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 2);
516 }
517 
518 static void FUNC(pred_angular_1)(uint8_t *src, const uint8_t *top,
519  const uint8_t *left,
520  ptrdiff_t stride, int c_idx, int mode)
521 {
522  FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 3);
523 }
524 
525 static void FUNC(pred_angular_2)(uint8_t *src, const uint8_t *top,
526  const uint8_t *left,
527  ptrdiff_t stride, int c_idx, int mode)
528 {
529  FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 4);
530 }
531 
532 static void FUNC(pred_angular_3)(uint8_t *src, const uint8_t *top,
533  const uint8_t *left,
534  ptrdiff_t stride, int c_idx, int mode)
535 {
536  FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 5);
537 }
538 
539 #undef EXTEND_LEFT_CIP
540 #undef EXTEND_RIGHT_CIP
541 #undef EXTEND_UP_CIP
542 #undef EXTEND_DOWN_CIP
543 #undef IS_INTRA
544 #undef MVF_PU
545 #undef MVF
546 #undef PU
547 #undef EXTEND
548 #undef MIN_TB_ADDR_ZS
549 #undef POS
HEVCLocalContext
Definition: hevcdec.h:434
BIT_DEPTH
#define BIT_DEPTH
Definition: bit_depth_template.c:24
POS
#define POS(x, y)
Definition: hevcpred_template.c:28
PU
#define PU(x)
AV_RN4P
#define AV_RN4P
Definition: bit_depth_template.c:91
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:125
pixdesc.h
INTRA_DC
@ INTRA_DC
Definition: hevcdec.h:173
max
#define max(a, b)
Definition: cuda_runtime.h:33
EXTEND_UP_CIP
#define EXTEND_UP_CIP(ptr, start, length)
PF_INTRA
@ PF_INTRA
Definition: hevcdec.h:165
pixel4
#define pixel4
Definition: bit_depth_template.c:83
pred_angular
static av_always_inline void FUNC() pred_angular(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int c_idx, int mode, int size)
Definition: hevcpred_template.c:418
hevcpred.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
EXTEND_LEFT_CIP
#define EXTEND_LEFT_CIP(ptr, start, length)
pred_planar
static av_always_inline void FUNC() pred_planar(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int trafo_size)
Definition: hevcpred_template.c:358
IS_INTRA
#define IS_INTRA(x, y)
PIXEL_SPLAT_X4
#define PIXEL_SPLAT_X4(x)
Definition: bit_depth_template.c:96
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
MVF
#define MVF(x, y)
pixel
uint8_t pixel
Definition: tiny_ssim.c:41
pred_angular_1
static void FUNC() pred_angular_1(uint8_t *src, const uint8_t *top, const uint8_t *left, ptrdiff_t stride, int c_idx, int mode)
Definition: hevcpred_template.c:518
bit_depth_template.c
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
INTRA_PLANAR
@ INTRA_PLANAR
Definition: hevcdec.h:172
size
int size
Definition: twinvq_data.h:10344
pred_angular_0
static void FUNC() pred_angular_0(uint8_t *src, const uint8_t *top, const uint8_t *left, ptrdiff_t stride, int c_idx, int mode)
Definition: hevcpred_template.c:511
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
fact
static double fact(double i)
Definition: af_aiir.c:943
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
MIN_TB_ADDR_ZS
#define MIN_TB_ADDR_ZS(x, y)
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
stride
#define stride
Definition: h264pred_template.c:537
IntraPredMode
IntraPredMode
Definition: hevcdec.h:171
av_clip_pixel
#define av_clip_pixel(a)
Definition: bit_depth_template.c:98
EXTEND_RIGHT_CIP
#define EXTEND_RIGHT_CIP(ptr, start, length)
INTRA_PRED
#define INTRA_PRED(size)
Definition: hevcpred_template.c:345
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
U
#define U(x)
Definition: vpx_arith.h:37
intra_pred
static av_always_inline void FUNC() intra_pred(HEVCLocalContext *lc, int x0, int y0, int log2_size, int c_idx)
Definition: hevcpred_template.c:30
pred_angular_3
static void FUNC() pred_angular_3(uint8_t *src, const uint8_t *top, const uint8_t *left, ptrdiff_t stride, int c_idx, int mode)
Definition: hevcpred_template.c:532
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
mode
mode
Definition: ebur128.h:83
HEVCContext
Definition: hevcdec.h:492
AV_WN4P
#define AV_WN4P
Definition: bit_depth_template.c:94
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
PRED_PLANAR
#define PRED_PLANAR(size)
Definition: hevcpred_template.c:373
EXTEND
#define EXTEND(ptr, val, len)
pred_angular_2
static void FUNC() pred_angular_2(uint8_t *src, const uint8_t *top, const uint8_t *left, ptrdiff_t stride, int c_idx, int mode)
Definition: hevcpred_template.c:525
pred_dc
static void FUNC() pred_dc(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int log2_size, int c_idx)
Definition: hevcpred_template.c:387
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
MAX_TB_SIZE
#define MAX_TB_SIZE
Definition: hevcdec.h:48
EXTEND_DOWN_CIP
#define EXTEND_DOWN_CIP(ptr, start, length)