GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/hevcdec.c Lines: 1713 2156 79.5 %
Date: 2020-04-04 00:26:16 Branches: 1242 1645 75.5 %

Line Branch Exec Source
1
/*
2
 * HEVC video Decoder
3
 *
4
 * Copyright (C) 2012 - 2013 Guillaume Martres
5
 * Copyright (C) 2012 - 2013 Mickael Raulet
6
 * Copyright (C) 2012 - 2013 Gildas Cocherel
7
 * Copyright (C) 2012 - 2013 Wassim Hamidouche
8
 *
9
 * This file is part of FFmpeg.
10
 *
11
 * FFmpeg is free software; you can redistribute it and/or
12
 * modify it under the terms of the GNU Lesser General Public
13
 * License as published by the Free Software Foundation; either
14
 * version 2.1 of the License, or (at your option) any later version.
15
 *
16
 * FFmpeg is distributed in the hope that it will be useful,
17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19
 * Lesser General Public License for more details.
20
 *
21
 * You should have received a copy of the GNU Lesser General Public
22
 * License along with FFmpeg; if not, write to the Free Software
23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24
 */
25
26
#include "libavutil/attributes.h"
27
#include "libavutil/common.h"
28
#include "libavutil/display.h"
29
#include "libavutil/internal.h"
30
#include "libavutil/mastering_display_metadata.h"
31
#include "libavutil/md5.h"
32
#include "libavutil/opt.h"
33
#include "libavutil/pixdesc.h"
34
#include "libavutil/stereo3d.h"
35
36
#include "bswapdsp.h"
37
#include "bytestream.h"
38
#include "cabac_functions.h"
39
#include "golomb.h"
40
#include "hevc.h"
41
#include "hevc_data.h"
42
#include "hevc_parse.h"
43
#include "hevcdec.h"
44
#include "hwaccel.h"
45
#include "profiles.h"
46
47
const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
48
49
/**
50
 * NOTE: Each function hls_foo correspond to the function foo in the
51
 * specification (HLS stands for High Level Syntax).
52
 */
53
54
/**
55
 * Section 5.7
56
 */
57
58
/* free everything allocated  by pic_arrays_init() */
59
735
static void pic_arrays_free(HEVCContext *s)
60
{
61
735
    av_freep(&s->sao);
62
735
    av_freep(&s->deblock);
63
64
735
    av_freep(&s->skip_flag);
65
735
    av_freep(&s->tab_ct_depth);
66
67
735
    av_freep(&s->tab_ipm);
68
735
    av_freep(&s->cbf_luma);
69
735
    av_freep(&s->is_pcm);
70
71
735
    av_freep(&s->qp_y_tab);
72
735
    av_freep(&s->tab_slice_address);
73
735
    av_freep(&s->filter_slice_edges);
74
75
735
    av_freep(&s->horizontal_bs);
76
735
    av_freep(&s->vertical_bs);
77
78
735
    av_freep(&s->sh.entry_point_offset);
79
735
    av_freep(&s->sh.size);
80
735
    av_freep(&s->sh.offset);
81
82
735
    av_buffer_pool_uninit(&s->tab_mvf_pool);
83
735
    av_buffer_pool_uninit(&s->rpl_tab_pool);
84
735
}
85
86
/* allocate arrays that depend on frame dimensions */
87
368
static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
88
{
89
368
    int log2_min_cb_size = sps->log2_min_cb_size;
90
368
    int width            = sps->width;
91
368
    int height           = sps->height;
92
368
    int pic_size_in_ctb  = ((width  >> log2_min_cb_size) + 1) *
93
368
                           ((height >> log2_min_cb_size) + 1);
94
368
    int ctb_count        = sps->ctb_width * sps->ctb_height;
95
368
    int min_pu_size      = sps->min_pu_width * sps->min_pu_height;
96
97
368
    s->bs_width  = (width  >> 2) + 1;
98
368
    s->bs_height = (height >> 2) + 1;
99
100
368
    s->sao           = av_mallocz_array(ctb_count, sizeof(*s->sao));
101
368
    s->deblock       = av_mallocz_array(ctb_count, sizeof(*s->deblock));
102

368
    if (!s->sao || !s->deblock)
103
        goto fail;
104
105
368
    s->skip_flag    = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
106
368
    s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
107

368
    if (!s->skip_flag || !s->tab_ct_depth)
108
        goto fail;
109
110
368
    s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
111
368
    s->tab_ipm  = av_mallocz(min_pu_size);
112
368
    s->is_pcm   = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
113

368
    if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
114
        goto fail;
115
116
368
    s->filter_slice_edges = av_mallocz(ctb_count);
117
368
    s->tab_slice_address  = av_malloc_array(pic_size_in_ctb,
118
                                      sizeof(*s->tab_slice_address));
119
368
    s->qp_y_tab           = av_malloc_array(pic_size_in_ctb,
120
                                      sizeof(*s->qp_y_tab));
121

368
    if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
122
        goto fail;
123
124
368
    s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
125
368
    s->vertical_bs   = av_mallocz_array(s->bs_width, s->bs_height);
126

368
    if (!s->horizontal_bs || !s->vertical_bs)
127
        goto fail;
128
129
368
    s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
130
                                          av_buffer_allocz);
131
368
    s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
132
                                          av_buffer_allocz);
133

368
    if (!s->tab_mvf_pool || !s->rpl_tab_pool)
134
        goto fail;
135
136
368
    return 0;
137
138
fail:
139
    pic_arrays_free(s);
140
    return AVERROR(ENOMEM);
141
}
142
143
1350
static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
144
{
145
1350
    int i = 0;
146
1350
    int j = 0;
147
    uint8_t luma_weight_l0_flag[16];
148
    uint8_t chroma_weight_l0_flag[16];
149
    uint8_t luma_weight_l1_flag[16];
150
    uint8_t chroma_weight_l1_flag[16];
151
    int luma_log2_weight_denom;
152
153
1350
    luma_log2_weight_denom = get_ue_golomb_long(gb);
154

1350
    if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
155
        av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
156
        return AVERROR_INVALIDDATA;
157
    }
158
1350
    s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
159
1350
    if (s->ps.sps->chroma_format_idc != 0) {
160
1350
        int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)get_se_golomb(gb);
161

1350
        if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
162
            av_log(s->avctx, AV_LOG_ERROR, "chroma_log2_weight_denom %"PRId64" is invalid\n", chroma_log2_weight_denom);
163
            return AVERROR_INVALIDDATA;
164
        }
165
1350
        s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
166
    }
167
168
5650
    for (i = 0; i < s->sh.nb_refs[L0]; i++) {
169
4300
        luma_weight_l0_flag[i] = get_bits1(gb);
170
4300
        if (!luma_weight_l0_flag[i]) {
171
1183
            s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
172
1183
            s->sh.luma_offset_l0[i] = 0;
173
        }
174
    }
175
1350
    if (s->ps.sps->chroma_format_idc != 0) {
176
5650
        for (i = 0; i < s->sh.nb_refs[L0]; i++)
177
4300
            chroma_weight_l0_flag[i] = get_bits1(gb);
178
    } else {
179
        for (i = 0; i < s->sh.nb_refs[L0]; i++)
180
            chroma_weight_l0_flag[i] = 0;
181
    }
182
5650
    for (i = 0; i < s->sh.nb_refs[L0]; i++) {
183
4300
        if (luma_weight_l0_flag[i]) {
184
3117
            int delta_luma_weight_l0 = get_se_golomb(gb);
185
3117
            if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
186
                return AVERROR_INVALIDDATA;
187
3117
            s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
188
3117
            s->sh.luma_offset_l0[i] = get_se_golomb(gb);
189
        }
190
4300
        if (chroma_weight_l0_flag[i]) {
191
3393
            for (j = 0; j < 2; j++) {
192
2262
                int delta_chroma_weight_l0 = get_se_golomb(gb);
193
2262
                int delta_chroma_offset_l0 = get_se_golomb(gb);
194
195
2262
                if (   (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
196

2262
                    || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
197
                    return AVERROR_INVALIDDATA;
198
                }
199
200
2262
                s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
201
2262
                s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
202
2262
                                                                                    >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
203
            }
204
        } else {
205
3169
            s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
206
3169
            s->sh.chroma_offset_l0[i][0] = 0;
207
3169
            s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
208
3169
            s->sh.chroma_offset_l0[i][1] = 0;
209
        }
210
    }
211
1350
    if (s->sh.slice_type == HEVC_SLICE_B) {
212
1839
        for (i = 0; i < s->sh.nb_refs[L1]; i++) {
213
1256
            luma_weight_l1_flag[i] = get_bits1(gb);
214
1256
            if (!luma_weight_l1_flag[i]) {
215
510
                s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
216
510
                s->sh.luma_offset_l1[i] = 0;
217
            }
218
        }
219
583
        if (s->ps.sps->chroma_format_idc != 0) {
220
1839
            for (i = 0; i < s->sh.nb_refs[L1]; i++)
221
1256
                chroma_weight_l1_flag[i] = get_bits1(gb);
222
        } else {
223
            for (i = 0; i < s->sh.nb_refs[L1]; i++)
224
                chroma_weight_l1_flag[i] = 0;
225
        }
226
1839
        for (i = 0; i < s->sh.nb_refs[L1]; i++) {
227
1256
            if (luma_weight_l1_flag[i]) {
228
746
                int delta_luma_weight_l1 = get_se_golomb(gb);
229
746
                if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
230
                    return AVERROR_INVALIDDATA;
231
746
                s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
232
746
                s->sh.luma_offset_l1[i] = get_se_golomb(gb);
233
            }
234
1256
            if (chroma_weight_l1_flag[i]) {
235
708
                for (j = 0; j < 2; j++) {
236
472
                    int delta_chroma_weight_l1 = get_se_golomb(gb);
237
472
                    int delta_chroma_offset_l1 = get_se_golomb(gb);
238
239
472
                    if (   (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
240

472
                        || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
241
                        return AVERROR_INVALIDDATA;
242
                    }
243
244
472
                    s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
245
472
                    s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
246
472
                                                                                        >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
247
                }
248
            } else {
249
1020
                s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
250
1020
                s->sh.chroma_offset_l1[i][0] = 0;
251
1020
                s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
252
1020
                s->sh.chroma_offset_l1[i][1] = 0;
253
            }
254
        }
255
    }
256
1350
    return 0;
257
}
258
259
18961
static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
260
{
261
18961
    const HEVCSPS *sps = s->ps.sps;
262
18961
    int max_poc_lsb    = 1 << sps->log2_max_poc_lsb;
263
18961
    int prev_delta_msb = 0;
264
18961
    unsigned int nb_sps = 0, nb_sh;
265
    int i;
266
267
18961
    rps->nb_refs = 0;
268
18961
    if (!sps->long_term_ref_pics_present_flag)
269
17927
        return 0;
270
271
1034
    if (sps->num_long_term_ref_pics_sps > 0)
272
499
        nb_sps = get_ue_golomb_long(gb);
273
1034
    nb_sh = get_ue_golomb_long(gb);
274
275
1034
    if (nb_sps > sps->num_long_term_ref_pics_sps)
276
        return AVERROR_INVALIDDATA;
277
1034
    if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
278
        return AVERROR_INVALIDDATA;
279
280
1034
    rps->nb_refs = nb_sh + nb_sps;
281
282
2594
    for (i = 0; i < rps->nb_refs; i++) {
283
        uint8_t delta_poc_msb_present;
284
285
1560
        if (i < nb_sps) {
286
184
            uint8_t lt_idx_sps = 0;
287
288
184
            if (sps->num_long_term_ref_pics_sps > 1)
289
184
                lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
290
291
184
            rps->poc[i]  = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
292
184
            rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
293
        } else {
294
1376
            rps->poc[i]  = get_bits(gb, sps->log2_max_poc_lsb);
295
1376
            rps->used[i] = get_bits1(gb);
296
        }
297
298
1560
        delta_poc_msb_present = get_bits1(gb);
299
1560
        if (delta_poc_msb_present) {
300
48
            int64_t delta = get_ue_golomb_long(gb);
301
            int64_t poc;
302
303

48
            if (i && i != nb_sps)
304
31
                delta += prev_delta_msb;
305
306
48
            poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
307
48
            if (poc != (int32_t)poc)
308
                return AVERROR_INVALIDDATA;
309
48
            rps->poc[i] = poc;
310
48
            prev_delta_msb = delta;
311
        }
312
    }
313
314
1034
    return 0;
315
}
316
317
544
static void export_stream_params(HEVCContext *s, const HEVCSPS *sps)
318
{
319
544
    AVCodecContext *avctx = s->avctx;
320
544
    const HEVCParamSets *ps = &s->ps;
321
544
    const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
322
544
    const HEVCWindow *ow = &sps->output_window;
323
544
    unsigned int num = 0, den = 0;
324
325
544
    avctx->pix_fmt             = sps->pix_fmt;
326
544
    avctx->coded_width         = sps->width;
327
544
    avctx->coded_height        = sps->height;
328
544
    avctx->width               = sps->width  - ow->left_offset - ow->right_offset;
329
544
    avctx->height              = sps->height - ow->top_offset  - ow->bottom_offset;
330
544
    avctx->has_b_frames        = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
331
544
    avctx->profile             = sps->ptl.general_ptl.profile_idc;
332
544
    avctx->level               = sps->ptl.general_ptl.level_idc;
333
334
544
    ff_set_sar(avctx, sps->vui.sar);
335
336
544
    if (sps->vui.video_signal_type_present_flag)
337
8
        avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
338
8
                                                            : AVCOL_RANGE_MPEG;
339
    else
340
536
        avctx->color_range = AVCOL_RANGE_MPEG;
341
342
544
    if (sps->vui.colour_description_present_flag) {
343
8
        avctx->color_primaries = sps->vui.colour_primaries;
344
8
        avctx->color_trc       = sps->vui.transfer_characteristic;
345
8
        avctx->colorspace      = sps->vui.matrix_coeffs;
346
    } else {
347
536
        avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
348
536
        avctx->color_trc       = AVCOL_TRC_UNSPECIFIED;
349
536
        avctx->colorspace      = AVCOL_SPC_UNSPECIFIED;
350
    }
351
352
544
    if (vps->vps_timing_info_present_flag) {
353
20
        num = vps->vps_num_units_in_tick;
354
20
        den = vps->vps_time_scale;
355
524
    } else if (sps->vui.vui_timing_info_present_flag) {
356
24
        num = sps->vui.vui_num_units_in_tick;
357
24
        den = sps->vui.vui_time_scale;
358
    }
359
360

544
    if (num != 0 && den != 0)
361
44
        av_reduce(&avctx->framerate.den, &avctx->framerate.num,
362
                  num, den, 1 << 30);
363
364

544
    if (s->sei.alternative_transfer.present &&
365
        av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
366
        s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
367
        avctx->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
368
    }
369
544
}
370
371
367
static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
372
{
373
#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
374
                     CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
375
                     CONFIG_HEVC_NVDEC_HWACCEL + \
376
                     CONFIG_HEVC_VAAPI_HWACCEL + \
377
                     CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
378
                     CONFIG_HEVC_VDPAU_HWACCEL)
379
367
    enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
380
381

367
    switch (sps->pix_fmt) {
382
319
    case AV_PIX_FMT_YUV420P:
383
    case AV_PIX_FMT_YUVJ420P:
384
#if CONFIG_HEVC_DXVA2_HWACCEL
385
        *fmt++ = AV_PIX_FMT_DXVA2_VLD;
386
#endif
387
#if CONFIG_HEVC_D3D11VA_HWACCEL
388
        *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
389
        *fmt++ = AV_PIX_FMT_D3D11;
390
#endif
391
#if CONFIG_HEVC_VAAPI_HWACCEL
392
319
        *fmt++ = AV_PIX_FMT_VAAPI;
393
#endif
394
#if CONFIG_HEVC_VDPAU_HWACCEL
395
319
        *fmt++ = AV_PIX_FMT_VDPAU;
396
#endif
397
#if CONFIG_HEVC_NVDEC_HWACCEL
398
        *fmt++ = AV_PIX_FMT_CUDA;
399
#endif
400
#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
401
        *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
402
#endif
403
319
        break;
404
22
    case AV_PIX_FMT_YUV420P10:
405
#if CONFIG_HEVC_DXVA2_HWACCEL
406
        *fmt++ = AV_PIX_FMT_DXVA2_VLD;
407
#endif
408
#if CONFIG_HEVC_D3D11VA_HWACCEL
409
        *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
410
        *fmt++ = AV_PIX_FMT_D3D11;
411
#endif
412
#if CONFIG_HEVC_VAAPI_HWACCEL
413
22
        *fmt++ = AV_PIX_FMT_VAAPI;
414
#endif
415
#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
416
        *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
417
#endif
418
#if CONFIG_HEVC_NVDEC_HWACCEL
419
        *fmt++ = AV_PIX_FMT_CUDA;
420
#endif
421
22
        break;
422
4
    case AV_PIX_FMT_YUV444P:
423
#if CONFIG_HEVC_VDPAU_HWACCEL
424
4
        *fmt++ = AV_PIX_FMT_VDPAU;
425
#endif
426
#if CONFIG_HEVC_NVDEC_HWACCEL
427
        *fmt++ = AV_PIX_FMT_CUDA;
428
#endif
429
4
        break;
430
10
    case AV_PIX_FMT_YUV422P:
431
    case AV_PIX_FMT_YUV422P10LE:
432
#if CONFIG_HEVC_VAAPI_HWACCEL
433
10
       *fmt++ = AV_PIX_FMT_VAAPI;
434
#endif
435
10
        break;
436
10
    case AV_PIX_FMT_YUV420P12:
437
    case AV_PIX_FMT_YUV444P10:
438
    case AV_PIX_FMT_YUV444P12:
439
#if CONFIG_HEVC_NVDEC_HWACCEL
440
        *fmt++ = AV_PIX_FMT_CUDA;
441
#endif
442
10
        break;
443
    }
444
445
367
    *fmt++ = sps->pix_fmt;
446
367
    *fmt = AV_PIX_FMT_NONE;
447
448
367
    return ff_thread_get_format(s->avctx, pix_fmts);
449
}
450
451
368
static int set_sps(HEVCContext *s, const HEVCSPS *sps,
452
                   enum AVPixelFormat pix_fmt)
453
{
454
    int ret, i;
455
456
368
    pic_arrays_free(s);
457
368
    s->ps.sps = NULL;
458
368
    s->ps.vps = NULL;
459
460
368
    if (!sps)
461
        return 0;
462
463
368
    ret = pic_arrays_init(s, sps);
464
368
    if (ret < 0)
465
        goto fail;
466
467
368
    export_stream_params(s, sps);
468
469
368
    s->avctx->pix_fmt = pix_fmt;
470
471
368
    ff_hevc_pred_init(&s->hpc,     sps->bit_depth);
472
368
    ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
473
368
    ff_videodsp_init (&s->vdsp,    sps->bit_depth);
474
475
1472
    for (i = 0; i < 3; i++) {
476
1104
        av_freep(&s->sao_pixel_buffer_h[i]);
477
1104
        av_freep(&s->sao_pixel_buffer_v[i]);
478
    }
479
480

368
    if (sps->sao_enabled && !s->avctx->hwaccel) {
481
315
        int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
482
        int c_idx;
483
484
1256
        for(c_idx = 0; c_idx < c_count; c_idx++) {
485
941
            int w = sps->width >> sps->hshift[c_idx];
486
941
            int h = sps->height >> sps->vshift[c_idx];
487
941
            s->sao_pixel_buffer_h[c_idx] =
488
941
                av_malloc((w * 2 * sps->ctb_height) <<
489
941
                          sps->pixel_shift);
490
941
            s->sao_pixel_buffer_v[c_idx] =
491
941
                av_malloc((h * 2 * sps->ctb_width) <<
492
941
                          sps->pixel_shift);
493
        }
494
    }
495
496
368
    s->ps.sps = sps;
497
368
    s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
498
499
368
    return 0;
500
501
fail:
502
    pic_arrays_free(s);
503
    s->ps.sps = NULL;
504
    return ret;
505
}
506
507
27513
static int hls_slice_header(HEVCContext *s)
508
{
509
27513
    GetBitContext *gb = &s->HEVClc->gb;
510
27513
    SliceHeader *sh   = &s->sh;
511
    int i, ret;
512
513
    // Coded parameters
514
27513
    sh->first_slice_in_pic_flag = get_bits1(gb);
515

27513
    if (s->ref && sh->first_slice_in_pic_flag) {
516
1
        av_log(s->avctx, AV_LOG_ERROR, "Two slices reporting being the first in the same frame.\n");
517
1
        return 1; // This slice will be skipped later, do not corrupt state
518
    }
519
520



27512
    if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
521
378
        s->seq_decode = (s->seq_decode + 1) & 0xff;
522
378
        s->max_ra     = INT_MAX;
523

378
        if (IS_IDR(s))
524
368
            ff_hevc_clear_refs(s);
525
    }
526
27512
    sh->no_output_of_prior_pics_flag = 0;
527

27512
    if (IS_IRAP(s))
528
1254
        sh->no_output_of_prior_pics_flag = get_bits1(gb);
529
530
27512
    sh->pps_id = get_ue_golomb_long(gb);
531

27512
    if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
532
22
        av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
533
22
        return AVERROR_INVALIDDATA;
534
    }
535
27490
    if (!sh->first_slice_in_pic_flag &&
536
17981
        s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
537
        av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
538
        return AVERROR_INVALIDDATA;
539
    }
540
27490
    s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
541

27490
    if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
542
6
        sh->no_output_of_prior_pics_flag = 1;
543
544
27490
    if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
545
367
        const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
546
367
        const HEVCSPS *last_sps = s->ps.sps;
547
        enum AVPixelFormat pix_fmt;
548
549


367
        if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
550

2
            if (sps->width != last_sps->width || sps->height != last_sps->height ||
551
2
                sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering !=
552
2
                last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
553
                sh->no_output_of_prior_pics_flag = 0;
554
        }
555
367
        ff_hevc_clear_refs(s);
556
557
367
        ret = set_sps(s, sps, sps->pix_fmt);
558
367
        if (ret < 0)
559
            return ret;
560
561
367
        pix_fmt = get_format(s, sps);
562
367
        if (pix_fmt < 0)
563
            return pix_fmt;
564
367
        s->avctx->pix_fmt = pix_fmt;
565
566
367
        s->seq_decode = (s->seq_decode + 1) & 0xff;
567
367
        s->max_ra     = INT_MAX;
568
    }
569
570
27490
    sh->dependent_slice_segment_flag = 0;
571
27490
    if (!sh->first_slice_in_pic_flag) {
572
        int slice_address_length;
573
574
17981
        if (s->ps.pps->dependent_slice_segments_enabled_flag)
575
9092
            sh->dependent_slice_segment_flag = get_bits1(gb);
576
577
17981
        slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
578
17981
                                            s->ps.sps->ctb_height);
579
17981
        sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
580
17981
        if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
581
            av_log(s->avctx, AV_LOG_ERROR,
582
                   "Invalid slice segment address: %u.\n",
583
                   sh->slice_segment_addr);
584
            return AVERROR_INVALIDDATA;
585
        }
586
587
17981
        if (!sh->dependent_slice_segment_flag) {
588
10034
            sh->slice_addr = sh->slice_segment_addr;
589
10034
            s->slice_idx++;
590
        }
591
    } else {
592
9509
        sh->slice_segment_addr = sh->slice_addr = 0;
593
9509
        s->slice_idx           = 0;
594
9509
        s->slice_initialized   = 0;
595
    }
596
597
27490
    if (!sh->dependent_slice_segment_flag) {
598
19543
        s->slice_initialized = 0;
599
600
19547
        for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
601
4
            skip_bits(gb, 1);  // slice_reserved_undetermined_flag[]
602
603
19543
        sh->slice_type = get_ue_golomb_long(gb);
604
19543
        if (!(sh->slice_type == HEVC_SLICE_I ||
605
18427
              sh->slice_type == HEVC_SLICE_P ||
606
14687
              sh->slice_type == HEVC_SLICE_B)) {
607
            av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
608
                   sh->slice_type);
609
            return AVERROR_INVALIDDATA;
610
        }
611

19543
        if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
612
            av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
613
            return AVERROR_INVALIDDATA;
614
        }
615
616
        // when flag is not present, picture is inferred to be output
617
19543
        sh->pic_output_flag = 1;
618
19543
        if (s->ps.pps->output_flag_present_flag)
619
703
            sh->pic_output_flag = get_bits1(gb);
620
621
19543
        if (s->ps.sps->separate_colour_plane_flag)
622
            sh->colour_plane_id = get_bits(gb, 2);
623
624

38504
        if (!IS_IDR(s)) {
625
            int poc, pos;
626
627
18961
            sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
628
18961
            poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
629

18961
            if (!sh->first_slice_in_pic_flag && poc != s->poc) {
630
                av_log(s->avctx, AV_LOG_WARNING,
631
                       "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
632
                if (s->avctx->err_recognition & AV_EF_EXPLODE)
633
                    return AVERROR_INVALIDDATA;
634
                poc = s->poc;
635
            }
636
18961
            s->poc = poc;
637
638
18961
            sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
639
18961
            pos = get_bits_left(gb);
640
18961
            if (!sh->short_term_ref_pic_set_sps_flag) {
641
3149
                ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
642
3149
                if (ret < 0)
643
                    return ret;
644
645
3149
                sh->short_term_rps = &sh->slice_rps;
646
            } else {
647
                int numbits, rps_idx;
648
649
15812
                if (!s->ps.sps->nb_st_rps) {
650
                    av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
651
                    return AVERROR_INVALIDDATA;
652
                }
653
654
15812
                numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
655
15812
                rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
656
15812
                sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
657
            }
658
18961
            sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
659
660
18961
            pos = get_bits_left(gb);
661
18961
            ret = decode_lt_rps(s, &sh->long_term_rps, gb);
662
18961
            if (ret < 0) {
663
                av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
664
                if (s->avctx->err_recognition & AV_EF_EXPLODE)
665
                    return AVERROR_INVALIDDATA;
666
            }
667
18961
            sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
668
669
18961
            if (s->ps.sps->sps_temporal_mvp_enabled_flag)
670
16530
                sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
671
            else
672
2431
                sh->slice_temporal_mvp_enabled_flag = 0;
673
        } else {
674
582
            s->sh.short_term_rps = NULL;
675
582
            s->poc               = 0;
676
        }
677
678
        /* 8.3.1 */
679

19543
        if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
680
9166
            s->nal_unit_type != HEVC_NAL_TRAIL_N &&
681
6707
            s->nal_unit_type != HEVC_NAL_TSA_N   &&
682
6707
            s->nal_unit_type != HEVC_NAL_STSA_N  &&
683
6707
            s->nal_unit_type != HEVC_NAL_RADL_N  &&
684
6685
            s->nal_unit_type != HEVC_NAL_RADL_R  &&
685
6666
            s->nal_unit_type != HEVC_NAL_RASL_N  &&
686
6316
            s->nal_unit_type != HEVC_NAL_RASL_R)
687
5854
            s->pocTid0 = s->poc;
688
689
19543
        if (s->ps.sps->sao_enabled) {
690
16094
            sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
691
16094
            if (s->ps.sps->chroma_format_idc) {
692
16092
                sh->slice_sample_adaptive_offset_flag[1] =
693
16092
                sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
694
            }
695
        } else {
696
3449
            sh->slice_sample_adaptive_offset_flag[0] = 0;
697
3449
            sh->slice_sample_adaptive_offset_flag[1] = 0;
698
3449
            sh->slice_sample_adaptive_offset_flag[2] = 0;
699
        }
700
701
19543
        sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
702

19543
        if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
703
            int nb_refs;
704
705
18427
            sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
706
18427
            if (sh->slice_type == HEVC_SLICE_B)
707
14687
                sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
708
709
18427
            if (get_bits1(gb)) { // num_ref_idx_active_override_flag
710
4860
                sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
711
4860
                if (sh->slice_type == HEVC_SLICE_B)
712
2699
                    sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
713
            }
714

18427
            if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
715
                av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
716
                       sh->nb_refs[L0], sh->nb_refs[L1]);
717
                return AVERROR_INVALIDDATA;
718
            }
719
720
18427
            sh->rpl_modification_flag[0] = 0;
721
18427
            sh->rpl_modification_flag[1] = 0;
722
18427
            nb_refs = ff_hevc_frame_nb_refs(s);
723
18427
            if (!nb_refs) {
724
                av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
725
                return AVERROR_INVALIDDATA;
726
            }
727
728

18427
            if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
729
1596
                sh->rpl_modification_flag[0] = get_bits1(gb);
730
1596
                if (sh->rpl_modification_flag[0]) {
731
3955
                    for (i = 0; i < sh->nb_refs[L0]; i++)
732
2779
                        sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
733
                }
734
735
1596
                if (sh->slice_type == HEVC_SLICE_B) {
736
1596
                    sh->rpl_modification_flag[1] = get_bits1(gb);
737
1596
                    if (sh->rpl_modification_flag[1] == 1)
738
2207
                        for (i = 0; i < sh->nb_refs[L1]; i++)
739
1555
                            sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
740
                }
741
            }
742
743
18427
            if (sh->slice_type == HEVC_SLICE_B)
744
14687
                sh->mvd_l1_zero_flag = get_bits1(gb);
745
746
18427
            if (s->ps.pps->cabac_init_present_flag)
747
15792
                sh->cabac_init_flag = get_bits1(gb);
748
            else
749
2635
                sh->cabac_init_flag = 0;
750
751
18427
            sh->collocated_ref_idx = 0;
752
18427
            if (sh->slice_temporal_mvp_enabled_flag) {
753
16090
                sh->collocated_list = L0;
754
16090
                if (sh->slice_type == HEVC_SLICE_B)
755
14185
                    sh->collocated_list = !get_bits1(gb);
756
757
16090
                if (sh->nb_refs[sh->collocated_list] > 1) {
758
14395
                    sh->collocated_ref_idx = get_ue_golomb_long(gb);
759
14395
                    if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
760
                        av_log(s->avctx, AV_LOG_ERROR,
761
                               "Invalid collocated_ref_idx: %d.\n",
762
                               sh->collocated_ref_idx);
763
                        return AVERROR_INVALIDDATA;
764
                    }
765
                }
766
            }
767
768

18427
            if ((s->ps.pps->weighted_pred_flag   && sh->slice_type == HEVC_SLICE_P) ||
769

17660
                (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
770
1350
                int ret = pred_weight_table(s, gb);
771
1350
                if (ret < 0)
772
                    return ret;
773
            }
774
775
18427
            sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
776

18427
            if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
777
                av_log(s->avctx, AV_LOG_ERROR,
778
                       "Invalid number of merging MVP candidates: %d.\n",
779
                       sh->max_num_merge_cand);
780
                return AVERROR_INVALIDDATA;
781
            }
782
        }
783
784
19543
        sh->slice_qp_delta = get_se_golomb(gb);
785
786
19543
        if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
787
250
            sh->slice_cb_qp_offset = get_se_golomb(gb);
788
250
            sh->slice_cr_qp_offset = get_se_golomb(gb);
789
        } else {
790
19293
            sh->slice_cb_qp_offset = 0;
791
19293
            sh->slice_cr_qp_offset = 0;
792
        }
793
794
19543
        if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
795
43
            sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
796
        else
797
19500
            sh->cu_chroma_qp_offset_enabled_flag = 0;
798
799
19543
        if (s->ps.pps->deblocking_filter_control_present_flag) {
800
2829
            int deblocking_filter_override_flag = 0;
801
802
2829
            if (s->ps.pps->deblocking_filter_override_enabled_flag)
803
609
                deblocking_filter_override_flag = get_bits1(gb);
804
805
2829
            if (deblocking_filter_override_flag) {
806
390
                sh->disable_deblocking_filter_flag = get_bits1(gb);
807
390
                if (!sh->disable_deblocking_filter_flag) {
808
270
                    int beta_offset_div2 = get_se_golomb(gb);
809
270
                    int tc_offset_div2   = get_se_golomb(gb) ;
810

270
                    if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
811
270
                        tc_offset_div2   < -6 || tc_offset_div2   > 6) {
812
                        av_log(s->avctx, AV_LOG_ERROR,
813
                            "Invalid deblock filter offsets: %d, %d\n",
814
                            beta_offset_div2, tc_offset_div2);
815
                        return AVERROR_INVALIDDATA;
816
                    }
817
270
                    sh->beta_offset = beta_offset_div2 * 2;
818
270
                    sh->tc_offset   =   tc_offset_div2 * 2;
819
                }
820
            } else {
821
2439
                sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
822
2439
                sh->beta_offset                    = s->ps.pps->beta_offset;
823
2439
                sh->tc_offset                      = s->ps.pps->tc_offset;
824
            }
825
        } else {
826
16714
            sh->disable_deblocking_filter_flag = 0;
827
16714
            sh->beta_offset                    = 0;
828
16714
            sh->tc_offset                      = 0;
829
        }
830
831
19543
        if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
832
17010
            (sh->slice_sample_adaptive_offset_flag[0] ||
833
11403
             sh->slice_sample_adaptive_offset_flag[1] ||
834
11385
             !sh->disable_deblocking_filter_flag)) {
835
16947
            sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
836
        } else {
837
2596
            sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
838
        }
839
7947
    } else if (!s->slice_initialized) {
840
        av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
841
        return AVERROR_INVALIDDATA;
842
    }
843
844
27490
    sh->num_entry_point_offsets = 0;
845

27490
    if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
846
7411
        unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
847
        // It would be possible to bound this tighter but this here is simpler
848
7411
        if (num_entry_point_offsets > get_bits_left(gb)) {
849
            av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
850
            return AVERROR_INVALIDDATA;
851
        }
852
853
7411
        sh->num_entry_point_offsets = num_entry_point_offsets;
854
7411
        if (sh->num_entry_point_offsets > 0) {
855
1945
            int offset_len = get_ue_golomb_long(gb) + 1;
856
857

1945
            if (offset_len < 1 || offset_len > 32) {
858
                sh->num_entry_point_offsets = 0;
859
                av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
860
                return AVERROR_INVALIDDATA;
861
            }
862
863
1945
            av_freep(&sh->entry_point_offset);
864
1945
            av_freep(&sh->offset);
865
1945
            av_freep(&sh->size);
866
1945
            sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
867
1945
            sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
868
1945
            sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
869

1945
            if (!sh->entry_point_offset || !sh->offset || !sh->size) {
870
                sh->num_entry_point_offsets = 0;
871
                av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
872
                return AVERROR(ENOMEM);
873
            }
874
9525
            for (i = 0; i < sh->num_entry_point_offsets; i++) {
875
7580
                unsigned val = get_bits_long(gb, offset_len);
876
7580
                sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
877
            }
878

1945
            if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
879
                s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
880
                s->threads_number = 1;
881
            } else
882
1945
                s->enable_parallel_tiles = 0;
883
        } else
884
5466
            s->enable_parallel_tiles = 0;
885
    }
886
887
27490
    if (s->ps.pps->slice_header_extension_present_flag) {
888
2765
        unsigned int length = get_ue_golomb_long(gb);
889
2765
        if (length*8LL > get_bits_left(gb)) {
890
            av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
891
            return AVERROR_INVALIDDATA;
892
        }
893
23029
        for (i = 0; i < length; i++)
894
20264
            skip_bits(gb, 8);  // slice_header_extension_data_byte
895
    }
896
897
    // Inferred parameters
898
27490
    sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
899
27490
    if (sh->slice_qp > 51 ||
900
27490
        sh->slice_qp < -s->ps.sps->qp_bd_offset) {
901
        av_log(s->avctx, AV_LOG_ERROR,
902
               "The slice_qp %d is outside the valid range "
903
               "[%d, 51].\n",
904
               sh->slice_qp,
905
               -s->ps.sps->qp_bd_offset);
906
        return AVERROR_INVALIDDATA;
907
    }
908
909
27490
    sh->slice_ctb_addr_rs = sh->slice_segment_addr;
910
911

27490
    if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
912
        av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
913
        return AVERROR_INVALIDDATA;
914
    }
915
916
27490
    if (get_bits_left(gb) < 0) {
917
        av_log(s->avctx, AV_LOG_ERROR,
918
               "Overread slice header by %d bits\n", -get_bits_left(gb));
919
        return AVERROR_INVALIDDATA;
920
    }
921
922
27490
    s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
923
924
27490
    if (!s->ps.pps->cu_qp_delta_enabled_flag)
925
22562
        s->HEVClc->qp_y = s->sh.slice_qp;
926
927
27490
    s->slice_initialized = 1;
928
27490
    s->HEVClc->tu.cu_qp_offset_cb = 0;
929
27490
    s->HEVClc->tu.cu_qp_offset_cr = 0;
930
931
27490
    return 0;
932
}
933
934
#define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
935
936
#define SET_SAO(elem, value)                            \
937
do {                                                    \
938
    if (!sao_merge_up_flag && !sao_merge_left_flag)     \
939
        sao->elem = value;                              \
940
    else if (sao_merge_left_flag)                       \
941
        sao->elem = CTB(s->sao, rx-1, ry).elem;         \
942
    else if (sao_merge_up_flag)                         \
943
        sao->elem = CTB(s->sao, rx, ry-1).elem;         \
944
    else                                                \
945
        sao->elem = 0;                                  \
946
} while (0)
947
948
1377406
static void hls_sao_param(HEVCContext *s, int rx, int ry)
949
{
950
1377406
    HEVCLocalContext *lc    = s->HEVClc;
951
1377406
    int sao_merge_left_flag = 0;
952
1377406
    int sao_merge_up_flag   = 0;
953
1377406
    SAOParams *sao          = &CTB(s->sao, rx, ry);
954
    int c_idx, i;
955
956
1377406
    if (s->sh.slice_sample_adaptive_offset_flag[0] ||
957
799850
        s->sh.slice_sample_adaptive_offset_flag[1]) {
958
579200
        if (rx > 0) {
959
548799
            if (lc->ctb_left_flag)
960
540356
                sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
961
        }
962

579200
        if (ry > 0 && !sao_merge_left_flag) {
963
258412
            if (lc->ctb_up_flag)
964
245064
                sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
965
        }
966
    }
967
968

5509528
    for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
969
4132122
        int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
970
2754716
                                                 s->ps.pps->log2_sao_offset_scale_chroma;
971
972
4132122
        if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
973
2896526
            sao->type_idx[c_idx] = SAO_NOT_APPLIED;
974
2896526
            continue;
975
        }
976
977
1235596
        if (c_idx == 2) {
978
329020
            sao->type_idx[2] = sao->type_idx[1];
979
329020
            sao->eo_class[2] = sao->eo_class[1];
980
        } else {
981


906576
            SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
982
        }
983
984
1235596
        if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
985
745770
            continue;
986
987
2449130
        for (i = 0; i < 4; i++)
988


1959304
            SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
989
990
489826
        if (sao->type_idx[c_idx] == SAO_BAND) {
991
579285
            for (i = 0; i < 4; i++) {
992
463428
                if (sao->offset_abs[c_idx][i]) {
993


350025
                    SET_SAO(offset_sign[c_idx][i],
994
                            ff_hevc_sao_offset_sign_decode(s));
995
                } else {
996
113403
                    sao->offset_sign[c_idx][i] = 0;
997
                }
998
            }
999


115857
            SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
1000
373969
        } else if (c_idx != 2) {
1001


299275
            SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
1002
        }
1003
1004
        // Inferred parameters
1005
489826
        sao->offset_val[c_idx][0] = 0;
1006
2449130
        for (i = 0; i < 4; i++) {
1007
1959304
            sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
1008
1959304
            if (sao->type_idx[c_idx] == SAO_EDGE) {
1009
1495876
                if (i > 1)
1010
747938
                    sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1011
463428
            } else if (sao->offset_sign[c_idx][i]) {
1012
154235
                sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1013
            }
1014
1959304
            sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
1015
        }
1016
    }
1017
1377406
}
1018
1019
#undef SET_SAO
1020
#undef CTB
1021
1022
384850
static int hls_cross_component_pred(HEVCContext *s, int idx) {
1023
384850
    HEVCLocalContext *lc    = s->HEVClc;
1024
384850
    int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
1025
1026
384850
    if (log2_res_scale_abs_plus1 !=  0) {
1027
235843
        int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
1028
235843
        lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
1029
235843
                               (1 - 2 * res_scale_sign_flag);
1030
    } else {
1031
149007
        lc->tu.res_scale_val = 0;
1032
    }
1033
1034
1035
384850
    return 0;
1036
}
1037
1038
15054346
static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1039
                              int xBase, int yBase, int cb_xBase, int cb_yBase,
1040
                              int log2_cb_size, int log2_trafo_size,
1041
                              int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
1042
{
1043
15054346
    HEVCLocalContext *lc = s->HEVClc;
1044
15054346
    const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
1045
    int i;
1046
1047
15054346
    if (lc->cu.pred_mode == MODE_INTRA) {
1048
9462421
        int trafo_size = 1 << log2_trafo_size;
1049
9462421
        ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1050
1051
9462421
        s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1052
    }
1053
1054

15054346
    if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1055

15116134
        (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1056
10623650
        int scan_idx   = SCAN_DIAG;
1057
10623650
        int scan_idx_c = SCAN_DIAG;
1058

16327348
        int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1059
5703698
                         (s->ps.sps->chroma_format_idc == 2 &&
1060

227786
                         (cbf_cb[1] || cbf_cr[1]));
1061
1062

10623650
        if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1063
543293
            lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1064
543293
            if (lc->tu.cu_qp_delta != 0)
1065
353071
                if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1066
194965
                    lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1067
543293
            lc->tu.is_cu_qp_delta_coded = 1;
1068
1069
543293
            if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1070
543292
                lc->tu.cu_qp_delta >  (25 + s->ps.sps->qp_bd_offset / 2)) {
1071
1
                av_log(s->avctx, AV_LOG_ERROR,
1072
                       "The cu_qp_delta %d is outside the valid range "
1073
                       "[%d, %d].\n",
1074
                       lc->tu.cu_qp_delta,
1075
1
                       -(26 + s->ps.sps->qp_bd_offset / 2),
1076
1
                        (25 + s->ps.sps->qp_bd_offset / 2));
1077
1
                return AVERROR_INVALIDDATA;
1078
            }
1079
1080
543292
            ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1081
        }
1082
1083

10623649
        if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1084

841055
            !lc->cu.cu_transquant_bypass_flag  &&  !lc->tu.is_cu_chroma_qp_offset_coded) {
1085
266275
            int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1086
266275
            if (cu_chroma_qp_offset_flag) {
1087
48966
                int cu_chroma_qp_offset_idx  = 0;
1088
48966
                if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1089
                    cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1090
                    av_log(s->avctx, AV_LOG_ERROR,
1091
                        "cu_chroma_qp_offset_idx not yet tested.\n");
1092
                }
1093
48966
                lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1094
48966
                lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1095
            } else {
1096
217309
                lc->tu.cu_qp_offset_cb = 0;
1097
217309
                lc->tu.cu_qp_offset_cr = 0;
1098
            }
1099
266275
            lc->tu.is_cu_chroma_qp_offset_coded = 1;
1100
        }
1101
1102

10623649
        if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1103
6121592
            if (lc->tu.intra_pred_mode >= 6 &&
1104
4116596
                lc->tu.intra_pred_mode <= 14) {
1105
1491262
                scan_idx = SCAN_VERT;
1106
4630330
            } else if (lc->tu.intra_pred_mode >= 22 &&
1107
2024225
                       lc->tu.intra_pred_mode <= 30) {
1108
1699652
                scan_idx = SCAN_HORIZ;
1109
            }
1110
1111
6121592
            if (lc->tu.intra_pred_mode_c >=  6 &&
1112
3689970
                lc->tu.intra_pred_mode_c <= 14) {
1113
1402714
                scan_idx_c = SCAN_VERT;
1114
4718878
            } else if (lc->tu.intra_pred_mode_c >= 22 &&
1115
1922258
                       lc->tu.intra_pred_mode_c <= 30) {
1116
1607627
                scan_idx_c = SCAN_HORIZ;
1117
            }
1118
        }
1119
1120
10623649
        lc->tu.cross_pf = 0;
1121
1122
10623649
        if (cbf_luma)
1123
9522275
            ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1124

15424842
        if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1125
4801193
            int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1126
4801193
            int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1127

5019009
            lc->tu.cross_pf  = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1128
217816
                                (lc->cu.pred_mode == MODE_INTER ||
1129
168873
                                 (lc->tu.chroma_mode_c ==  4)));
1130
1131
4801193
            if (lc->tu.cross_pf) {
1132
192425
                hls_cross_component_pred(s, 0);
1133
            }
1134

9980644
            for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1135
5179451
                if (lc->cu.pred_mode == MODE_INTRA) {
1136
2802211
                    ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1137
2802211
                    s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1138
                }
1139
5179451
                if (cbf_cb[i])
1140
1356651
                    ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1141
                                                log2_trafo_size_c, scan_idx_c, 1);
1142
                else
1143
3822800
                    if (lc->tu.cross_pf) {
1144
39658
                        ptrdiff_t stride = s->frame->linesize[1];
1145
39658
                        int hshift = s->ps.sps->hshift[1];
1146
39658
                        int vshift = s->ps.sps->vshift[1];
1147
39658
                        int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1148
39658
                        int16_t *coeffs   = (int16_t*)lc->edge_emu_buffer2;
1149
39658
                        int size = 1 << log2_trafo_size_c;
1150
1151
39658
                        uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1152
39658
                                                              ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1153
1871162
                        for (i = 0; i < (size * size); i++) {
1154
1831504
                            coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1155
                        }
1156
39658
                        s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1157
                    }
1158
            }
1159
1160
4801193
            if (lc->tu.cross_pf) {
1161
192425
                hls_cross_component_pred(s, 1);
1162
            }
1163

9980644
            for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1164
5179451
                if (lc->cu.pred_mode == MODE_INTRA) {
1165
2802211
                    ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1166
2802211
                    s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1167
                }
1168
5179451
                if (cbf_cr[i])
1169
1483841
                    ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1170
                                                log2_trafo_size_c, scan_idx_c, 2);
1171
                else
1172
3695610
                    if (lc->tu.cross_pf) {
1173
75924
                        ptrdiff_t stride = s->frame->linesize[2];
1174
75924
                        int hshift = s->ps.sps->hshift[2];
1175
75924
                        int vshift = s->ps.sps->vshift[2];
1176
75924
                        int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1177
75924
                        int16_t *coeffs   = (int16_t*)lc->edge_emu_buffer2;
1178
75924
                        int size = 1 << log2_trafo_size_c;
1179
1180
75924
                        uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1181
75924
                                                          ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1182
3691476
                        for (i = 0; i < (size * size); i++) {
1183
3615552
                            coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1184
                        }
1185
75924
                        s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1186
                    }
1187
            }
1188

5822456
        } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1189
1495788
            int trafo_size_h = 1 << (log2_trafo_size + 1);
1190
1495788
            int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1191

3158445
            for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1192
1662657
                if (lc->cu.pred_mode == MODE_INTRA) {
1193
1182570
                    ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1194
                                                    trafo_size_h, trafo_size_v);
1195
1182570
                    s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1196
                }
1197
1662657
                if (cbf_cb[i])
1198
632269
                    ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1199
                                                log2_trafo_size, scan_idx_c, 1);
1200
            }
1201

3158445
            for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1202
1662657
                if (lc->cu.pred_mode == MODE_INTRA) {
1203
1182570
                    ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1204
                                                trafo_size_h, trafo_size_v);
1205
1182570
                    s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1206
                }
1207
1662657
                if (cbf_cr[i])
1208
713145
                    ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1209
                                                log2_trafo_size, scan_idx_c, 2);
1210
            }
1211
        }
1212

4430696
    } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1213

3501131
        if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1214
996443
            int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1215
996443
            int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1216
996443
            ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1217
996443
            s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1218
996443
            s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1219
996443
            if (s->ps.sps->chroma_format_idc == 2) {
1220
12423
                ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1221
                                                trafo_size_h, trafo_size_v);
1222
12423
                s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1223
12423
                s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1224
            }
1225
1508245
        } else if (blk_idx == 3) {
1226
342183
            int trafo_size_h = 1 << (log2_trafo_size + 1);
1227
342183
            int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1228
342183
            ff_hevc_set_neighbour_available(s, xBase, yBase,
1229
                                            trafo_size_h, trafo_size_v);
1230
342183
            s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1231
342183
            s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1232
342183
            if (s->ps.sps->chroma_format_idc == 2) {
1233
4196
                ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1234
                                                trafo_size_h, trafo_size_v);
1235
4196
                s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1236
4196
                s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1237
            }
1238
        }
1239
    }
1240
1241
15054345
    return 0;
1242
}
1243
1244
356478
static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1245
{
1246
356478
    int cb_size          = 1 << log2_cb_size;
1247
356478
    int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1248
1249
356478
    int min_pu_width     = s->ps.sps->min_pu_width;
1250
356478
    int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1251
356478
    int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1252
    int i, j;
1253
1254
851386
    for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1255
1443964
        for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1256
949056
            s->is_pcm[i + j * min_pu_width] = 2;
1257
356478
}
1258
1259
18189095
static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1260
                              int xBase, int yBase, int cb_xBase, int cb_yBase,
1261
                              int log2_cb_size, int log2_trafo_size,
1262
                              int trafo_depth, int blk_idx,
1263
                              const int *base_cbf_cb, const int *base_cbf_cr)
1264
{
1265
18189095
    HEVCLocalContext *lc = s->HEVClc;
1266
    uint8_t split_transform_flag;
1267
    int cbf_cb[2];
1268
    int cbf_cr[2];
1269
    int ret;
1270
1271
18189095
    cbf_cb[0] = base_cbf_cb[0];
1272
18189095
    cbf_cb[1] = base_cbf_cb[1];
1273
18189095
    cbf_cr[0] = base_cbf_cr[0];
1274
18189095
    cbf_cr[1] = base_cbf_cr[1];
1275
1276
18189095
    if (lc->cu.intra_split_flag) {
1277
6242541
        if (trafo_depth == 1) {
1278
4691972
            lc->tu.intra_pred_mode   = lc->pu.intra_pred_mode[blk_idx];
1279
4691972
            if (s->ps.sps->chroma_format_idc == 3) {
1280
135404
                lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1281
135404
                lc->tu.chroma_mode_c     = lc->pu.chroma_mode_c[blk_idx];
1282
            } else {
1283
4556568
                lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1284
4556568
                lc->tu.chroma_mode_c     = lc->pu.chroma_mode_c[0];
1285
            }
1286
        }
1287
    } else {
1288
11946554
        lc->tu.intra_pred_mode   = lc->pu.intra_pred_mode[0];
1289
11946554
        lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1290
11946554
        lc->tu.chroma_mode_c     = lc->pu.chroma_mode_c[0];
1291
    }
1292
1293
18189095
    if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1294
18081217
        log2_trafo_size >  s->ps.sps->log2_min_tb_size    &&
1295
9478025
        trafo_depth     < lc->cu.max_trafo_depth       &&
1296

7950273
        !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1297
6784667
        split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1298
    } else {
1299
24341822
        int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1300
1532966
                          lc->cu.pred_mode == MODE_INTER &&
1301

12937394
                          lc->cu.part_mode != PART_2Nx2N &&
1302
                          trafo_depth == 0;
1303
1304
11404428
        split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1305


11404428
                               (lc->cu.intra_split_flag && trafo_depth == 0) ||
1306
                               inter_split;
1307
    }
1308
1309

18189095
    if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1310

9973983
        if (trafo_depth == 0 || cbf_cb[0]) {
1311
6815531
            cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1312

6815531
            if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1313
452048
                cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1314
            }
1315
        }
1316
1317

9973983
        if (trafo_depth == 0 || cbf_cr[0]) {
1318
6762539
            cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1319

6762539
            if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1320
587469
                cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1321
            }
1322
        }
1323
    }
1324
1325
18189095
    if (split_transform_flag) {
1326
3134749
        const int trafo_size_split = 1 << (log2_trafo_size - 1);
1327
3134749
        const int x1 = x0 + trafo_size_split;
1328
3134749
        const int y1 = y0 + trafo_size_split;
1329
1330
#define SUBDIVIDE(x, y, idx)                                                    \
1331
do {                                                                            \
1332
    ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1333
                             log2_trafo_size - 1, trafo_depth + 1, idx,         \
1334
                             cbf_cb, cbf_cr);                                   \
1335
    if (ret < 0)                                                                \
1336
        return ret;                                                             \
1337
} while (0)
1338
1339
3134749
        SUBDIVIDE(x0, y0, 0);
1340
3134749
        SUBDIVIDE(x1, y0, 1);
1341
3134749
        SUBDIVIDE(x0, y1, 2);
1342
3134749
        SUBDIVIDE(x1, y1, 3);
1343
1344
#undef SUBDIVIDE
1345
    } else {
1346
15054346
        int min_tu_size      = 1 << s->ps.sps->log2_min_tb_size;
1347
15054346
        int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1348
15054346
        int min_tu_width     = s->ps.sps->min_tb_width;
1349
15054346
        int cbf_luma         = 1;
1350
1351

15054346
        if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1352

976133
            cbf_cb[0] || cbf_cr[0] ||
1353

684251
            (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1354
14382741
            cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1355
        }
1356
1357
15054346
        ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1358
                                 log2_cb_size, log2_trafo_size,
1359
                                 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1360
15054346
        if (ret < 0)
1361
1
            return ret;
1362
        // TODO: store cbf_luma somewhere else
1363
15054345
        if (cbf_luma) {
1364
            int i, j;
1365
28919812
            for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1366
88500442
                for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1367
69102905
                    int x_tu = (x0 + j) >> log2_min_tu_size;
1368
69102905
                    int y_tu = (y0 + i) >> log2_min_tu_size;
1369
69102905
                    s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1370
                }
1371
        }
1372
15054345
        if (!s->sh.disable_deblocking_filter_flag) {
1373
14521525
            ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1374
14521525
            if (s->ps.pps->transquant_bypass_enable_flag &&
1375
373941
                lc->cu.cu_transquant_bypass_flag)
1376
275932
                set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1377
        }
1378
    }
1379
18189094
    return 0;
1380
}
1381
1382
12433
static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1383
{
1384
12433
    HEVCLocalContext *lc = s->HEVClc;
1385
    GetBitContext gb;
1386
12433
    int cb_size   = 1 << log2_cb_size;
1387
12433
    ptrdiff_t stride0 = s->frame->linesize[0];
1388
12433
    ptrdiff_t stride1 = s->frame->linesize[1];
1389
12433
    ptrdiff_t stride2 = s->frame->linesize[2];
1390
12433
    uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1391
12433
    uint8_t *dst1 = &s->frame->data[1][(y0 >> s->ps.sps->vshift[1]) * stride1 + ((x0 >> s->ps.sps->hshift[1]) << s->ps.sps->pixel_shift)];
1392
12433
    uint8_t *dst2 = &s->frame->data[2][(y0 >> s->ps.sps->vshift[2]) * stride2 + ((x0 >> s->ps.sps->hshift[2]) << s->ps.sps->pixel_shift)];
1393
1394
12433
    int length         = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1395
12433
                         (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1396
12433
                          ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1397
12433
                          s->ps.sps->pcm.bit_depth_chroma;
1398
12433
    const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1399
    int ret;
1400
1401
12433
    if (!s->sh.disable_deblocking_filter_flag)
1402
6937
        ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1403
1404
12433
    ret = init_get_bits(&gb, pcm, length);
1405
12433
    if (ret < 0)
1406
        return ret;
1407
1408
12433
    s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size,     &gb, s->ps.sps->pcm.bit_depth);
1409
12433
    if (s->ps.sps->chroma_format_idc) {
1410
12433
        s->hevcdsp.put_pcm(dst1, stride1,
1411
12433
                           cb_size >> s->ps.sps->hshift[1],
1412
12433
                           cb_size >> s->ps.sps->vshift[1],
1413
12433
                           &gb, s->ps.sps->pcm.bit_depth_chroma);
1414
12433
        s->hevcdsp.put_pcm(dst2, stride2,
1415
12433
                           cb_size >> s->ps.sps->hshift[2],
1416
12433
                           cb_size >> s->ps.sps->vshift[2],
1417
12433
                           &gb, s->ps.sps->pcm.bit_depth_chroma);
1418
    }
1419
1420
12433
    return 0;
1421
}
1422
1423
/**
1424
 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1425
 *
1426
 * @param s HEVC decoding context
1427
 * @param dst target buffer for block data at block position
1428
 * @param dststride stride of the dst buffer
1429
 * @param ref reference picture buffer at origin (0, 0)
1430
 * @param mv motion vector (relative to block position) to get pixel data from
1431
 * @param x_off horizontal position of block from origin (0, 0)
1432
 * @param y_off vertical position of block from origin (0, 0)
1433
 * @param block_w width of block
1434
 * @param block_h height of block
1435
 * @param luma_weight weighting factor applied to the luma prediction
1436
 * @param luma_offset additive offset applied to the luma prediction value
1437
 */
1438
1439
4797591
static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1440
                        AVFrame *ref, const Mv *mv, int x_off, int y_off,
1441
                        int block_w, int block_h, int luma_weight, int luma_offset)
1442
{
1443
4797591
    HEVCLocalContext *lc = s->HEVClc;
1444
4797591
    uint8_t *src         = ref->data[0];
1445
4797591
    ptrdiff_t srcstride  = ref->linesize[0];
1446
4797591
    int pic_width        = s->ps.sps->width;
1447
4797591
    int pic_height       = s->ps.sps->height;
1448
4797591
    int mx               = mv->x & 3;
1449
4797591
    int my               = mv->y & 3;
1450

9549525
    int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1451

4751934
                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1452
4797591
    int idx              = ff_hevc_pel_weight[block_w];
1453
1454
4797591
    x_off += mv->x >> 2;
1455
4797591
    y_off += mv->y >> 2;
1456
4797591
    src   += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1457
1458

4797591
    if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1459
4638547
        x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1460
4575674
        y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1461
414120
        const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1462
414120
        int offset     = QPEL_EXTRA_BEFORE * srcstride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1463
414120
        int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1464
1465
414120
        s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1466
                                 edge_emu_stride, srcstride,
1467
                                 block_w + QPEL_EXTRA,
1468
                                 block_h + QPEL_EXTRA,
1469
                                 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1470
                                 pic_width, pic_height);
1471
414120
        src = lc->edge_emu_buffer + buf_offset;
1472
414120
        srcstride = edge_emu_stride;
1473
    }
1474
1475
4797591
    if (!weight_flag)
1476
4691653
        s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1477
                                                      block_h, mx, my, block_w);
1478
    else
1479
105938
        s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1480
105938
                                                        block_h, s->sh.luma_log2_weight_denom,
1481
                                                        luma_weight, luma_offset, mx, my, block_w);
1482
4797591
}
1483
1484
/**
1485
 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1486
 *
1487
 * @param s HEVC decoding context
1488
 * @param dst target buffer for block data at block position
1489
 * @param dststride stride of the dst buffer
1490
 * @param ref0 reference picture0 buffer at origin (0, 0)
1491
 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1492
 * @param x_off horizontal position of block from origin (0, 0)
1493
 * @param y_off vertical position of block from origin (0, 0)
1494
 * @param block_w width of block
1495
 * @param block_h height of block
1496
 * @param ref1 reference picture1 buffer at origin (0, 0)
1497
 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1498
 * @param current_mv current motion vector structure
1499
 */
1500
3781449
 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1501
                       AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1502
                       int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1503
{
1504
3781449
    HEVCLocalContext *lc = s->HEVClc;
1505
3781449
    ptrdiff_t src0stride  = ref0->linesize[0];
1506
3781449
    ptrdiff_t src1stride  = ref1->linesize[0];
1507
3781449
    int pic_width        = s->ps.sps->width;
1508
3781449
    int pic_height       = s->ps.sps->height;
1509
3781449
    int mx0              = mv0->x & 3;
1510
3781449
    int my0              = mv0->y & 3;
1511
3781449
    int mx1              = mv1->x & 3;
1512
3781449
    int my1              = mv1->y & 3;
1513

7562898
    int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1514

3781449
                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1515
3781449
    int x_off0           = x_off + (mv0->x >> 2);
1516
3781449
    int y_off0           = y_off + (mv0->y >> 2);
1517
3781449
    int x_off1           = x_off + (mv1->x >> 2);
1518
3781449
    int y_off1           = y_off + (mv1->y >> 2);
1519
3781449
    int idx              = ff_hevc_pel_weight[block_w];
1520
1521
3781449
    uint8_t *src0  = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1522
3781449
    uint8_t *src1  = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1523
1524

3781449
    if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1525
3629676
        x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1526
3566623
        y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1527
415542
        const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1528
415542
        int offset     = QPEL_EXTRA_BEFORE * src0stride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1529
415542
        int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1530
1531
415542
        s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1532
                                 edge_emu_stride, src0stride,
1533
                                 block_w + QPEL_EXTRA,
1534
                                 block_h + QPEL_EXTRA,
1535
                                 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1536
                                 pic_width, pic_height);
1537
415542
        src0 = lc->edge_emu_buffer + buf_offset;
1538
415542
        src0stride = edge_emu_stride;
1539
    }
1540
1541

3781449
    if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1542
3624885
        x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1543
3559536
        y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1544
426476
        const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1545
426476
        int offset     = QPEL_EXTRA_BEFORE * src1stride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1546
426476
        int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1547
1548
426476
        s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1549
                                 edge_emu_stride, src1stride,
1550
                                 block_w + QPEL_EXTRA,
1551
                                 block_h + QPEL_EXTRA,
1552
                                 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1553
                                 pic_width, pic_height);
1554
426476
        src1 = lc->edge_emu_buffer2 + buf_offset;
1555
426476
        src1stride = edge_emu_stride;
1556
    }
1557
1558
3781449
    s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1559
                                                block_h, mx0, my0, block_w);
1560
3781449
    if (!weight_flag)
1561
3719142
        s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1562
                                                       block_h, mx1, my1, block_w);
1563
    else
1564
62307
        s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1565
62307
                                                         block_h, s->sh.luma_log2_weight_denom,
1566
62307
                                                         s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1567
62307
                                                         s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1568
62307
                                                         s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1569
62307
                                                         s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1570
                                                         mx1, my1, block_w);
1571
1572
3781449
}
1573
1574
/**
1575
 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1576
 *
1577
 * @param s HEVC decoding context
1578
 * @param dst1 target buffer for block data at block position (U plane)
1579
 * @param dst2 target buffer for block data at block position (V plane)
1580
 * @param dststride stride of the dst1 and dst2 buffers
1581
 * @param ref reference picture buffer at origin (0, 0)
1582
 * @param mv motion vector (relative to block position) to get pixel data from
1583
 * @param x_off horizontal position of block from origin (0, 0)
1584
 * @param y_off vertical position of block from origin (0, 0)
1585
 * @param block_w width of block
1586
 * @param block_h height of block
1587
 * @param chroma_weight weighting factor applied to the chroma prediction
1588
 * @param chroma_offset additive offset applied to the chroma prediction value
1589
 */
1590
1591
9595182
static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1592
                          ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1593
                          int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1594
{
1595
9595182
    HEVCLocalContext *lc = s->HEVClc;
1596
9595182
    int pic_width        = s->ps.sps->width >> s->ps.sps->hshift[1];
1597
9595182
    int pic_height       = s->ps.sps->height >> s->ps.sps->vshift[1];
1598
9595182
    const Mv *mv         = &current_mv->mv[reflist];
1599

19099050
    int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1600

9503868
                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1601
9595182
    int idx              = ff_hevc_pel_weight[block_w];
1602
9595182
    int hshift           = s->ps.sps->hshift[1];
1603
9595182
    int vshift           = s->ps.sps->vshift[1];
1604
9595182
    intptr_t mx          = av_mod_uintp2(mv->x, 2 + hshift);
1605
9595182
    intptr_t my          = av_mod_uintp2(mv->y, 2 + vshift);
1606
9595182
    intptr_t _mx         = mx << (1 - hshift);
1607
9595182
    intptr_t _my         = my << (1 - vshift);
1608
1609
9595182
    x_off += mv->x >> (2 + hshift);
1610
9595182
    y_off += mv->y >> (2 + vshift);
1611
9595182
    src0  += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1612
1613

9595182
    if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1614
9286952
        x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1615
9161214
        y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1616
818430
        const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1617
818430
        int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1618
818430
        int buf_offset0 = EPEL_EXTRA_BEFORE *
1619
818430
                          (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1620
818430
        s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1621
                                 edge_emu_stride, srcstride,
1622
                                 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1623
                                 x_off - EPEL_EXTRA_BEFORE,
1624
                                 y_off - EPEL_EXTRA_BEFORE,
1625
                                 pic_width, pic_height);
1626
1627
818430
        src0 = lc->edge_emu_buffer + buf_offset0;
1628
818430
        srcstride = edge_emu_stride;
1629
    }
1630
9595182
    if (!weight_flag)
1631
9383306
        s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1632
                                                  block_h, _mx, _my, block_w);
1633
    else
1634
211876
        s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1635
211876
                                                        block_h, s->sh.chroma_log2_weight_denom,
1636
                                                        chroma_weight, chroma_offset, _mx, _my, block_w);
1637
9595182
}
1638
1639
/**
1640
 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1641
 *
1642
 * @param s HEVC decoding context
1643
 * @param dst target buffer for block data at block position
1644
 * @param dststride stride of the dst buffer
1645
 * @param ref0 reference picture0 buffer at origin (0, 0)
1646
 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1647
 * @param x_off horizontal position of block from origin (0, 0)
1648
 * @param y_off vertical position of block from origin (0, 0)
1649
 * @param block_w width of block
1650
 * @param block_h height of block
1651
 * @param ref1 reference picture1 buffer at origin (0, 0)
1652
 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1653
 * @param current_mv current motion vector structure
1654
 * @param cidx chroma component(cb, cr)
1655
 */
1656
7562898
static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1657
                         int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1658
{
1659
7562898
    HEVCLocalContext *lc = s->HEVClc;
1660
7562898
    uint8_t *src1        = ref0->data[cidx+1];
1661
7562898
    uint8_t *src2        = ref1->data[cidx+1];
1662
7562898
    ptrdiff_t src1stride = ref0->linesize[cidx+1];
1663
7562898
    ptrdiff_t src2stride = ref1->linesize[cidx+1];
1664

15125796
    int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1665

7562898
                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1666
7562898
    int pic_width        = s->ps.sps->width >> s->ps.sps->hshift[1];
1667
7562898
    int pic_height       = s->ps.sps->height >> s->ps.sps->vshift[1];
1668
7562898
    Mv *mv0              = &current_mv->mv[0];
1669
7562898
    Mv *mv1              = &current_mv->mv[1];
1670
7562898
    int hshift = s->ps.sps->hshift[1];
1671
7562898
    int vshift = s->ps.sps->vshift[1];
1672
1673
7562898
    intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1674
7562898
    intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1675
7562898
    intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1676
7562898
    intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1677
7562898
    intptr_t _mx0 = mx0 << (1 - hshift);
1678
7562898
    intptr_t _my0 = my0 << (1 - vshift);
1679
7562898
    intptr_t _mx1 = mx1 << (1 - hshift);
1680
7562898
    intptr_t _my1 = my1 << (1 - vshift);
1681
1682
7562898
    int x_off0 = x_off + (mv0->x >> (2 + hshift));
1683
7562898
    int y_off0 = y_off + (mv0->y >> (2 + vshift));
1684
7562898
    int x_off1 = x_off + (mv1->x >> (2 + hshift));
1685
7562898
    int y_off1 = y_off + (mv1->y >> (2 + vshift));
1686
7562898
    int idx = ff_hevc_pel_weight[block_w];
1687
7562898
    src1  += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1688
7562898
    src2  += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1689
1690

7562898
    if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1691
7264516
        x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1692
7138414
        y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1693
825266
        const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1694
825266
        int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1695
825266
        int buf_offset1 = EPEL_EXTRA_BEFORE *
1696
825266
                          (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1697
1698
825266
        s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1699
                                 edge_emu_stride, src1stride,
1700
                                 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1701
                                 x_off0 - EPEL_EXTRA_BEFORE,
1702
                                 y_off0 - EPEL_EXTRA_BEFORE,
1703
                                 pic_width, pic_height);
1704
1705
825266
        src1 = lc->edge_emu_buffer + buf_offset1;
1706
825266
        src1stride = edge_emu_stride;
1707
    }
1708
1709

7562898
    if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1710
7254974
        x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1711
7124282
        y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1712
847398
        const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1713
847398
        int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1714
847398
        int buf_offset1 = EPEL_EXTRA_BEFORE *
1715
847398
                          (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1716
1717
847398
        s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1718
                                 edge_emu_stride, src2stride,
1719
                                 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1720
                                 x_off1 - EPEL_EXTRA_BEFORE,
1721
                                 y_off1 - EPEL_EXTRA_BEFORE,
1722
                                 pic_width, pic_height);
1723
1724
847398
        src2 = lc->edge_emu_buffer2 + buf_offset1;
1725
847398
        src2stride = edge_emu_stride;
1726
    }
1727
1728
7562898
    s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1729
                                                block_h, _mx0, _my0, block_w);
1730
7562898
    if (!weight_flag)
1731
7438284
        s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1732
7438284
                                                       src2, src2stride, lc->tmp,
1733
                                                       block_h, _mx1, _my1, block_w);
1734
    else
1735
124614
        s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1736
124614
                                                         src2, src2stride, lc->tmp,
1737
                                                         block_h,
1738
124614
                                                         s->sh.chroma_log2_weight_denom,
1739
124614
                                                         s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1740
124614
                                                         s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1741
124614
                                                         s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1742
124614
                                                         s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1743
                                                         _mx1, _my1, block_w);
1744
7562898
}
1745
1746
12360489
static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1747
                                const Mv *mv, int y0, int height)
1748
{
1749
12360489
    if (s->threads_type == FF_THREAD_FRAME ) {
1750
107575
        int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1751
1752
107575
        ff_thread_await_progress(&ref->tf, y, 0);
1753
    }
1754
12360489
}
1755
1756
2377473
static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1757
                                  int nPbH, int log2_cb_size, int part_idx,
1758
                                  int merge_idx, MvField *mv)
1759
{
1760
2377473
    HEVCLocalContext *lc = s->HEVClc;
1761
2377473
    enum InterPredIdc inter_pred_idc = PRED_L0;
1762
    int mvp_flag;
1763
1764
2377473
    ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1765
2377473
    mv->pred_flag = 0;
1766
2377473
    if (s->sh.slice_type == HEVC_SLICE_B)
1767
1811353
        inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1768
1769
2377473
    if (inter_pred_idc != PRED_L1) {
1770
1993454
        if (s->sh.nb_refs[L0])
1771
1993454
            mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1772
1773
1993454
        mv->pred_flag = PF_L0;
1774
1993454
        ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1775
1993454
        mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1776
1993454
        ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1777
                                 part_idx, merge_idx, mv, mvp_flag, 0);
1778
1993454
        mv->mv[0].x += lc->pu.mvd.x;
1779
1993454
        mv->mv[0].y += lc->pu.mvd.y;
1780
    }
1781
1782
2377473
    if (inter_pred_idc != PRED_L0) {
1783
788021
        if (s->sh.nb_refs[L1])
1784
788021
            mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1785
1786

788021
        if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1787
157794
            AV_ZERO32(&lc->pu.mvd);
1788
        } else {
1789
630227
            ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1790
        }
1791
1792
788021
        mv->pred_flag += PF_L1;
1793
788021
        mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1794
788021
        ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1795
                                 part_idx, merge_idx, mv, mvp_flag, 1);
1796
788021
        mv->mv[1].x += lc->pu.mvd.x;
1797
788021
        mv->mv[1].y += lc->pu.mvd.y;
1798
    }
1799
2377473
}
1800
1801
8579040
static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1802
                                int nPbW, int nPbH,
1803
                                int log2_cb_size, int partIdx, int idx)
1804
{
1805
#define POS(c_idx, x, y)                                                              \
1806
    &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1807
                           (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1808
8579040
    HEVCLocalContext *lc = s->HEVClc;
1809
8579040
    int merge_idx = 0;
1810
8579040
    struct MvField current_mv = {{{ 0 }}};
1811
1812
8579040
    int min_pu_width = s->ps.sps->min_pu_width;
1813
1814
8579040
    MvField *tab_mvf = s->ref->tab_mvf;
1815
8579040
    RefPicList  *refPicList = s->ref->refPicList;
1816
8579040
    HEVCFrame *ref0 = NULL, *ref1 = NULL;
1817
8579040
    uint8_t *dst0 = POS(0, x0, y0);
1818
8579040
    uint8_t *dst1 = POS(1, x0, y0);
1819
8579040
    uint8_t *dst2 = POS(2, x0, y0);
1820
8579040
    int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1821
8579040
    int min_cb_width     = s->ps.sps->min_cb_width;
1822
8579040
    int x_cb             = x0 >> log2_min_cb_size;
1823
8579040
    int y_cb             = y0 >> log2_min_cb_size;
1824
    int x_pu, y_pu;
1825
    int i, j;
1826
1827
8579040
    int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1828
1829
8579040
    if (!skip_flag)
1830
4706854
        lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1831
1832

8579040
    if (skip_flag || lc->pu.merge_flag) {
1833
6201567
        if (s->sh.max_num_merge_cand > 1)
1834
6124714
            merge_idx = ff_hevc_merge_idx_decode(s);
1835
        else
1836
76853
            merge_idx = 0;
1837
1838
6201567
        ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1839
                                   partIdx, merge_idx, &current_mv);
1840
    } else {
1841
2377473
        hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1842
                              partIdx, merge_idx, &current_mv);
1843
    }
1844
1845
8579040
    x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1846
8579040
    y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1847
1848
40921612
    for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1849
237414796
        for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1850
205072224
            tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1851
1852
8579040
    if (current_mv.pred_flag & PF_L0) {
1853
7818463
        ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1854
7818463
        if (!ref0)
1855
            return;
1856
7818463
        hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1857
    }
1858
8579040
    if (current_mv.pred_flag & PF_L1) {
1859
4542026
        ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1860
4542026
        if (!ref1)
1861
            return;
1862
4542026
        hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1863
    }
1864
1865
8579040
    if (current_mv.pred_flag == PF_L0) {
1866
4037014
        int x0_c = x0 >> s->ps.sps->hshift[1];
1867
4037014
        int y0_c = y0 >> s->ps.sps->vshift[1];
1868
4037014
        int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1869
4037014
        int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1870
1871
4037014
        luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1872
                    &current_mv.mv[0], x0, y0, nPbW, nPbH,
1873
4037014
                    s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1874
4037014
                    s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1875
1876
4037014
        if (s->ps.sps->chroma_format_idc) {
1877
4037014
            chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1878
                          0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1879
4037014
                          s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1880
4037014
            chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1881
                          0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1882
4037014
                          s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1883
        }
1884
4542026
    } else if (current_mv.pred_flag == PF_L1) {
1885
760577
        int x0_c = x0 >> s->ps.sps->hshift[1];
1886
760577
        int y0_c = y0 >> s->ps.sps->vshift[1];
1887
760577
        int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1888
760577
        int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1889
1890
760577
        luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1891
                    &current_mv.mv[1], x0, y0, nPbW, nPbH,
1892
760577
                    s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1893
760577
                    s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1894
1895
760577
        if (s->ps.sps->chroma_format_idc) {
1896
760577
            chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1897
                          1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1898
760577
                          s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1899
1900
760577
            chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1901
                          1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1902
760577
                          s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1903
        }
1904
3781449
    } else if (current_mv.pred_flag == PF_BI) {
1905
3781449
        int x0_c = x0 >> s->ps.sps->hshift[1];
1906
3781449
        int y0_c = y0 >> s->ps.sps->vshift[1];
1907
3781449
        int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1908
3781449
        int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1909
1910
3781449
        luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1911
                   &current_mv.mv[0], x0, y0, nPbW, nPbH,
1912
                   ref1->frame, &current_mv.mv[1], &current_mv);
1913
1914
3781449
        if (s->ps.sps->chroma_format_idc) {
1915
3781449
            chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1916
                         x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 0);
1917
1918
3781449
            chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1919
                         x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 1);
1920
        }
1921
    }
1922
}
1923
1924
/**
1925
 * 8.4.1
1926
 */
1927
7367716
static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1928
                                int prev_intra_luma_pred_flag)
1929
{
1930
7367716
    HEVCLocalContext *lc = s->HEVClc;
1931
7367716
    int x_pu             = x0 >> s->ps.sps->log2_min_pu_size;
1932
7367716
    int y_pu             = y0 >> s->ps.sps->log2_min_pu_size;
1933
7367716
    int min_pu_width     = s->ps.sps->min_pu_width;
1934
7367716
    int size_in_pus      = pu_size >> s->ps.sps->log2_min_pu_size;
1935
7367716
    int x0b              = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1936
7367716
    int y0b              = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1937
1938
1163689
    int cand_up   = (lc->ctb_up_flag || y0b) ?
1939
8531405
                    s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1940
635782
    int cand_left = (lc->ctb_left_flag || x0b) ?
1941
8003498
                    s->tab_ipm[y_pu * min_pu_width + x_pu - 1]   : INTRA_DC;
1942
1943
7367716
    int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1944
1945
7367716
    MvField *tab_mvf = s->ref->tab_mvf;
1946
    int intra_pred_mode;
1947
    int candidate[3];
1948
    int i, j;
1949
1950
    // intra_pred_mode prediction does not cross vertical CTB boundaries
1951
7367716
    if ((y0 - 1) < y_ctb)
1952
909612
        cand_up = INTRA_DC;
1953
1954
7367716
    if (cand_left == cand_up) {
1955
1533574
        if (cand_left < 2) {
1956
892163
            candidate[0] = INTRA_PLANAR;
1957
892163
            candidate[1] = INTRA_DC;
1958
892163
            candidate[2] = INTRA_ANGULAR_26;
1959
        } else {
1960
641411
            candidate[0] = cand_left;
1961
641411
            candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1962
641411
            candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1963
        }
1964
    } else {
1965
5834142
        candidate[0] = cand_left;
1966
5834142
        candidate[1] = cand_up;
1967

5834142
        if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1968
4039502
            candidate[2] = INTRA_PLANAR;
1969

1794640
        } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1970
1205855
            candidate[2] = INTRA_DC;
1971
        } else {
1972
588785
            candidate[2] = INTRA_ANGULAR_26;
1973
        }
1974
    }
1975
1976
7367716
    if (prev_intra_luma_pred_flag) {
1977
4388606
        intra_pred_mode = candidate[lc->pu.mpm_idx];
1978
    } else {
1979
2979110
        if (candidate[0] > candidate[1])
1980
1426440
            FFSWAP(uint8_t, candidate[0], candidate[1]);
1981
2979110
        if (candidate[0] > candidate[2])
1982
1780084
            FFSWAP(uint8_t, candidate[0], candidate[2]);
1983
2979110
        if (candidate[1] > candidate[2])
1984
2224428
            FFSWAP(uint8_t, candidate[1], candidate[2]);
1985
1986
2979110
        intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1987
11916440
        for (i = 0; i < 3; i++)
1988
8937330
            if (intra_pred_mode >= candidate[i])
1989
6512279
                intra_pred_mode++;
1990
    }
1991
1992
    /* write the intra prediction units into the mv array */
1993
7367716
    if (!size_in_pus)
1994
        size_in_pus = 1;
1995
20162470
    for (i = 0; i < size_in_pus; i++) {
1996
12794754
        memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1997
               intra_pred_mode, size_in_pus);
1998
1999
52545370
        for (j = 0; j < size_in_pus; j++) {
2000
39750616
            tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
2001
        }
2002
    }
2003
2004
7367716
    return intra_pred_mode;
2005
}
2006
2007
10850434
static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
2008
                                          int log2_cb_size, int ct_depth)
2009
{
2010
10850434
    int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
2011
10850434
    int x_cb   = x0 >> s->ps.sps->log2_min_cb_size;
2012
10850434
    int y_cb   = y0 >> s->ps.sps->log2_min_cb_size;
2013
    int y;
2014
2015
30759835
    for (y = 0; y < length; y++)
2016
19909401
        memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
2017
               ct_depth, length);
2018
10850434
}
2019
2020
static const uint8_t tab_mode_idx[] = {
2021
     0,  1,  2,  2,  2,  2,  3,  5,  7,  8, 10, 12, 13, 15, 17, 18, 19, 20,
2022
    21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2023
2024
3848737
static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
2025
                                  int log2_cb_size)
2026
{
2027
3848737
    HEVCLocalContext *lc = s->HEVClc;
2028
    static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2029
    uint8_t prev_intra_luma_pred_flag[4];
2030
3848737
    int split   = lc->cu.part_mode == PART_NxN;
2031
3848737
    int pb_size = (1 << log2_cb_size) >> split;
2032
3848737
    int side    = split + 1;
2033
    int chroma_mode;
2034
    int i, j;
2035
2036
8870467
    for (i = 0; i < side; i++)
2037
12389446
        for (j = 0; j < side; j++)
2038
7367716
            prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2039
2040
8870467
    for (i = 0; i < side; i++) {
2041
12389446
        for (j = 0; j < side; j++) {
2042
7367716
            if (prev_intra_luma_pred_flag[2 * i + j])
2043
4388606
                lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2044
            else
2045
2979110
                lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2046
2047
7367716
            lc->pu.intra_pred_mode[2 * i + j] =
2048
7367716
                luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2049
7367716
                                     prev_intra_luma_pred_flag[2 * i + j]);
2050
        }
2051
    }
2052
2053
3848737
    if (s->ps.sps->chroma_format_idc == 3) {
2054
243863
        for (i = 0; i < side; i++) {
2055
345416
            for (j = 0; j < side; j++) {
2056
206559
                lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2057
206559
                if (chroma_mode != 4) {
2058
34248
                    if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
2059
2343
                        lc->pu.intra_pred_mode_c[2 * i + j] = 34;
2060
                    else
2061
31905
                        lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
2062
                } else {
2063
172311
                    lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
2064
                }
2065
            }
2066
        }
2067
3743731
    } else if (s->ps.sps->chroma_format_idc == 2) {
2068
        int mode_idx;
2069
212786
        lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2070
212786
        if (chroma_mode != 4) {
2071
73995
            if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2072
3515
                mode_idx = 34;
2073
            else
2074
70480
                mode_idx = intra_chroma_table[chroma_mode];
2075
        } else {
2076
138791
            mode_idx = lc->pu.intra_pred_mode[0];
2077
        }
2078
212786
        lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2079
3530945
    } else if (s->ps.sps->chroma_format_idc != 0) {
2080
3530753
        chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2081
3530753
        if (chroma_mode != 4) {
2082
916359
            if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2083
67820
                lc->pu.intra_pred_mode_c[0] = 34;
2084
            else
2085
848539
                lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2086
        } else {
2087
2614394
            lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2088
        }
2089
    }
2090
3848737
}
2091
2092
7001698
static void intra_prediction_unit_default_value(HEVCContext *s,
2093
                                                int x0, int y0,
2094
                                                int log2_cb_size)
2095
{
2096
7001698
    HEVCLocalContext *lc = s->HEVClc;
2097
7001698
    int pb_size          = 1 << log2_cb_size;
2098
7001698
    int size_in_pus      = pb_size >> s->ps.sps->log2_min_pu_size;
2099
7001698
    int min_pu_width     = s->ps.sps->min_pu_width;
2100
7001698
    MvField *tab_mvf     = s->ref->tab_mvf;
2101
7001698
    int x_pu             = x0 >> s->ps.sps->log2_min_pu_size;
2102
7001698
    int y_pu             = y0 >> s->ps.sps->log2_min_pu_size;
2103
    int j, k;
2104
2105
7001698
    if (size_in_pus == 0)
2106
        size_in_pus = 1;
2107
36371734
    for (j = 0; j < size_in_pus; j++)
2108
29370036
        memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2109
7001698
    if (lc->cu.pred_mode == MODE_INTRA)
2110
53341
        for (j = 0; j < size_in_pus; j++)
2111
223420
            for (k = 0; k < size_in_pus; k++)
2112
182512
                tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2113
7001698
}
2114
2115
10850435
static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2116
{
2117
10850435
    int cb_size          = 1 << log2_cb_size;
2118
10850435
    HEVCLocalContext *lc = s->HEVClc;
2119
10850435
    int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2120
10850435
    int length           = cb_size >> log2_min_cb_size;
2121
10850435
    int min_cb_width     = s->ps.sps->min_cb_width;
2122
10850435
    int x_cb             = x0 >> log2_min_cb_size;
2123
10850435
    int y_cb             = y0 >> log2_min_cb_size;
2124
10850435
    int idx              = log2_cb_size - 2;
2125
10850435
    int qp_block_mask    = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2126
    int x, y, ret;
2127
2128
10850435
    lc->cu.x                = x0;
2129
10850435
    lc->cu.y                = y0;
2130
10850435
    lc->cu.pred_mode        = MODE_INTRA;
2131
10850435
    lc->cu.part_mode        = PART_2Nx2N;
2132
10850435
    lc->cu.intra_split_flag = 0;
2133
2134
10850435
    SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2135
54252175
    for (x = 0; x < 4; x++)
2136
43401740
        lc->pu.intra_pred_mode[x] = 1;
2137
10850435
    if (s->ps.pps->transquant_bypass_enable_flag) {
2138
200139
        lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2139
200139
        if (lc->cu.cu_transquant_bypass_flag)
2140
80538
            set_deblocking_bypass(s, x0, y0, log2_cb_size);
2141
    } else
2142
10650296
        lc->cu.cu_transquant_bypass_flag = 0;
2143
2144
10850435
    if (s->sh.slice_type != HEVC_SLICE_I) {
2145
8054524
        uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2146
2147
8054524
        x = y_cb * min_cb_width + x_cb;
2148
24315103
        for (y = 0; y < length; y++) {
2149
16260579
            memset(&s->skip_flag[x], skip_flag, length);
2150
16260579
            x += min_cb_width;
2151
        }
2152
8054524
        lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2153
    } else {
2154
2795911
        x = y_cb * min_cb_width + x_cb;
2155
6444734
        for (y = 0; y < length; y++) {
2156
3648823
            memset(&s->skip_flag[x], 0, length);
2157
3648823
            x += min_cb_width;
2158
        }
2159
    }
2160
2161
10850435
    if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2162
3872186
        hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2163
3872186
        intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2164
2165
3872186
        if (!s->sh.disable_deblocking_filter_flag)
2166
3725673
            ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2167
    } else {
2168
6978249
        int pcm_flag = 0;
2169
2170
6978249
        if (s->sh.slice_type != HEVC_SLICE_I)
2171
4182338
            lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2172
6978249
        if (lc->cu.pred_mode != MODE_INTRA ||
2173
3861170
            log2_cb_size == s->ps.sps->log2_min_cb_size) {
2174
6093281
            lc->cu.part_mode        = ff_hevc_part_mode_decode(s, log2_cb_size);
2175
7371910
            lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2176
1278629
                                      lc->cu.pred_mode == MODE_INTRA;
2177
        }
2178
2179
6978249
        if (lc->cu.pred_mode == MODE_INTRA) {
2180

3861170
            if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2181
162684
                log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2182
160815
                log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2183
153183
                pcm_flag = ff_hevc_pcm_flag_decode(s);
2184
            }
2185
3861170
            if (pcm_flag) {
2186
12433
                intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2187
12433
                ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2188
12433
                if (s->ps.sps->pcm.loop_filter_disable_flag)
2189
8
                    set_deblocking_bypass(s, x0, y0, log2_cb_size);
2190
2191
12433
                if (ret < 0)
2192
                    return ret;
2193
            } else {
2194
3848737
                intra_prediction_unit(s, x0, y0, log2_cb_size);
2195
            }
2196
        } else {
2197
3117079
            intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2198


3117079
            switch (lc->cu.part_mode) {
2199
1738576
            case PART_2Nx2N:
2200
1738576
                hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2201
1738576
                break;
2202
445726
            case PART_2NxN:
2203
445726
                hls_prediction_unit(s, x0, y0,               cb_size, cb_size / 2, log2_cb_size, 0, idx);
2204
445726
                hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2205
445726
                break;
2206
535018
            case PART_Nx2N:
2207
535018
                hls_prediction_unit(s, x0,               y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2208
535018
                hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2209
535018
                break;
2210
63734
            case PART_2NxnU:
2211
63734
                hls_prediction_unit(s, x0, y0,               cb_size, cb_size     / 4, log2_cb_size, 0, idx);
2212
63734
                hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2213
63734
                break;
2214
55171
            case PART_2NxnD:
2215
55171
                hls_prediction_unit(s, x0, y0,                   cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2216
55171
                hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size     / 4, log2_cb_size, 1, idx);
2217
55171
                break;
2218
93167
            case PART_nLx2N:
2219
93167
                hls_prediction_unit(s, x0,               y0, cb_size     / 4, cb_size, log2_cb_size, 0, idx - 2);
2220
93167
                hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2221
93167
                break;
2222
80051
            case PART_nRx2N:
2223
80051
                hls_prediction_unit(s, x0,                   y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2224
80051
                hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size     / 4, cb_size, log2_cb_size, 1, idx - 2);
2225
80051
                break;
2226
105636
            case PART_NxN:
2227
105636
                hls_prediction_unit(s, x0,               y0,               cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2228
105636
                hls_prediction_unit(s, x0 + cb_size / 2, y0,               cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2229
105636
                hls_prediction_unit(s, x0,               y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2230
105636
                hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2231
105636
                break;
2232
            }
2233
6978249
        }
2234
2235
6978249
        if (!pcm_flag) {
2236
6965816
            int rqt_root_cbf = 1;
2237
2238
6965816
            if (lc->cu.pred_mode != MODE_INTRA &&
2239

3117079
                !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2240
2346082
                rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2241
            }
2242
6965816
            if (rqt_root_cbf) {
2243
                const static int cbf[2] = { 0 };
2244
5650099
                lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2245
3848737
                                         s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2246
1801362
                                         s->ps.sps->max_transform_hierarchy_depth_inter;
2247
5650099
                ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2248
                                         log2_cb_size,
2249
                                         log2_cb_size, 0, 0, cbf, cbf);
2250
5650099
                if (ret < 0)
2251
1
                    return ret;
2252
            } else {
2253
1315717
                if (!s->sh.disable_deblocking_filter_flag)
2254
1259285
                    ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2255
            }
2256
        }
2257
    }
2258
2259

10850434
    if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2260
743468
        ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2261
2262
10850434
    x = y_cb * min_cb_width + x_cb;
2263
30759835
    for (y = 0; y < length; y++) {
2264
19909401
        memset(&s->qp_y_tab[x], lc->qp_y, length);
2265
19909401
        x += min_cb_width;
2266
    }
2267
2268
10850434
    if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2269
3640236
       ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2270
2098788
        lc->qPy_pred = lc->qp_y;
2271
    }
2272
2273
10850434
    set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2274
2275
10850434
    return 0;
2276
}
2277
2278
14163995
static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2279
                               int log2_cb_size, int cb_depth)
2280
{
2281
14163995
    HEVCLocalContext *lc = s->HEVClc;
2282
14163995
    const int cb_size    = 1 << log2_cb_size;
2283
    int ret;
2284
    int split_cu;
2285
2286
14163995
    lc->ct_depth = cb_depth;
2287
14163995
    if (x0 + cb_size <= s->ps.sps->width  &&
2288
14135392
        y0 + cb_size <= s->ps.sps->height &&
2289
13821613
        log2_cb_size > s->ps.sps->log2_min_cb_size) {
2290
7385931
        split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2291
    } else {
2292
6778064
        split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2293
    }
2294
14163995
    if (s->ps.pps->cu_qp_delta_enabled_flag &&
2295
2375803
        log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2296
1327815
        lc->tu.is_cu_qp_delta_coded = 0;
2297
1327815
        lc->tu.cu_qp_delta          = 0;
2298
    }
2299
2300
14163995
    if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2301
519326
        log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2302
519326
        lc->tu.is_cu_chroma_qp_offset_coded = 0;
2303
    }
2304
2305
14163995
    if (split_cu) {
2306
3313560
        int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2307
3313560
        const int cb_size_split = cb_size >> 1;
2308
3313560
        const int x1 = x0 + cb_size_split;
2309
3313560
        const int y1 = y0 + cb_size_split;
2310
2311
3313560
        int more_data = 0;
2312
2313
3313560
        more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2314
3313560
        if (more_data < 0)
2315
2
            return more_data;
2316
2317

3313558
        if (more_data && x1 < s->ps.sps->width) {
2318
3285868
            more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2319
3285868
            if (more_data < 0)
2320
                return more_data;
2321
        }
2322

3313558
        if (more_data && y1 < s->ps.sps->height) {
2323
3107421
            more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2324
3107421
            if (more_data < 0)
2325
                return more_data;
2326
        }
2327

3313558
        if (more_data && x1 < s->ps.sps->width &&
2328
3275663
            y1 < s->ps.sps->height) {
2329
3079740
            more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2330
3079740
            if (more_data < 0)
2331
1
                return more_data;
2332
        }
2333
2334
3313557
        if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2335
1853526
            ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2336
1376880
            lc->qPy_pred = lc->qp_y;
2337
2338
3313557
        if (more_data)
2339
3368573
            return ((x1 + cb_size_split) < s->ps.sps->width ||
2340
90453
                    (y1 + cb_size_split) < s->ps.sps->height);
2341
        else
2342
35437
            return 0;
2343
    } else {
2344
10850435
        ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2345
10850435
        if (ret < 0)
2346
1
            return ret;
2347
10850434
        if ((!((x0 + cb_size) %
2348
10850434
               (1 << (s->ps.sps->log2_ctb_size))) ||
2349
7944655
             (x0 + cb_size >= s->ps.sps->width)) &&
2350
2976476
            (!((y0 + cb_size) %
2351
2976476
               (1 << (s->ps.sps->log2_ctb_size))) ||
2352
1694448
             (y0 + cb_size >= s->ps.sps->height))) {
2353
1377405
            int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2354
1377405
            return !end_of_slice_flag;
2355
        } else {
2356
9473029
            return 1;
2357
        }
2358
    }
2359
2360
    return 0;
2361
}
2362
2363
1377406
static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2364
                                 int ctb_addr_ts)
2365
{
2366
1377406
    HEVCLocalContext *lc  = s->HEVClc;
2367
1377406
    int ctb_size          = 1 << s->ps.sps->log2_ctb_size;
2368
1377406
    int ctb_addr_rs       = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2369
1377406
    int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2370
2371
1377406
    s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2372
2373
1377406
    if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2374

93384
        if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2375
5334
            lc->first_qp_group = 1;
2376
93384
        lc->end_of_tiles_x = s->ps.sps->width;
2377
1284022
    } else if (s->ps.pps->tiles_enabled_flag) {
2378

271890
        if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2379
6253
            int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2380
6253
            lc->end_of_tiles_x   = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2381
6253
            lc->first_qp_group   = 1;
2382
        }
2383
    } else {
2384
1012132
        lc->end_of_tiles_x = s->ps.sps->width;
2385
    }
2386
2387
1377406
    lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2388
2389
1377406
    lc->boundary_flags = 0;
2390
1377406
    if (s->ps.pps->tiles_enabled_flag) {
2391

271890
        if (x_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2392
30253
            lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2393

271890
        if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2394
3649
            lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2395

271890
        if (y_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->ps.sps->ctb_width]])
2396
33061
            lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2397

271890
        if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2398
13770
            lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2399
    } else {
2400
1105516
        if (ctb_addr_in_slice <= 0)
2401
17551
            lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2402
1105516
        if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2403
183824
            lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2404
    }
2405
2406

1377406
    lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2407

1377406
    lc->ctb_up_flag   = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2408

1377406
    lc->ctb_up_right_flag = ((y_ctb > 0)  && (ctb_addr_in_slice+1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->ps.sps->ctb_width]]));
2409


1377406
    lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0)  && (ctb_addr_in_slice-1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->ps.sps->ctb_width]]));
2410
1377406
}
2411
2412
27461
static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2413
{
2414
27461
    HEVCContext *s  = avctxt->priv_data;
2415
27461
    int ctb_size    = 1 << s->ps.sps->log2_ctb_size;
2416
27461
    int more_data   = 1;
2417
27461
    int x_ctb       = 0;
2418
27461
    int y_ctb       = 0;
2419
27461
    int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2420
    int ret;
2421
2422

27461
    if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2423
        av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2424
        return AVERROR_INVALIDDATA;
2425
    }
2426
2427
27461
    if (s->sh.dependent_slice_segment_flag) {
2428
7947
        int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2429
7947
        if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2430
            av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2431
            return AVERROR_INVALIDDATA;
2432
        }
2433
    }
2434
2435

1404866
    while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2436
1377406
        int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2437
2438
1377406
        x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2439
1377406
        y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2440
1377406
        hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2441
2442
1377406
        ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2443
1377406
        if (ret < 0) {
2444
            s->tab_slice_address[ctb_addr_rs] = -1;
2445
            return ret;
2446
        }
2447
2448
1377406
        hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2449
2450
1377406
        s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2451
1377406
        s->deblock[ctb_addr_rs].tc_offset   = s->sh.tc_offset;
2452
1377406
        s->filter_slice_edges[ctb_addr_rs]  = s->sh.slice_loop_filter_across_slices_enabled_flag;
2453
2454
1377406
        more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2455
1377406
        if (more_data < 0) {
2456
1
            s->tab_slice_address[ctb_addr_rs] = -1;
2457
1
            return more_data;
2458
        }
2459
2460
2461
1377405
        ctb_addr_ts++;
2462
1377405
        ff_hevc_save_states(s, ctb_addr_ts);
2463
1377405
        ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2464
    }
2465
2466
27460
    if (x_ctb + ctb_size >= s->ps.sps->width &&
2467
13954
        y_ctb + ctb_size >= s->ps.sps->height)
2468
9479
        ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2469
2470
27460
    return ctb_addr_ts;
2471
}
2472
2473
27461
static int hls_slice_data(HEVCContext *s)
2474
{
2475
    int arg[2];
2476
    int ret[2];
2477
2478
27461
    arg[0] = 0;
2479
27461
    arg[1] = 1;
2480
2481
27461
    s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2482
27461
    return ret[0];
2483
}
2484
static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2485
{
2486
    HEVCContext *s1  = avctxt->priv_data, *s;
2487
    HEVCLocalContext *lc;
2488
    int ctb_size    = 1<< s1->ps.sps->log2_ctb_size;
2489
    int more_data   = 1;
2490
    int *ctb_row_p    = input_ctb_row;
2491
    int ctb_row = ctb_row_p[job];
2492
    int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->ps.sps->width + ctb_size - 1) >> s1->ps.sps->log2_ctb_size);
2493
    int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2494
    int thread = ctb_row % s1->threads_number;
2495
    int ret;
2496
2497
    s = s1->sList[self_id];
2498
    lc = s->HEVClc;
2499
2500
    if(ctb_row) {
2501
        ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2502
        if (ret < 0)
2503
            goto error;
2504
        ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2505
    }
2506
2507
    while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2508
        int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2509
        int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2510
2511
        hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2512
2513
        ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2514
2515
        if (atomic_load(&s1->wpp_err)) {
2516
            ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2517
            return 0;
2518
        }
2519
2520
        ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2521
        if (ret < 0)
2522
            goto error;
2523
        hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2524
        more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2525
2526
        if (more_data < 0) {
2527
            ret = more_data;
2528
            goto error;
2529
        }
2530
2531
        ctb_addr_ts++;
2532
2533
        ff_hevc_save_states(s, ctb_addr_ts);
2534
        ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2535
        ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2536
2537
        if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2538
            atomic_store(&s1->wpp_err, 1);
2539
            ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2540
            return 0;
2541
        }
2542
2543
        if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2544
            ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2545
            ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2546
            return ctb_addr_ts;
2547
        }
2548
        ctb_addr_rs       = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2549
        x_ctb+=ctb_size;
2550
2551
        if(x_ctb >= s->ps.sps->width) {
2552
            break;
2553
        }
2554
    }
2555
    ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2556
2557
    return 0;
2558
error:
2559
    s->tab_slice_address[ctb_addr_rs] = -1;
2560
    atomic_store(&s1->wpp_err, 1);
2561
    ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2562
    return ret;
2563
}
2564
2565
static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2566
{
2567
    const uint8_t *data = nal->data;
2568
    int length          = nal->size;
2569
    HEVCLocalContext *lc = s->HEVClc;
2570
    int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2571
    int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2572
    int64_t offset;
2573
    int64_t startheader, cmpt = 0;
2574
    int i, j, res = 0;
2575
2576
    if (!ret || !arg) {
2577
        av_free(ret);
2578
        av_free(arg);
2579
        return AVERROR(ENOMEM);
2580
    }
2581
2582
    if (s->sh.slice_ctb_addr_rs + s->sh.num_entry_point_offsets * s->ps.sps->ctb_width >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
2583
        av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2584
            s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2585
            s->ps.sps->ctb_width, s->ps.sps->ctb_height
2586
        );
2587
        res = AVERROR_INVALIDDATA;
2588
        goto error;
2589
    }
2590
2591
    ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2592
2593
    if (!s->sList[1]) {
2594
        for (i = 1; i < s->threads_number; i++) {
2595
            s->sList[i] = av_malloc(sizeof(HEVCContext));
2596
            memcpy(s->sList[i], s, sizeof(HEVCContext));
2597
            s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2598
            s->sList[i]->HEVClc = s->HEVClcList[i];
2599
        }
2600
    }
2601
2602
    offset = (lc->gb.index >> 3);
2603
2604
    for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2605
        if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2606
            startheader--;
2607
            cmpt++;
2608
        }
2609
    }
2610
2611
    for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2612
        offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2613
        for (j = 0, cmpt = 0, startheader = offset
2614
             + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2615
            if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2616
                startheader--;
2617
                cmpt++;
2618
            }
2619
        }
2620
        s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2621
        s->sh.offset[i - 1] = offset;
2622
2623
    }
2624
    if (s->sh.num_entry_point_offsets != 0) {
2625
        offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2626
        if (length < offset) {
2627
            av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2628
            res = AVERROR_INVALIDDATA;
2629
            goto error;
2630
        }
2631
        s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2632
        s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2633
2634
    }
2635
    s->data = data;
2636
2637
    for (i = 1; i < s->threads_number; i++) {
2638
        s->sList[i]->HEVClc->first_qp_group = 1;
2639
        s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2640
        memcpy(s->sList[i], s, sizeof(HEVCContext));
2641
        s->sList[i]->HEVClc = s->HEVClcList[i];
2642
    }
2643
2644
    atomic_store(&s->wpp_err, 0);
2645
    ff_reset_entries(s->avctx);
2646
2647
    for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2648
        arg[i] = i;
2649
        ret[i] = 0;
2650
    }
2651
2652
    if (s->ps.pps->entropy_coding_sync_enabled_flag)
2653
        s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2654
2655
    for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2656
        res += ret[i];
2657
error:
2658
    av_free(ret);
2659
    av_free(arg);
2660
    return res;
2661
}
2662
2663
9480
static int set_side_data(HEVCContext *s)
2664
{
2665
9480
    AVFrame *out = s->ref->frame;
2666
2667
9480
    if (s->sei.frame_packing.present &&
2668
        s->sei.frame_packing.arrangement_type >= 3 &&
2669
        s->sei.frame_packing.arrangement_type <= 5 &&
2670
        s->sei.frame_packing.content_interpretation_type > 0 &&
2671
        s->sei.frame_packing.content_interpretation_type < 3) {
2672
        AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2673
        if (!stereo)
2674
            return AVERROR(ENOMEM);
2675
2676
        switch (s->sei.frame_packing.arrangement_type) {
2677
        case 3:
2678
            if (s->sei.frame_packing.quincunx_subsampling)
2679
                stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2680
            else
2681
                stereo->type = AV_STEREO3D_SIDEBYSIDE;
2682
            break;
2683
        case 4:
2684
            stereo->type = AV_STEREO3D_TOPBOTTOM;
2685
            break;
2686
        case 5:
2687
            stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2688
            break;
2689
        }
2690
2691
        if (s->sei.frame_packing.content_interpretation_type == 2)
2692
            stereo->flags = AV_STEREO3D_FLAG_INVERT;
2693
2694
        if (s->sei.frame_packing.arrangement_type == 5) {
2695
            if (s->sei.frame_packing.current_frame_is_frame0_flag)
2696
                stereo->view = AV_STEREO3D_VIEW_LEFT;
2697
            else
2698
                stereo->view = AV_STEREO3D_VIEW_RIGHT;
2699
        }
2700
    }
2701
2702
9480
    if (s->sei.display_orientation.present &&
2703
        (s->sei.display_orientation.anticlockwise_rotation ||
2704
         s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) {
2705
        double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16);
2706
        AVFrameSideData *rotation = av_frame_new_side_data(out,
2707
                                                           AV_FRAME_DATA_DISPLAYMATRIX,
2708
                                                           sizeof(int32_t) * 9);
2709
        if (!rotation)
2710
            return AVERROR(ENOMEM);
2711
2712
        av_display_rotation_set((int32_t *)rotation->data, angle);
2713
        av_display_matrix_flip((int32_t *)rotation->data,
2714
                               s->sei.display_orientation.hflip,
2715
                               s->sei.display_orientation.vflip);
2716
    }
2717
2718
    // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2719
    // so the side data persists for the entire coded video sequence.
2720
9480
    if (s->sei.mastering_display.present > 0 &&
2721
        IS_IRAP(s) && s->no_rasl_output_flag) {
2722
        s->sei.mastering_display.present--;
2723
    }
2724
9480
    if (s->sei.mastering_display.present) {
2725
        // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2726
        const int mapping[3] = {2, 0, 1};
2727
        const int chroma_den = 50000;
2728
        const int luma_den = 10000;
2729
        int i;
2730
        AVMasteringDisplayMetadata *metadata =
2731
            av_mastering_display_metadata_create_side_data(out);
2732
        if (!metadata)
2733
            return AVERROR(ENOMEM);
2734
2735
        for (i = 0; i < 3; i++) {
2736
            const int j = mapping[i];
2737
            metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0];
2738
            metadata->display_primaries[i][0].den = chroma_den;
2739
            metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1];
2740
            metadata->display_primaries[i][1].den = chroma_den;
2741
        }
2742
        metadata->white_point[0].num = s->sei.mastering_display.white_point[0];
2743
        metadata->white_point[0].den = chroma_den;
2744
        metadata->white_point[1].num = s->sei.mastering_display.white_point[1];
2745
        metadata->white_point[1].den = chroma_den;
2746
2747
        metadata->max_luminance.num = s->sei.mastering_display.max_luminance;
2748
        metadata->max_luminance.den = luma_den;
2749
        metadata->min_luminance.num = s->sei.mastering_display.min_luminance;
2750
        metadata->min_luminance.den = luma_den;
2751
        metadata->has_luminance = 1;
2752
        metadata->has_primaries = 1;
2753
2754
        av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2755
        av_log(s->avctx, AV_LOG_DEBUG,
2756
               "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2757
               av_q2d(metadata->display_primaries[0][0]),
2758
               av_q2d(metadata->display_primaries[0][1]),
2759
               av_q2d(metadata->display_primaries[1][0]),
2760
               av_q2d(metadata->display_primaries[1][1]),
2761
               av_q2d(metadata->display_primaries[2][0]),
2762
               av_q2d(metadata->display_primaries[2][1]),
2763
               av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2764
        av_log(s->avctx, AV_LOG_DEBUG,
2765
               "min_luminance=%f, max_luminance=%f\n",
2766
               av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2767
    }
2768
    // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2769
    // so the side data persists for the entire coded video sequence.
2770
9480
    if (s->sei.content_light.present > 0 &&
2771
        IS_IRAP(s) && s->no_rasl_output_flag) {
2772
        s->sei.content_light.present--;
2773
    }
2774
9480
    if (s->sei.content_light.present) {
2775
        AVContentLightMetadata *metadata =
2776
            av_content_light_metadata_create_side_data(out);
2777
        if (!metadata)
2778
            return AVERROR(ENOMEM);
2779
        metadata->MaxCLL  = s->sei.content_light.max_content_light_level;
2780
        metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level;
2781
2782
        av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
2783
        av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
2784
               metadata->MaxCLL, metadata->MaxFALL);
2785
    }
2786
2787
9480
    if (s->sei.a53_caption.buf_ref) {
2788
        HEVCSEIA53Caption *a53 = &s->sei.a53_caption;
2789
2790
        AVFrameSideData *sd = av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_A53_CC, a53->buf_ref);
2791
        if (!sd)
2792
            av_buffer_unref(&a53->buf_ref);
2793
        a53->buf_ref = NULL;
2794
2795
        s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2796
    }
2797
2798
9480
    return 0;
2799
}
2800
2801
9480
static int hevc_frame_start(HEVCContext *s)
2802
{
2803
9480
    HEVCLocalContext *lc = s->HEVClc;
2804
9480
    int pic_size_in_ctb  = ((s->ps.sps->width  >> s->ps.sps->log2_min_cb_size) + 1) *
2805
9480
                           ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2806
    int ret;
2807
2808
9480
    memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2809
9480
    memset(s->vertical_bs,   0, s->bs_width * s->bs_height);
2810
9480
    memset(s->cbf_luma,      0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2811
9480
    memset(s->is_pcm,        0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2812
9480
    memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2813
2814
9480
    s->is_decoded        = 0;
2815
9480
    s->first_nal_type    = s->nal_unit_type;
2816
2817



9480
    s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2818
2819
9480
    if (s->ps.pps->tiles_enabled_flag)
2820
620
        lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2821
2822
9480
    ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2823
9480
    if (ret < 0)
2824
        goto fail;
2825
2826
9480
    ret = ff_hevc_frame_rps(s);
2827
9480
    if (ret < 0) {
2828
        av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2829
        goto fail;
2830
    }
2831
2832

9480
    s->ref->frame->key_frame = IS_IRAP(s);
2833
2834
9480
    ret = set_side_data(s);
2835
9480
    if (ret < 0)
2836
        goto fail;
2837
2838
9480
    s->frame->pict_type = 3 - s->sh.slice_type;
2839
2840

9480
    if (!IS_IRAP(s))
2841
8949
        ff_hevc_bump_frame(s);
2842
2843
9480
    av_frame_unref(s->output_frame);
2844
9480
    ret = ff_hevc_output_frame(s, s->output_frame, 0);
2845
9480
    if (ret < 0)
2846
        goto fail;
2847
2848
9480
    if (!s->avctx->hwaccel)
2849
9480
        ff_thread_finish_setup(s->avctx);
2850
2851
9480
    return 0;
2852
2853
fail:
2854
    if (s->ref)
2855
        ff_hevc_unref_frame(s, s->ref, ~0);
2856
    s->ref = NULL;
2857
    return ret;
2858
}
2859
2860
37746
static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2861
{
2862
37746
    HEVCLocalContext *lc = s->HEVClc;
2863
37746
    GetBitContext *gb    = &lc->gb;
2864
    int ctb_addr_ts, ret;
2865
2866
37746
    *gb              = nal->gb;
2867
37746
    s->nal_unit_type = nal->type;
2868
37746
    s->temporal_id   = nal->temporal_id;
2869
2870


37746
    switch (s->nal_unit_type) {
2871
396
    case HEVC_NAL_VPS:
2872

396
        if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2873
            ret = s->avctx->hwaccel->decode_params(s->avctx,
2874
                                                   nal->type,
2875
                                                   nal->raw_data,
2876
                                                   nal->raw_size);
2877
            if (ret < 0)
2878
                goto fail;
2879
        }
2880
396
        ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2881
396
        if (ret < 0)
2882
            goto fail;
2883
396
        break;
2884
393
    case HEVC_NAL_SPS:
2885

393
        if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2886
            ret = s->avctx->hwaccel->decode_params(s->avctx,
2887
                                                   nal->type,
2888
                                                   nal->raw_data,
2889
                                                   nal->raw_size);
2890
            if (ret < 0)
2891
                goto fail;
2892
        }
2893
393
        ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2894
                                     s->apply_defdispwin);
2895
393
        if (ret < 0)
2896
            goto fail;
2897
393
        break;
2898
1351
    case HEVC_NAL_PPS:
2899

1351
        if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2900
            ret = s->avctx->hwaccel->decode_params(s->avctx,
2901
                                                   nal->type,
2902
                                                   nal->raw_data,
2903
                                                   nal->raw_size);
2904
            if (ret < 0)
2905
                goto fail;
2906
        }
2907
1351
        ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2908
1351
        if (ret < 0)
2909
2
            goto fail;
2910
1349
        break;
2911
7466
    case HEVC_NAL_SEI_PREFIX:
2912
    case HEVC_NAL_SEI_SUFFIX:
2913

7466
        if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2914
            ret = s->avctx->hwaccel->decode_params(s->avctx,
2915
                                                   nal->type,
2916
                                                   nal->raw_data,
2917
                                                   nal->raw_size);
2918
            if (ret < 0)
2919
                goto fail;
2920
        }
2921
7466
        ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
2922
7466
        if (ret < 0)
2923
22
            goto fail;
2924
7444
        break;
2925
27513
    case HEVC_NAL_TRAIL_R:
2926
    case HEVC_NAL_TRAIL_N:
2927
    case HEVC_NAL_TSA_N:
2928
    case HEVC_NAL_TSA_R:
2929
    case HEVC_NAL_STSA_N:
2930
    case HEVC_NAL_STSA_R:
2931
    case HEVC_NAL_BLA_W_LP:
2932
    case HEVC_NAL_BLA_W_RADL:
2933
    case HEVC_NAL_BLA_N_LP:
2934
    case HEVC_NAL_IDR_W_RADL:
2935
    case HEVC_NAL_IDR_N_LP:
2936
    case HEVC_NAL_CRA_NUT:
2937
    case HEVC_NAL_RADL_N:
2938
    case HEVC_NAL_RADL_R:
2939
    case HEVC_NAL_RASL_N:
2940
    case HEVC_NAL_RASL_R:
2941
27513
        ret = hls_slice_header(s);
2942
27513
        if (ret < 0)
2943
22
            return ret;
2944
27491
        if (ret == 1) {
2945
1
            ret = AVERROR_INVALIDDATA;
2946
1
            goto fail;
2947
        }
2948
2949
2950
27490
        if (
2951

27490
            (s->avctx->skip_frame >= AVDISCARD_BIDIR && s->sh.slice_type == HEVC_SLICE_B) ||
2952

27490
            (s->avctx->skip_frame >= AVDISCARD_NONINTRA && s->sh.slice_type != HEVC_SLICE_I) ||
2953

27490
            (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IRAP(s))) {
2954
            break;
2955
        }
2956
2957
27490
        if (s->sh.first_slice_in_pic_flag) {
2958
9509
            if (s->max_ra == INT_MAX) {
2959


386
                if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2960
18
                    s->max_ra = s->poc;
2961
                } else {
2962

368
                    if (IS_IDR(s))
2963
368
                        s->max_ra = INT_MIN;
2964
                }
2965
            }
2966
2967

9509
            if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2968
829
                s->poc <= s->max_ra) {
2969
29
                s->is_decoded = 0;
2970
29
                break;
2971
            } else {
2972

9480
                if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2973
463
                    s->max_ra = INT_MIN;
2974
            }
2975
2976
9480
            s->overlap ++;
2977
9480
            ret = hevc_frame_start(s);
2978
9480
            if (ret < 0)
2979
                return ret;
2980
17981
        } else if (!s->ref) {
2981
            av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2982
            goto fail;
2983
        }
2984
2985
27461
        if (s->nal_unit_type != s->first_nal_type) {
2986
            av_log(s->avctx, AV_LOG_ERROR,
2987
                   "Non-matching NAL types of the VCL NALUs: %d %d\n",
2988
                   s->first_nal_type, s->nal_unit_type);
2989
            return AVERROR_INVALIDDATA;
2990
        }
2991
2992
27461
        if (!s->sh.dependent_slice_segment_flag &&
2993
19514
            s->sh.slice_type != HEVC_SLICE_I) {
2994
18398
            ret = ff_hevc_slice_rpl(s);
2995
18398
            if (ret < 0) {
2996
                av_log(s->avctx, AV_LOG_WARNING,
2997
                       "Error constructing the reference lists for the current slice.\n");
2998
                goto fail;
2999
            }
3000
        }
3001
3002

27461
        if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
3003
            ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
3004
            if (ret < 0)
3005
                goto fail;
3006
        }
3007
3008
27461
        if (s->avctx->hwaccel) {
3009
            ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
3010
            if (ret < 0)
3011
                goto fail;
3012
        } else {
3013

27461
            if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
3014
                ctb_addr_ts = hls_slice_data_wpp(s, nal);
3015
            else
3016
27461
                ctb_addr_ts = hls_slice_data(s);
3017
27461
            if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
3018
9479
                s->is_decoded = 1;
3019
            }
3020
3021
27461
            if (ctb_addr_ts < 0) {
3022
1
                ret = ctb_addr_ts;
3023
1
                goto fail;
3024
            }
3025
        }
3026
27460
        break;
3027
4
    case HEVC_NAL_EOS_NUT:
3028
    case HEVC_NAL_EOB_NUT:
3029
4
        s->seq_decode = (s->seq_decode + 1) & 0xff;
3030
4
        s->max_ra     = INT_MAX;
3031
4
        break;
3032
623
    case HEVC_NAL_AUD:
3033
    case HEVC_NAL_FD_NUT:
3034
623
        break;
3035
    default:
3036
        av_log(s->avctx, AV_LOG_INFO,
3037
               "Skipping NAL unit %d\n", s->nal_unit_type);
3038
    }
3039
3040
37698
    return 0;
3041
26
fail:
3042
26
    if (s->avctx->err_recognition & AV_EF_EXPLODE)
3043
        return ret;
3044
26
    return 0;
3045
}
3046
3047
9532
static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
3048
{
3049
9532
    int i, ret = 0;
3050
9532
    int eos_at_start = 1;
3051
3052
9532
    s->ref = NULL;
3053
9532
    s->last_eos = s->eos;
3054
9532
    s->eos = 0;
3055
9532
    s->overlap = 0;
3056
3057
    /* split the input packet into NAL units, so we know the upper bound on the
3058
     * number of slices in the frame */
3059
9532
    ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
3060
9532
                                s->nal_length_size, s->avctx->codec_id, 1, 0);
3061
9532
    if (ret < 0) {
3062
        av_log(s->avctx, AV_LOG_ERROR,
3063
               "Error splitting the input into NAL units.\n");
3064
        return ret;
3065
    }
3066
3067
47278
    for (i = 0; i < s->pkt.nb_nals; i++) {
3068
37746
        if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
3069
37745
            s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
3070
4
            if (eos_at_start) {
3071
4
                s->last_eos = 1;
3072
            } else {
3073
                s->eos = 1;
3074
            }
3075
        } else {
3076
37742
            eos_at_start = 0;
3077
        }
3078
    }
3079
3080
    /* decode the NAL units */
3081
47256
    for (i = 0; i < s->pkt.nb_nals; i++) {
3082
37746
        H2645NAL *nal = &s->pkt.nals[i];
3083
3084
37746
        if (s->avctx->skip_frame >= AVDISCARD_ALL ||
3085
37746
            (s->avctx->skip_frame >= AVDISCARD_NONREF
3086

37746
            && ff_hevc_nal_is_nonref(nal->type)) || nal->nuh_layer_id > 0)
3087
            continue;
3088
3089
37746
        ret = decode_nal_unit(s, nal);
3090

37746
        if (ret >= 0 && s->overlap > 2)
3091
            ret = AVERROR_INVALIDDATA;
3092
37746
        if (ret < 0) {
3093
22
            av_log(s->avctx, AV_LOG_WARNING,
3094
                   "Error parsing NAL unit #%d.\n", i);
3095
22
            goto fail;
3096
        }
3097
    }
3098
3099
9510
fail:
3100

9532
    if (s->ref && s->threads_type == FF_THREAD_FRAME)
3101
32
        ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3102
3103
9532
    return ret;
3104
}
3105
3106
static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3107
{
3108
    int i;
3109
    for (i = 0; i < 16; i++)
3110
        av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3111
}
3112
3113
static int verify_md5(HEVCContext *s, AVFrame *frame)
3114
{
3115
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3116
    int pixel_shift;
3117
    int i, j;
3118
3119
    if (!desc)
3120
        return AVERROR(EINVAL);
3121
3122
    pixel_shift = desc->comp[0].depth > 8;
3123
3124
    av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3125
           s->poc);
3126
3127
    /* the checksums are LE, so we have to byteswap for >8bpp formats
3128
     * on BE arches */
3129
#if HAVE_BIGENDIAN
3130
    if (pixel_shift && !s->checksum_buf) {
3131
        av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3132
                       FFMAX3(frame->linesize[0], frame->linesize[1],
3133
                              frame->linesize[2]));
3134
        if (!s->checksum_buf)
3135
            return AVERROR(ENOMEM);
3136
    }
3137
#endif
3138
3139
    for (i = 0; frame->data[i]; i++) {
3140
        int width  = s->avctx->coded_width;
3141
        int height = s->avctx->coded_height;
3142
        int w = (i == 1 || i == 2) ? (width  >> desc->log2_chroma_w) : width;
3143
        int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3144
        uint8_t md5[16];
3145
3146
        av_md5_init(s->md5_ctx);
3147
        for (j = 0; j < h; j++) {
3148
            const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3149
#if HAVE_BIGENDIAN
3150
            if (pixel_shift) {
3151
                s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3152
                                    (const uint16_t *) src, w);
3153
                src = s->checksum_buf;
3154
            }
3155
#endif
3156
            av_md5_update(s->md5_ctx, src, w << pixel_shift);
3157
        }
3158
        av_md5_final(s->md5_ctx, md5);
3159
3160
        if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3161
            av_log   (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3162
            print_md5(s->avctx, AV_LOG_DEBUG, md5);
3163
            av_log   (s->avctx, AV_LOG_DEBUG, "; ");
3164
        } else {
3165
            av_log   (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3166
            print_md5(s->avctx, AV_LOG_ERROR, md5);
3167
            av_log   (s->avctx, AV_LOG_ERROR, " != ");
3168
            print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
3169
            av_log   (s->avctx, AV_LOG_ERROR, "\n");
3170
            return AVERROR_INVALIDDATA;
3171
        }
3172
    }
3173
3174
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
3175
3176
    return 0;
3177
}
3178
3179
178
static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3180
{
3181
    int ret, i;
3182
3183
178
    ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
3184
178
                                   &s->nal_length_size, s->avctx->err_recognition,
3185
178
                                   s->apply_defdispwin, s->avctx);
3186
178
    if (ret < 0)
3187
        return ret;
3188
3189
    /* export stream parameters from the first SPS */
3190
210
    for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3191

208
        if (first && s->ps.sps_list[i]) {
3192
176
            const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3193
176
            export_stream_params(s, sps);
3194
176
            break;
3195
        }
3196
    }
3197
3198
178
    return 0;
3199
}
3200
3201
10000
static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3202
                             AVPacket *avpkt)
3203
{
3204
    int ret;
3205
    int new_extradata_size;
3206
    uint8_t *new_extradata;
3207
10000
    HEVCContext *s = avctx->priv_data;
3208
3209
10000
    if (!avpkt->size) {
3210
468
        ret = ff_hevc_output_frame(s, data, 1);
3211
468
        if (ret < 0)
3212
            return ret;
3213
3214
468
        *got_output = ret;
3215
468
        return 0;
3216
    }
3217
3218
9532
    new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3219
                                            &new_extradata_size);
3220

9532
    if (new_extradata && new_extradata_size > 0) {
3221
1
        ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
3222
1
        if (ret < 0)
3223
            return ret;
3224
    }
3225
3226
9532
    s->ref = NULL;
3227
9532
    ret    = decode_nal_units(s, avpkt->data, avpkt->size);
3228