hevcpred_template.c 22.1 KB
Newer Older
1
/*
2
 * HEVC video decoder
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *
 * Copyright (C) 2012 - 2013 Guillaume Martres
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/pixdesc.h"
24

25 26 27 28 29
#include "bit_depth_template.c"
#include "hevcpred.h"

#define POS(x, y) src[(x) + stride * (y)]

30 31
static av_always_inline void FUNC(intra_pred)(HEVCContext *s, int x0, int y0,
                                              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 44 45 46 47 48 49
#define EXTEND(ptr, val, len)         \
do {                                  \
    pixel4 pix = PIXEL_SPLAT_X4(val); \
    for (i = 0; i < (len); i += 4)    \
        AV_WN4P(ptr + i, pix);        \
} while (0)

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 55
            else                                                               \
                a = PIXEL_SPLAT_X4(ptr[i+3])
56
#define EXTEND_LEFT_CIP(ptr, start, length) \
57
        for (i = start; i > (start) - (length); i--) \
58 59
            if (!IS_INTRA(i - 1, -1)) \
                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 65
            else                                                               \
                a = PIXEL_SPLAT_X4(ptr[i - 3])
66 67
#define EXTEND_DOWN_CIP(ptr, start, length)                                    \
        for (i = start; i < (start) + (length); i += 4)                        \
68
            if (!IS_INTRA(-1, i))                                              \
69
                AV_WN4P(&ptr[i], a);                                           \
70 71 72
            else                                                               \
                a = PIXEL_SPLAT_X4(ptr[i + 3])

73
    HEVCLocalContext *lc = s->HEVClc;
74
    int i;
75 76
    int hshift = s->ps.sps->hshift[c_idx];
    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 83
    int x = x0 >> hshift;
    int y = y0 >> vshift;
84 85
    int x_tb = (x0 >> s->ps.sps->log2_min_tb_size) & s->ps.sps->tb_mask;
    int y_tb = (y0 >> s->ps.sps->log2_min_tb_size) & s->ps.sps->tb_mask;
86

87 88 89 90 91
    int cur_tb_addr = MIN_TB_ADDR_ZS(x_tb, y_tb);

    ptrdiff_t stride = s->frame->linesize[c_idx] / sizeof(pixel);
    pixel *src = (pixel*)s->frame->data[c_idx] + x + y * stride;

92
    int min_pu_width = s->ps.sps->min_pu_width;
93

94 95
    enum IntraPredMode mode = c_idx ? lc->tu.intra_pred_mode_c :
                              lc->tu.intra_pred_mode;
96
    pixel4 a;
97 98 99 100
    pixel  left_array[2 * MAX_TB_SIZE + 1];
    pixel  filtered_left_array[2 * MAX_TB_SIZE + 1];
    pixel  top_array[2 * MAX_TB_SIZE + 1];
    pixel  filtered_top_array[2 * MAX_TB_SIZE + 1];
101

102 103 104 105
    pixel  *left          = left_array + 1;
    pixel  *top           = top_array  + 1;
    pixel  *filtered_left = filtered_left_array + 1;
    pixel  *filtered_top  = filtered_top_array  + 1;
106
    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) & s->ps.sps->tb_mask);
107 108 109
    int cand_left        = lc->na.cand_left;
    int cand_up_left     = lc->na.cand_up_left;
    int cand_up          = lc->na.cand_up;
110
    int cand_up_right    = lc->na.cand_up_right    && cur_tb_addr > MIN_TB_ADDR_ZS((x_tb + size_in_tbs_h) & s->ps.sps->tb_mask, y_tb - 1);
111

112
    int bottom_left_size = (FFMIN(y0 + 2 * size_in_luma_v, s->ps.sps->height) -
113
                           (y0 + size_in_luma_v)) >> vshift;
114
    int top_right_size   = (FFMIN(x0 + 2 * size_in_luma_h, s->ps.sps->width) -
115
                           (x0 + size_in_luma_h)) >> hshift;
116

117
    if (s->ps.pps->constrained_intra_pred_flag == 1) {
118 119
        int size_in_luma_pu_v = PU(size_in_luma_v);
        int size_in_luma_pu_h = PU(size_in_luma_h);
120 121
        int on_pu_edge_x    = !av_mod_uintp2(x0, s->ps.sps->log2_min_pu_size);
        int on_pu_edge_y    = !av_mod_uintp2(y0, s->ps.sps->log2_min_pu_size);
122 123
        if (!size_in_luma_pu_h)
            size_in_luma_pu_h++;
124 125
        if (cand_bottom_left == 1 && on_pu_edge_x) {
            int x_left_pu   = PU(x0 - 1);
126
            int y_bottom_pu = PU(y0 + size_in_luma_v);
127
            int max = FFMIN(size_in_luma_pu_v, s->ps.sps->min_pu_height - y_bottom_pu);
128
            cand_bottom_left = 0;
129
            for (i = 0; i < max; i += 2)
130
                cand_bottom_left |= (MVF(x_left_pu, y_bottom_pu + i).pred_flag == PF_INTRA);
131 132 133 134
        }
        if (cand_left == 1 && on_pu_edge_x) {
            int x_left_pu   = PU(x0 - 1);
            int y_left_pu   = PU(y0);
135
            int max = FFMIN(size_in_luma_pu_v, s->ps.sps->min_pu_height - y_left_pu);
136
            cand_left = 0;
137
            for (i = 0; i < max; i += 2)
138
                cand_left |= (MVF(x_left_pu, y_left_pu + i).pred_flag == PF_INTRA);
139 140 141 142
        }
        if (cand_up_left == 1) {
            int x_left_pu   = PU(x0 - 1);
            int y_top_pu    = PU(y0 - 1);
143
            cand_up_left = MVF(x_left_pu, y_top_pu).pred_flag == PF_INTRA;
144 145 146 147
        }
        if (cand_up == 1 && on_pu_edge_y) {
            int x_top_pu    = PU(x0);
            int y_top_pu    = PU(y0 - 1);
148
            int max = FFMIN(size_in_luma_pu_h, s->ps.sps->min_pu_width - x_top_pu);
149
            cand_up = 0;
150
            for (i = 0; i < max; i += 2)
151
                cand_up |= (MVF(x_top_pu + i, y_top_pu).pred_flag == PF_INTRA);
152 153 154
        }
        if (cand_up_right == 1 && on_pu_edge_y) {
            int y_top_pu    = PU(y0 - 1);
155
            int x_right_pu  = PU(x0 + size_in_luma_h);
156
            int max = FFMIN(size_in_luma_pu_h, s->ps.sps->min_pu_width - x_right_pu);
157
            cand_up_right = 0;
158
            for (i = 0; i < max; i += 2)
159
                cand_up_right |= (MVF(x_right_pu + i, y_top_pu).pred_flag == PF_INTRA);
160
        }
161 162
        memset(left, 128, 2 * MAX_TB_SIZE*sizeof(pixel));
        memset(top , 128, 2 * MAX_TB_SIZE*sizeof(pixel));
163
        top[-1] = 128;
164
    }
165 166 167
    if (cand_up_left) {
        left[-1] = POS(-1, -1);
        top[-1]  = left[-1];
168 169
    }
    if (cand_up)
170
        memcpy(top, src - stride, size * sizeof(pixel));
171
    if (cand_up_right) {
172 173 174
        memcpy(top + size, src - stride + size, size * sizeof(pixel));
        EXTEND(top + size + top_right_size, POS(size + top_right_size - 1, -1),
               size - top_right_size);
175 176 177 178 179
    }
    if (cand_left)
        for (i = 0; i < size; i++)
            left[i] = POS(-1, i);
    if (cand_bottom_left) {
180
        for (i = size; i < size + bottom_left_size; i++)
181
            left[i] = POS(-1, i);
182 183
        EXTEND(left + size + bottom_left_size, POS(-1, size + bottom_left_size - 1),
               size - bottom_left_size);
184 185
    }

186
    if (s->ps.pps->constrained_intra_pred_flag == 1) {
187
        if (cand_bottom_left || cand_left || cand_up_left || cand_up || cand_up_right) {
188 189 190 191
            int size_max_x = x0 + ((2 * size) << hshift) < s->ps.sps->width ?
                                    2 * size : (s->ps.sps->width - x0) >> hshift;
            int size_max_y = y0 + ((2 * size) << vshift) < s->ps.sps->height ?
                                    2 * size : (s->ps.sps->height - y0) >> vshift;
192
            int j = size + (cand_bottom_left? bottom_left_size: 0) -1;
193
            if (!cand_up_right) {
194 195
                size_max_x = x0 + ((size) << hshift) < s->ps.sps->width ?
                                                    size : (s->ps.sps->width - x0) >> hshift;
196 197
            }
            if (!cand_bottom_left) {
198 199
                size_max_y = y0 + (( size) << vshift) < s->ps.sps->height ?
                                                     size : (s->ps.sps->height - y0) >> vshift;
200
            }
201
            if (cand_bottom_left || cand_left || cand_up_left) {
202 203
                while (j > -1 && !IS_INTRA(-1, j))
                    j--;
204 205
                if (!IS_INTRA(-1, j)) {
                    j = 0;
206 207 208
                    while (j < size_max_x && !IS_INTRA(j, -1))
                        j++;
                    EXTEND_LEFT_CIP(top, j, j + 1);
209 210 211 212
                    left[-1] = top[-1];
                }
            } else {
                j = 0;
213 214
                while (j < size_max_x && !IS_INTRA(j, -1))
                    j++;
215
                if (j > 0)
216
                    if (x0 > 0) {
217
                        EXTEND_LEFT_CIP(top, j, j + 1);
218 219 220 221
                    } else {
                        EXTEND_LEFT_CIP(top, j, j);
                        top[-1] = top[0];
                    }
222 223
                left[-1] = top[-1];
            }
224
            left[-1] = top[-1];
225
            if (cand_bottom_left || cand_left) {
226 227
                a = PIXEL_SPLAT_X4(left[-1]);
                EXTEND_DOWN_CIP(left, 0, size_max_y);
228
            }
229 230 231 232
            if (!cand_left)
                EXTEND(left, left[-1], size);
            if (!cand_bottom_left)
                EXTEND(left + size, left[size - 1], size);
233
            if (x0 != 0 && y0 != 0) {
234
                a = PIXEL_SPLAT_X4(left[size_max_y - 1]);
235
                EXTEND_UP_CIP(left, size_max_y - 1, size_max_y);
236 237
                if (!IS_INTRA(-1, - 1))
                    left[-1] = left[0];
238
            } else if (x0 == 0) {
239
                EXTEND(left, 0, size_max_y);
240
            } else {
241 242
                a = PIXEL_SPLAT_X4(left[size_max_y - 1]);
                EXTEND_UP_CIP(left, size_max_y - 1, size_max_y);
243 244 245
            }
            top[-1] = left[-1];
            if (y0 != 0) {
246
                a = PIXEL_SPLAT_X4(left[-1]);
247 248 249 250 251 252 253
                EXTEND_RIGHT_CIP(top, 0, size_max_x);
            }
        }
    }
    // Infer the unavailable samples
    if (!cand_bottom_left) {
        if (cand_left) {
254
            EXTEND(left + size, left[size - 1], size);
255
        } else if (cand_up_left) {
256
            EXTEND(left, left[-1], 2 * size);
257 258 259
            cand_left = 1;
        } else if (cand_up) {
            left[-1] = top[0];
260
            EXTEND(left, left[-1], 2 * size);
261
            cand_up_left = 1;
262
            cand_left    = 1;
263
        } else if (cand_up_right) {
264
            EXTEND(top, top[size], size);
265
            left[-1] = top[size];
266
            EXTEND(left, left[-1], 2 * size);
267
            cand_up      = 1;
268
            cand_up_left = 1;
269
            cand_left    = 1;
270
        } else { // No samples available
271
            left[-1] = (1 << (BIT_DEPTH - 1));
272 273
            EXTEND(top,  left[-1], 2 * size);
            EXTEND(left, left[-1], 2 * size);
274 275 276
        }
    }

277 278
    if (!cand_left)
        EXTEND(left, left[size], size);
279 280 281
    if (!cand_up_left) {
        left[-1] = left[0];
    }
282 283 284 285
    if (!cand_up)
        EXTEND(top, left[-1], size);
    if (!cand_up_right)
        EXTEND(top + size, top[size - 1], size);
286 287 288 289

    top[-1] = left[-1];

    // Filtering process
290
    if (!s->ps.sps->intra_smoothing_disabled_flag && (c_idx == 0  || s->ps.sps->chroma_format_idc == 3)) {
291 292 293 294 295 296
        if (mode != INTRA_DC && size != 4){
            int intra_hor_ver_dist_thresh[] = { 7, 1, 0 };
            int min_dist_vert_hor = FFMIN(FFABS((int)(mode - 26U)),
                                          FFABS((int)(mode - 10U)));
            if (min_dist_vert_hor > intra_hor_ver_dist_thresh[log2_size - 3]) {
                int threshold = 1 << (BIT_DEPTH - 5);
297
                if (s->ps.sps->sps_strong_intra_smoothing_enable_flag && c_idx == 0 &&
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
                    log2_size == 5 &&
                    FFABS(top[-1]  + top[63]  - 2 * top[31])  < threshold &&
                    FFABS(left[-1] + left[63] - 2 * left[31]) < threshold) {
                    // We can't just overwrite values in top because it could be
                    // a pointer into src
                    filtered_top[-1] = top[-1];
                    filtered_top[63] = top[63];
                    for (i = 0; i < 63; i++)
                        filtered_top[i] = ((64 - (i + 1)) * top[-1] +
                                           (i + 1)  * top[63] + 32) >> 6;
                    for (i = 0; i < 63; i++)
                        left[i] = ((64 - (i + 1)) * left[-1] +
                                   (i + 1)  * left[63] + 32) >> 6;
                    top = filtered_top;
                } else {
                    filtered_left[2 * size - 1] = left[2 * size - 1];
                    filtered_top[2 * size - 1]  = top[2 * size - 1];
                    for (i = 2 * size - 2; i >= 0; i--)
                        filtered_left[i] = (left[i + 1] + 2 * left[i] +
                                            left[i - 1] + 2) >> 2;
                    filtered_top[-1]  =
                    filtered_left[-1] = (left[0] + 2 * left[-1] + top[0] + 2) >> 2;
                    for (i = 2 * size - 2; i >= 0; i--)
                        filtered_top[i] = (top[i + 1] + 2 * top[i] +
                                           top[i - 1] + 2) >> 2;
                    left = filtered_left;
                    top  = filtered_top;
                }
326 327 328 329 330 331
            }
        }
    }

    switch (mode) {
    case INTRA_PLANAR:
332 333
        s->hpc.pred_planar[log2_size - 2]((uint8_t *)src, (uint8_t *)top,
                                          (uint8_t *)left, stride);
334 335
        break;
    case INTRA_DC:
336 337
        s->hpc.pred_dc((uint8_t *)src, (uint8_t *)top,
                       (uint8_t *)left, stride, log2_size, c_idx);
338 339
        break;
    default:
340 341 342
        s->hpc.pred_angular[log2_size - 2]((uint8_t *)src, (uint8_t *)top,
                                           (uint8_t *)left, stride, c_idx,
                                           mode);
343 344 345 346
        break;
    }
}

347 348 349 350 351 352 353 354 355 356 357 358 359
#define INTRA_PRED(size)                                                            \
static void FUNC(intra_pred_ ## size)(HEVCContext *s, int x0, int y0, int c_idx)    \
{                                                                                   \
    FUNC(intra_pred)(s, x0, y0, size, c_idx);                                       \
}

INTRA_PRED(2)
INTRA_PRED(3)
INTRA_PRED(4)
INTRA_PRED(5)

#undef INTRA_PRED

360
static av_always_inline void FUNC(pred_planar)(uint8_t *_src, const uint8_t *_top,
361 362
                                  const uint8_t *_left, ptrdiff_t stride,
                                  int trafo_size)
363 364
{
    int x, y;
365 366 367
    pixel *src        = (pixel *)_src;
    const pixel *top  = (const pixel *)_top;
    const pixel *left = (const pixel *)_left;
368 369 370 371 372 373 374
    int size = 1 << trafo_size;
    for (y = 0; y < size; y++)
        for (x = 0; x < size; x++)
            POS(x, y) = ((size - 1 - x) * left[y] + (x + 1) * top[size]  +
                         (size - 1 - y) * top[x]  + (y + 1) * left[size] + size) >> (trafo_size + 1);
}

375 376 377 378 379
#define PRED_PLANAR(size)\
static void FUNC(pred_planar_ ## size)(uint8_t *src, const uint8_t *top,        \
                                       const uint8_t *left, ptrdiff_t stride)   \
{                                                                               \
    FUNC(pred_planar)(src, top, left, stride, size + 2);                        \
380 381
}

382 383 384 385
PRED_PLANAR(0)
PRED_PLANAR(1)
PRED_PLANAR(2)
PRED_PLANAR(3)
386

387
#undef PRED_PLANAR
388 389 390 391 392 393

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)
{
    int i, j, x, y;
394 395 396 397 398
    int size          = (1 << log2_size);
    pixel *src        = (pixel *)_src;
    const pixel *top  = (const pixel *)_top;
    const pixel *left = (const pixel *)_left;
    int dc            = size;
399 400 401 402 403 404 405 406 407
    pixel4 a;
    for (i = 0; i < size; i++)
        dc += left[i] + top[i];

    dc >>= log2_size + 1;

    a = PIXEL_SPLAT_X4(dc);

    for (i = 0; i < size; i++)
408 409
        for (j = 0; j < size; j+=4)
            AV_WN4P(&POS(j, i), a);
410 411

    if (c_idx == 0 && size < 32) {
412
        POS(0, 0) = (left[0] + 2 * dc + top[0] + 2) >> 2;
413 414 415 416 417 418 419 420 421 422 423 424 425 426
        for (x = 1; x < size; x++)
            POS(x, 0) = (top[x] + 3 * dc + 2) >> 2;
        for (y = 1; y < size; y++)
            POS(0, y) = (left[y] + 3 * dc + 2) >> 2;
    }
}

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)
{
    int x, y;
427 428 429
    pixel *src        = (pixel *)_src;
    const pixel *top  = (const pixel *)_top;
    const pixel *left = (const pixel *)_left;
430 431

    static const int intra_pred_angle[] = {
432 433
         32,  26,  21,  17, 13,  9,  5, 2, 0, -2, -5, -9, -13, -17, -21, -26, -32,
        -26, -21, -17, -13, -9, -5, -2, 0, 2,  5,  9, 13,  17,  21,  26,  32
434 435 436 437 438 439 440
    };
    static const int inv_angle[] = {
        -4096, -1638, -910, -630, -482, -390, -315, -256, -315, -390, -482,
        -630, -910, -1638, -4096
    };

    int angle = intra_pred_angle[mode - 2];
441
    pixel ref_array[3 * MAX_TB_SIZE + 4];
442 443 444 445 446 447 448
    pixel *ref_tmp = ref_array + size;
    const pixel *ref;
    int last = (size * angle) >> 5;

    if (mode >= 18) {
        ref = top - 1;
        if (angle < 0 && last < -1) {
449 450
            for (x = 0; x <= size; x += 4)
                AV_WN4P(&ref_tmp[x], AV_RN4P(&top[x - 1]));
451
            for (x = last; x <= -1; x++)
452
                ref_tmp[x] = left[-1 + ((x * inv_angle[mode - 11] + 128) >> 8)];
453 454 455 456 457 458 459
            ref = ref_tmp;
        }

        for (y = 0; y < size; y++) {
            int idx  = ((y + 1) * angle) >> 5;
            int fact = ((y + 1) * angle) & 31;
            if (fact) {
460
                for (x = 0; x < size; x += 4) {
461 462
                    POS(x    , y) = ((32 - fact) * ref[x + idx + 1] +
                                           fact  * ref[x + idx + 2] + 16) >> 5;
463
                    POS(x + 1, y) = ((32 - fact) * ref[x + 1 + idx + 1] +
464
                                           fact  * ref[x + 1 + idx + 2] + 16) >> 5;
465
                    POS(x + 2, y) = ((32 - fact) * ref[x + 2 + idx + 1] +
466
                                           fact  * ref[x + 2 + idx + 2] + 16) >> 5;
467
                    POS(x + 3, y) = ((32 - fact) * ref[x + 3 + idx + 1] +
468
                                           fact  * ref[x + 3 + idx + 2] + 16) >> 5;
469 470
                }
            } else {
471 472
                for (x = 0; x < size; x += 4)
                    AV_WN4P(&POS(x, y), AV_RN4P(&ref[x + idx + 1]));
473 474 475 476 477 478 479 480 481
            }
        }
        if (mode == 26 && c_idx == 0 && size < 32) {
            for (y = 0; y < size; y++)
                POS(0, y) = av_clip_pixel(top[0] + ((left[y] - left[-1]) >> 1));
        }
    } else {
        ref = left - 1;
        if (angle < 0 && last < -1) {
482 483
            for (x = 0; x <= size; x += 4)
                AV_WN4P(&ref_tmp[x], AV_RN4P(&left[x - 1]));
484
            for (x = last; x <= -1; x++)
485
                ref_tmp[x] = top[-1 + ((x * inv_angle[mode - 11] + 128) >> 8)];
486 487 488 489 490 491 492 493 494 495 496 497
            ref = ref_tmp;
        }

        for (x = 0; x < size; x++) {
            int idx  = ((x + 1) * angle) >> 5;
            int fact = ((x + 1) * angle) & 31;
            if (fact) {
                for (y = 0; y < size; y++) {
                    POS(x, y) = ((32 - fact) * ref[y + idx + 1] +
                                       fact  * ref[y + idx + 2] + 16) >> 5;
                }
            } else {
498
                for (y = 0; y < size; y++)
499 500 501 502
                    POS(x, y) = ref[y + idx + 1];
            }
        }
        if (mode == 10 && c_idx == 0 && size < 32) {
503
            for (x = 0; x < size; x += 4) {
504 505 506 507
                POS(x,     0) = av_clip_pixel(left[0] + ((top[x    ] - top[-1]) >> 1));
                POS(x + 1, 0) = av_clip_pixel(left[0] + ((top[x + 1] - top[-1]) >> 1));
                POS(x + 2, 0) = av_clip_pixel(left[0] + ((top[x + 2] - top[-1]) >> 1));
                POS(x + 3, 0) = av_clip_pixel(left[0] + ((top[x + 3] - top[-1]) >> 1));
508
            }
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
        }
    }
}

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)
{
    FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 2);
}

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)
{
    FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 3);
}

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)
{
    FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 4);
}

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)
{
    FUNC(pred_angular)(src, top, left, stride, c_idx, mode, 1 << 5);
}
540

541 542 543 544 545 546 547 548
#undef EXTEND_LEFT_CIP
#undef EXTEND_RIGHT_CIP
#undef EXTEND_UP_CIP
#undef EXTEND_DOWN_CIP
#undef IS_INTRA
#undef MVF_PU
#undef MVF
#undef PU
549
#undef EXTEND
550
#undef MIN_TB_ADDR_ZS
551
#undef POS