GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/hevcdec.c Lines: 1738 2182 79.7 %
Date: 2020-09-21 17:35:45 Branches: 1257 1663 75.6 %

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
#include "libavutil/timecode.h"
36
37
#include "bswapdsp.h"
38
#include "bytestream.h"
39
#include "cabac_functions.h"
40
#include "golomb.h"
41
#include "hevc.h"
42
#include "hevc_data.h"
43
#include "hevc_parse.h"
44
#include "hevcdec.h"
45
#include "hwconfig.h"
46
#include "profiles.h"
47
48
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 };
49
50
/**
51
 * NOTE: Each function hls_foo correspond to the function foo in the
52
 * specification (HLS stands for High Level Syntax).
53
 */
54
55
/**
56
 * Section 5.7
57
 */
58
59
/* free everything allocated  by pic_arrays_init() */
60
735
static void pic_arrays_free(HEVCContext *s)
61
{
62
735
    av_freep(&s->sao);
63
735
    av_freep(&s->deblock);
64
65
735
    av_freep(&s->skip_flag);
66
735
    av_freep(&s->tab_ct_depth);
67
68
735
    av_freep(&s->tab_ipm);
69
735
    av_freep(&s->cbf_luma);
70
735
    av_freep(&s->is_pcm);
71
72
735
    av_freep(&s->qp_y_tab);
73
735
    av_freep(&s->tab_slice_address);
74
735
    av_freep(&s->filter_slice_edges);
75
76
735
    av_freep(&s->horizontal_bs);
77
735
    av_freep(&s->vertical_bs);
78
79
735
    av_freep(&s->sh.entry_point_offset);
80
735
    av_freep(&s->sh.size);
81
735
    av_freep(&s->sh.offset);
82
83
735
    av_buffer_pool_uninit(&s->tab_mvf_pool);
84
735
    av_buffer_pool_uninit(&s->rpl_tab_pool);
85
735
}
86
87
/* allocate arrays that depend on frame dimensions */
88
368
static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
89
{
90
368
    int log2_min_cb_size = sps->log2_min_cb_size;
91
368
    int width            = sps->width;
92
368
    int height           = sps->height;
93
368
    int pic_size_in_ctb  = ((width  >> log2_min_cb_size) + 1) *
94
368
                           ((height >> log2_min_cb_size) + 1);
95
368
    int ctb_count        = sps->ctb_width * sps->ctb_height;
96
368
    int min_pu_size      = sps->min_pu_width * sps->min_pu_height;
97
98
368
    s->bs_width  = (width  >> 2) + 1;
99
368
    s->bs_height = (height >> 2) + 1;
100
101
368
    s->sao           = av_mallocz_array(ctb_count, sizeof(*s->sao));
102
368
    s->deblock       = av_mallocz_array(ctb_count, sizeof(*s->deblock));
103

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

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

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

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

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

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

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

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

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

472
                        || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
242
                        return AVERROR_INVALIDDATA;
243
                    }
244
245
472
                    s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
246
472
                    s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
247
472
                                                                                        >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
248
                }
249
            } else {
250
1020
                s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
251
1020
                s->sh.chroma_offset_l1[i][0] = 0;
252
1020
                s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
253
1020
                s->sh.chroma_offset_l1[i][1] = 0;
254
            }
255
        }
256
    }
257
1350
    return 0;
258
}
259
260
18961
static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
261
{
262
18961
    const HEVCSPS *sps = s->ps.sps;
263
18961
    int max_poc_lsb    = 1 << sps->log2_max_poc_lsb;
264
18961
    int prev_delta_msb = 0;
265
18961
    unsigned int nb_sps = 0, nb_sh;
266
    int i;
267
268
18961
    rps->nb_refs = 0;
269
18961
    if (!sps->long_term_ref_pics_present_flag)
270
17927
        return 0;
271
272
1034
    if (sps->num_long_term_ref_pics_sps > 0)
273
499
        nb_sps = get_ue_golomb_long(gb);
274
1034
    nb_sh = get_ue_golomb_long(gb);
275
276
1034
    if (nb_sps > sps->num_long_term_ref_pics_sps)
277
        return AVERROR_INVALIDDATA;
278
1034
    if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
279
        return AVERROR_INVALIDDATA;
280
281
1034
    rps->nb_refs = nb_sh + nb_sps;
282
283
2594
    for (i = 0; i < rps->nb_refs; i++) {
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
        rps->poc_msb_present[i] = get_bits1(gb);
299
1560
        if (rps->poc_msb_present[i]) {
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
    avctx->chroma_sample_location = AVCHROMA_LOC_UNSPECIFIED;
353
544
    if (sps->chroma_format_idc == 1) {
354
506
        if (sps->vui.chroma_loc_info_present_flag) {
355
4
            if (sps->vui.chroma_sample_loc_type_top_field <= 5)
356
4
                avctx->chroma_sample_location = sps->vui.chroma_sample_loc_type_top_field + 1;
357
        } else
358
502
            avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
359
    }
360
361
544
    if (vps->vps_timing_info_present_flag) {
362
20
        num = vps->vps_num_units_in_tick;
363
20
        den = vps->vps_time_scale;
364
524
    } else if (sps->vui.vui_timing_info_present_flag) {
365
24
        num = sps->vui.vui_num_units_in_tick;
366
24
        den = sps->vui.vui_time_scale;
367
    }
368
369

544
    if (num != 0 && den != 0)
370
44
        av_reduce(&avctx->framerate.den, &avctx->framerate.num,
371
                  num, den, 1 << 30);
372
373

544
    if (s->sei.alternative_transfer.present &&
374
        av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
375
        s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
376
        avctx->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
377
    }
378
544
}
379
380
367
static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
381
{
382
#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
383
                     CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
384
                     CONFIG_HEVC_NVDEC_HWACCEL + \
385
                     CONFIG_HEVC_VAAPI_HWACCEL + \
386
                     CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
387
                     CONFIG_HEVC_VDPAU_HWACCEL)
388
367
    enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
389
390

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

368
    if (sps->sao_enabled && !s->avctx->hwaccel) {
496
315
        int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
497
        int c_idx;
498
499
1256
        for(c_idx = 0; c_idx < c_count; c_idx++) {
500
941
            int w = sps->width >> sps->hshift[c_idx];
501
941
            int h = sps->height >> sps->vshift[c_idx];
502
941
            s->sao_pixel_buffer_h[c_idx] =
503
941
                av_malloc((w * 2 * sps->ctb_height) <<
504
941
                          sps->pixel_shift);
505
941
            s->sao_pixel_buffer_v[c_idx] =
506
941
                av_malloc((h * 2 * sps->ctb_width) <<
507
941
                          sps->pixel_shift);
508
        }
509
    }
510
511
368
    s->ps.sps = sps;
512
368
    s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
513
514
368
    return 0;
515
516
fail:
517
    pic_arrays_free(s);
518
    s->ps.sps = NULL;
519
    return ret;
520
}
521
522
27513
static int hls_slice_header(HEVCContext *s)
523
{
524
27513
    GetBitContext *gb = &s->HEVClc->gb;
525
27513
    SliceHeader *sh   = &s->sh;
526
    int i, ret;
527
528
    // Coded parameters
529
27513
    sh->first_slice_in_pic_flag = get_bits1(gb);
530

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



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

378
        if (IS_IDR(s))
539
368
            ff_hevc_clear_refs(s);
540
    }
541
27512
    sh->no_output_of_prior_pics_flag = 0;
542

27512
    if (IS_IRAP(s))
543
1254
        sh->no_output_of_prior_pics_flag = get_bits1(gb);
544
545
27512
    sh->pps_id = get_ue_golomb_long(gb);
546

27512
    if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
547
22
        av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
548
22
        return AVERROR_INVALIDDATA;
549
    }
550
27490
    if (!sh->first_slice_in_pic_flag &&
551
17981
        s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
552
        av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
553
        return AVERROR_INVALIDDATA;
554
    }
555
27490
    s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
556

27490
    if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
557
6
        sh->no_output_of_prior_pics_flag = 1;
558
559
27490
    if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
560
367
        const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
561
367
        const HEVCSPS *last_sps = s->ps.sps;
562
        enum AVPixelFormat pix_fmt;
563
564


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

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

19543
        if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
627
            av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
628
            return AVERROR_INVALIDDATA;
629
        }
630
631
        // when flag is not present, picture is inferred to be output
632
19543
        sh->pic_output_flag = 1;
633
19543
        if (s->ps.pps->output_flag_present_flag)
634
703
            sh->pic_output_flag = get_bits1(gb);
635
636
19543
        if (s->ps.sps->separate_colour_plane_flag)
637
            sh->colour_plane_id = get_bits(gb, 2);
638
639

38504
        if (!IS_IDR(s)) {
640
            int poc, pos;
641
642
18961
            sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
643
18961
            poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
644

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

19543
        if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
695
9166
            s->nal_unit_type != HEVC_NAL_TRAIL_N &&
696
6707
            s->nal_unit_type != HEVC_NAL_TSA_N   &&
697
6707
            s->nal_unit_type != HEVC_NAL_STSA_N  &&
698
6707
            s->nal_unit_type != HEVC_NAL_RADL_N  &&
699
6685
            s->nal_unit_type != HEVC_NAL_RADL_R  &&
700
6666
            s->nal_unit_type != HEVC_NAL_RASL_N  &&
701
6316
            s->nal_unit_type != HEVC_NAL_RASL_R)
702
5854
            s->pocTid0 = s->poc;
703
704
19543
        if (s->ps.sps->sao_enabled) {
705
16094
            sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
706
16094
            if (s->ps.sps->chroma_format_idc) {
707
16092
                sh->slice_sample_adaptive_offset_flag[1] =
708
16092
                sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
709
            }
710
        } else {
711
3449
            sh->slice_sample_adaptive_offset_flag[0] = 0;
712
3449
            sh->slice_sample_adaptive_offset_flag[1] = 0;
713
3449
            sh->slice_sample_adaptive_offset_flag[2] = 0;
714
        }
715
716
19543
        sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
717

19543
        if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
718
            int nb_refs;
719
720
18427
            sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
721
18427
            if (sh->slice_type == HEVC_SLICE_B)
722
14687
                sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
723
724
18427
            if (get_bits1(gb)) { // num_ref_idx_active_override_flag
725
4860
                sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
726
4860
                if (sh->slice_type == HEVC_SLICE_B)
727
2699
                    sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
728
            }
729

18427
            if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
730
                av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
731
                       sh->nb_refs[L0], sh->nb_refs[L1]);
732
                return AVERROR_INVALIDDATA;
733
            }
734
735
18427
            sh->rpl_modification_flag[0] = 0;
736
18427
            sh->rpl_modification_flag[1] = 0;
737
18427
            nb_refs = ff_hevc_frame_nb_refs(s);
738
18427
            if (!nb_refs) {
739
                av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
740
                return AVERROR_INVALIDDATA;
741
            }
742
743

18427
            if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
744
1596
                sh->rpl_modification_flag[0] = get_bits1(gb);
745
1596
                if (sh->rpl_modification_flag[0]) {
746
3955
                    for (i = 0; i < sh->nb_refs[L0]; i++)
747
2779
                        sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
748
                }
749
750
1596
                if (sh->slice_type == HEVC_SLICE_B) {
751
1596
                    sh->rpl_modification_flag[1] = get_bits1(gb);
752
1596
                    if (sh->rpl_modification_flag[1] == 1)
753
2207
                        for (i = 0; i < sh->nb_refs[L1]; i++)
754
1555
                            sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
755
                }
756
            }
757
758
18427
            if (sh->slice_type == HEVC_SLICE_B)
759
14687
                sh->mvd_l1_zero_flag = get_bits1(gb);
760
761
18427
            if (s->ps.pps->cabac_init_present_flag)
762
15792
                sh->cabac_init_flag = get_bits1(gb);
763
            else
764
2635
                sh->cabac_init_flag = 0;
765
766
18427
            sh->collocated_ref_idx = 0;
767
18427
            if (sh->slice_temporal_mvp_enabled_flag) {
768
16090
                sh->collocated_list = L0;
769
16090
                if (sh->slice_type == HEVC_SLICE_B)
770
14185
                    sh->collocated_list = !get_bits1(gb);
771
772
16090
                if (sh->nb_refs[sh->collocated_list] > 1) {
773
14395
                    sh->collocated_ref_idx = get_ue_golomb_long(gb);
774
14395
                    if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
775
                        av_log(s->avctx, AV_LOG_ERROR,
776
                               "Invalid collocated_ref_idx: %d.\n",
777
                               sh->collocated_ref_idx);
778
                        return AVERROR_INVALIDDATA;
779
                    }
780
                }
781
            }
782
783

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

17660
                (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
785
1350
                int ret = pred_weight_table(s, gb);
786
1350
                if (ret < 0)
787
                    return ret;
788
            }
789
790
18427
            sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
791

18427
            if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
792
                av_log(s->avctx, AV_LOG_ERROR,
793
                       "Invalid number of merging MVP candidates: %d.\n",
794
                       sh->max_num_merge_cand);
795
                return AVERROR_INVALIDDATA;
796
            }
797
        }
798
799
19543
        sh->slice_qp_delta = get_se_golomb(gb);
800
801
19543
        if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
802
250
            sh->slice_cb_qp_offset = get_se_golomb(gb);
803
250
            sh->slice_cr_qp_offset = get_se_golomb(gb);
804
        } else {
805
19293
            sh->slice_cb_qp_offset = 0;
806
19293
            sh->slice_cr_qp_offset = 0;
807
        }
808
809
19543
        if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
810
43
            sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
811
        else
812
19500
            sh->cu_chroma_qp_offset_enabled_flag = 0;
813
814
19543
        if (s->ps.pps->deblocking_filter_control_present_flag) {
815
2829
            int deblocking_filter_override_flag = 0;
816
817
2829
            if (s->ps.pps->deblocking_filter_override_enabled_flag)
818
609
                deblocking_filter_override_flag = get_bits1(gb);
819
820
2829
            if (deblocking_filter_override_flag) {
821
390
                sh->disable_deblocking_filter_flag = get_bits1(gb);
822
390
                if (!sh->disable_deblocking_filter_flag) {
823
270
                    int beta_offset_div2 = get_se_golomb(gb);
824
270
                    int tc_offset_div2   = get_se_golomb(gb) ;
825

270
                    if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
826
270
                        tc_offset_div2   < -6 || tc_offset_div2   > 6) {
827
                        av_log(s->avctx, AV_LOG_ERROR,
828
                            "Invalid deblock filter offsets: %d, %d\n",
829
                            beta_offset_div2, tc_offset_div2);
830
                        return AVERROR_INVALIDDATA;
831
                    }
832
270
                    sh->beta_offset = beta_offset_div2 * 2;
833
270
                    sh->tc_offset   =   tc_offset_div2 * 2;
834
                }
835
            } else {
836
2439
                sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
837
2439
                sh->beta_offset                    = s->ps.pps->beta_offset;
838
2439
                sh->tc_offset                      = s->ps.pps->tc_offset;
839
            }
840
        } else {
841
16714
            sh->disable_deblocking_filter_flag = 0;
842
16714
            sh->beta_offset                    = 0;
843
16714
            sh->tc_offset                      = 0;
844
        }
845
846
19543
        if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
847
17010
            (sh->slice_sample_adaptive_offset_flag[0] ||
848
11403
             sh->slice_sample_adaptive_offset_flag[1] ||
849
11385
             !sh->disable_deblocking_filter_flag)) {
850
16947
            sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
851
        } else {
852
2596
            sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
853
        }
854
7947
    } else if (!s->slice_initialized) {
855
        av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
856
        return AVERROR_INVALIDDATA;
857
    }
858
859
27490
    sh->num_entry_point_offsets = 0;
860

27490
    if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
861
7411
        unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
862
        // It would be possible to bound this tighter but this here is simpler
863
7411
        if (num_entry_point_offsets > get_bits_left(gb)) {
864
            av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
865
            return AVERROR_INVALIDDATA;
866
        }
867
868
7411
        sh->num_entry_point_offsets = num_entry_point_offsets;
869
7411
        if (sh->num_entry_point_offsets > 0) {
870
1945
            int offset_len = get_ue_golomb_long(gb) + 1;
871
872

1945
            if (offset_len < 1 || offset_len > 32) {
873
                sh->num_entry_point_offsets = 0;
874
                av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
875
                return AVERROR_INVALIDDATA;
876
            }
877
878
1945
            av_freep(&sh->entry_point_offset);
879
1945
            av_freep(&sh->offset);
880
1945
            av_freep(&sh->size);
881
1945
            sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
882
1945
            sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
883
1945
            sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
884

1945
            if (!sh->entry_point_offset || !sh->offset || !sh->size) {
885
                sh->num_entry_point_offsets = 0;
886
                av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
887
                return AVERROR(ENOMEM);
888
            }
889
9525
            for (i = 0; i < sh->num_entry_point_offsets; i++) {
890
7580
                unsigned val = get_bits_long(gb, offset_len);
891
7580
                sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
892
            }
893

1945
            if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
894
                s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
895
                s->threads_number = 1;
896
            } else
897
1945
                s->enable_parallel_tiles = 0;
898
        } else
899
5466
            s->enable_parallel_tiles = 0;
900
    }
901
902
27490
    if (s->ps.pps->slice_header_extension_present_flag) {
903
2765
        unsigned int length = get_ue_golomb_long(gb);
904
2765
        if (length*8LL > get_bits_left(gb)) {
905
            av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
906
            return AVERROR_INVALIDDATA;
907
        }
908
23029
        for (i = 0; i < length; i++)
909
20264
            skip_bits(gb, 8);  // slice_header_extension_data_byte
910
    }
911
912
    // Inferred parameters
913
27490
    sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
914
27490
    if (sh->slice_qp > 51 ||
915
27490
        sh->slice_qp < -s->ps.sps->qp_bd_offset) {
916
        av_log(s->avctx, AV_LOG_ERROR,
917
               "The slice_qp %d is outside the valid range "
918
               "[%d, 51].\n",
919
               sh->slice_qp,
920
               -s->ps.sps->qp_bd_offset);
921
        return AVERROR_INVALIDDATA;
922
    }
923
924
27490
    sh->slice_ctb_addr_rs = sh->slice_segment_addr;
925
926

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

579200
        if (ry > 0 && !sao_merge_left_flag) {
978
258412
            if (lc->ctb_up_flag)
979
245064
                sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
980
        }
981
    }
982
983

5509528
    for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
984
4132122
        int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
985
2754716
                                                 s->ps.pps->log2_sao_offset_scale_chroma;
986
987
4132122
        if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
988
2896526
            sao->type_idx[c_idx] = SAO_NOT_APPLIED;
989
2896526
            continue;
990
        }
991
992
1235596
        if (c_idx == 2) {
993
329020
            sao->type_idx[2] = sao->type_idx[1];
994
329020
            sao->eo_class[2] = sao->eo_class[1];
995
        } else {
996


906576
            SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
997
        }
998
999
1235596
        if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
1000
745770
            continue;
1001
1002
2449130
        for (i = 0; i < 4; i++)
1003


1959304
            SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
1004
1005
489826
        if (sao->type_idx[c_idx] == SAO_BAND) {
1006
579285
            for (i = 0; i < 4; i++) {
1007
463428
                if (sao->offset_abs[c_idx][i]) {
1008


350025
                    SET_SAO(offset_sign[c_idx][i],
1009
                            ff_hevc_sao_offset_sign_decode(s));
1010
                } else {
1011
113403
                    sao->offset_sign[c_idx][i] = 0;
1012
                }
1013
            }
1014


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


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

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

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

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

227786
                         (cbf_cb[1] || cbf_cr[1]));
1076
1077

10623650
        if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1078
543293
            lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1079
543293
            if (lc->tu.cu_qp_delta != 0)
1080
353071
                if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1081
194965
                    lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1082
543293
            lc->tu.is_cu_qp_delta_coded = 1;
1083
1084
543293
            if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1085
543292
                lc->tu.cu_qp_delta >  (25 + s->ps.sps->qp_bd_offset / 2)) {
1086
1
                av_log(s->avctx, AV_LOG_ERROR,
1087
                       "The cu_qp_delta %d is outside the valid range "
1088
                       "[%d, %d].\n",
1089
                       lc->tu.cu_qp_delta,
1090
1
                       -(26 + s->ps.sps->qp_bd_offset / 2),
1091
1
                        (25 + s->ps.sps->qp_bd_offset / 2));
1092
1
                return AVERROR_INVALIDDATA;
1093
            }
1094
1095
543292
            ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1096
        }
1097
1098

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

841055
            !lc->cu.cu_transquant_bypass_flag  &&  !lc->tu.is_cu_chroma_qp_offset_coded) {
1100
266275
            int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1101
266275
            if (cu_chroma_qp_offset_flag) {
1102
48966
                int cu_chroma_qp_offset_idx  = 0;
1103
48966
                if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1104
                    cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1105
                    av_log(s->avctx, AV_LOG_ERROR,
1106
                        "cu_chroma_qp_offset_idx not yet tested.\n");
1107
                }
1108
48966
                lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1109
48966
                lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1110
            } else {
1111
217309
                lc->tu.cu_qp_offset_cb = 0;
1112
217309
                lc->tu.cu_qp_offset_cr = 0;
1113
            }
1114
266275
            lc->tu.is_cu_chroma_qp_offset_coded = 1;
1115
        }
1116
1117

10623649
        if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1118
6121592
            if (lc->tu.intra_pred_mode >= 6 &&
1119
4116596
                lc->tu.intra_pred_mode <= 14) {
1120
1491262
                scan_idx = SCAN_VERT;
1121
4630330
            } else if (lc->tu.intra_pred_mode >= 22 &&
1122
2024225
                       lc->tu.intra_pred_mode <= 30) {
1123
1699652
                scan_idx = SCAN_HORIZ;
1124
            }
1125
1126
6121592
            if (lc->tu.intra_pred_mode_c >=  6 &&
1127
3689970
                lc->tu.intra_pred_mode_c <= 14) {
1128
1402714
                scan_idx_c = SCAN_VERT;
1129
4718878
            } else if (lc->tu.intra_pred_mode_c >= 22 &&
1130
1922258
                       lc->tu.intra_pred_mode_c <= 30) {
1131
1607627
                scan_idx_c = SCAN_HORIZ;
1132
            }
1133
        }
1134
1135
10623649
        lc->tu.cross_pf = 0;
1136
1137
10623649
        if (cbf_luma)
1138
9522275
            ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1139

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

5019009
            lc->tu.cross_pf  = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1143
217816
                                (lc->cu.pred_mode == MODE_INTER ||
1144
168873
                                 (lc->tu.chroma_mode_c ==  4)));
1145
1146
4801193
            if (lc->tu.cross_pf) {
1147
192425
                hls_cross_component_pred(s, 0);
1148
            }
1149

9980644
            for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1150
5179451
                if (lc->cu.pred_mode == MODE_INTRA) {
1151
2802211
                    ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1152
2802211
                    s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1153
                }
1154
5179451
                if (cbf_cb[i])
1155
1356651
                    ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1156
                                                log2_trafo_size_c, scan_idx_c, 1);
1157
                else
1158
3822800
                    if (lc->tu.cross_pf) {
1159
39658
                        ptrdiff_t stride = s->frame->linesize[1];
1160
39658
                        int hshift = s->ps.sps->hshift[1];
1161
39658
                        int vshift = s->ps.sps->vshift[1];
1162
39658
                        int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1163
39658
                        int16_t *coeffs   = (int16_t*)lc->edge_emu_buffer2;
1164
39658
                        int size = 1 << log2_trafo_size_c;
1165
1166
39658
                        uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1167
39658
                                                              ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1168
1871162
                        for (i = 0; i < (size * size); i++) {
1169
1831504
                            coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1170
                        }
1171
39658
                        s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1172
                    }
1173
            }
1174
1175
4801193
            if (lc->tu.cross_pf) {
1176
192425
                hls_cross_component_pred(s, 1);
1177
            }
1178

9980644
            for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1179
5179451
                if (lc->cu.pred_mode == MODE_INTRA) {
1180
2802211
                    ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1181
2802211
                    s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1182
                }
1183
5179451
                if (cbf_cr[i])
1184
1483841
                    ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1185
                                                log2_trafo_size_c, scan_idx_c, 2);
1186
                else
1187
3695610
                    if (lc->tu.cross_pf) {
1188
75924
                        ptrdiff_t stride = s->frame->linesize[2];
1189
75924
                        int hshift = s->ps.sps->hshift[2];
1190
75924
                        int vshift = s->ps.sps->vshift[2];
1191
75924
                        int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1192
75924
                        int16_t *coeffs   = (int16_t*)lc->edge_emu_buffer2;
1193
75924
                        int size = 1 << log2_trafo_size_c;
1194
1195
75924
                        uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1196
75924
                                                          ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1197
3691476
                        for (i = 0; i < (size * size); i++) {
1198
3615552
                            coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1199
                        }
1200
75924
                        s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1201
                    }
1202
            }
1203

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

3158445
            for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1207
1662657
                if (lc->cu.pred_mode == MODE_INTRA) {
1208
1182570
                    ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1209
                                                    trafo_size_h, trafo_size_v);
1210
1182570
                    s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1211
                }
1212
1662657
                if (cbf_cb[i])
1213
632269
                    ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1214
                                                log2_trafo_size, scan_idx_c, 1);
1215
            }
1216

3158445
            for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1217
1662657
                if (lc->cu.pred_mode == MODE_INTRA) {
1218
1182570
                    ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1219
                                                trafo_size_h, trafo_size_v);
1220
1182570
                    s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1221
                }
1222
1662657
                if (cbf_cr[i])
1223
713145
                    ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1224
                                                log2_trafo_size, scan_idx_c, 2);
1225
            }
1226
        }
1227

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

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

7950273
        !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1312
6784667
        split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1313
    } else {
1314
24341822
        int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1315
1532966
                          lc->cu.pred_mode == MODE_INTER &&
1316

12937394
                          lc->cu.part_mode != PART_2Nx2N &&
1317
                          trafo_depth == 0;
1318
1319
11404428
        split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1320


11404428
                               (lc->cu.intra_split_flag && trafo_depth == 0) ||
1321
                               inter_split;
1322
    }
1323
1324

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

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

6815531
            if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1328
452048
                cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1329
            }
1330
        }
1331
1332

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

6762539
            if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1335
587469
                cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1336
            }
1337
        }
1338
    }
1339
1340
18189095
    if (split_transform_flag) {
1341
3134749
        const int trafo_size_split = 1 << (log2_trafo_size - 1);
1342
3134749
        const int x1 = x0 + trafo_size_split;
1343
3134749
        const int y1 = y0 + trafo_size_split;
1344
1345
#define SUBDIVIDE(x, y, idx)                                                    \
1346
do {                                                                            \
1347
    ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1348
                             log2_trafo_size - 1, trafo_depth + 1, idx,         \
1349
                             cbf_cb, cbf_cr);                                   \
1350
    if (ret < 0)                                                                \
1351
        return ret;                                                             \
1352
} while (0)
1353
1354
3134749
        SUBDIVIDE(x0, y0, 0);
1355
3134749
        SUBDIVIDE(x1, y0, 1);
1356
3134749
        SUBDIVIDE(x0, y1, 2);
1357
3134749
        SUBDIVIDE(x1, y1, 3);
1358
1359
#undef SUBDIVIDE
1360
    } else {
1361
15054346
        int min_tu_size      = 1 << s->ps.sps->log2_min_tb_size;
1362
15054346
        int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1363
15054346
        int min_tu_width     = s->ps.sps->min_tb_width;
1364
15054346
        int cbf_luma         = 1;
1365
1366

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

976133
            cbf_cb[0] || cbf_cr[0] ||
1368

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

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

4751934
                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1467
4797591
    int idx              = ff_hevc_pel_weight[block_w];
1468
1469
4797591
    x_off += mv->x >> 2;
1470
4797591
    y_off += mv->y >> 2;
1471
4797591
    src   += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1472
1473

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

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

3781449
                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1530
3781449
    int x_off0           = x_off + (mv0->x >> 2);
1531
3781449
    int y_off0           = y_off + (mv0->y >> 2);
1532
3781449
    int x_off1           = x_off + (mv1->x >> 2);
1533
3781449
    int y_off1           = y_off + (mv1->y >> 2);
1534
3781449
    int idx              = ff_hevc_pel_weight[block_w];
1535
1536
3781449
    uint8_t *src0  = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1537
3781449
    uint8_t *src1  = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1538
1539

3781449
    if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1540
3629676
        x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1541
3566623
        y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1542
415542
        const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1543
415542
        int offset     = QPEL_EXTRA_BEFORE * src0stride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1544
415542
        int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1545
1546
415542
        s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1547
                                 edge_emu_stride, src0stride,
1548
                                 block_w + QPEL_EXTRA,
1549
                                 block_h + QPEL_EXTRA,
1550
                                 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1551
                                 pic_width, pic_height);
1552
415542
        src0 = lc->edge_emu_buffer + buf_offset;
1553
415542
        src0stride = edge_emu_stride;
1554
    }
1555
1556

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

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

9503868
                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1616
9595182
    int idx              = ff_hevc_pel_weight[block_w];
1617
9595182
    int hshift           = s->ps.sps->hshift[1];
1618
9595182
    int vshift           = s->ps.sps->vshift[1];
1619
9595182
    intptr_t mx          = av_mod_uintp2(mv->x, 2 + hshift);
1620
9595182
    intptr_t my          = av_mod_uintp2(mv->y, 2 + vshift);
1621
9595182
    intptr_t _mx         = mx << (1 - hshift);
1622
9595182
    intptr_t _my         = my << (1 - vshift);
1623
1624
9595182
    x_off += mv->x >> (2 + hshift);
1625
9595182
    y_off += mv->y >> (2 + vshift);
1626
9595182
    src0  += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1627
1628

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

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

7562898
                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1681
7562898
    int pic_width        = s->ps.sps->width >> s->ps.sps->hshift[1];
1682
7562898
    int pic_height       = s->ps.sps->height >> s->ps.sps->vshift[1];
1683
7562898
    Mv *mv0              = &current_mv->mv[0];
1684
7562898
    Mv *mv1              = &current_mv->mv[1];
1685
7562898
    int hshift = s->ps.sps->hshift[1];
1686
7562898
    int vshift = s->ps.sps->vshift[1];
1687
1688
7562898
    intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1689
7562898
    intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1690
7562898
    intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1691
7562898
    intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1692
7562898
    intptr_t _mx0 = mx0 << (1 - hshift);
1693
7562898
    intptr_t _my0 = my0 << (1 - vshift);
1694
7562898
    intptr_t _mx1 = mx1 << (1 - hshift);
1695
7562898
    intptr_t _my1 = my1 << (1 - vshift);
1696
1697
7562898
    int x_off0 = x_off + (mv0->x >> (2 + hshift));
1698
7562898
    int y_off0 = y_off + (mv0->y >> (2 + vshift));
1699
7562898
    int x_off1 = x_off + (mv1->x >> (2 + hshift));
1700
7562898
    int y_off1 = y_off + (mv1->y >> (2 + vshift));
1701
7562898
    int idx = ff_hevc_pel_weight[block_w];
1702
7562898
    src1  += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1703
7562898
    src2  += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1704
1705

7562898
    if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1706
7264516
        x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1707
7138414
        y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1708
825266
        const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1709
825266
        int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1710
825266
        int buf_offset1 = EPEL_EXTRA_BEFORE *
1711
825266
                          (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1712
1713
825266
        s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1714
                                 edge_emu_stride, src1stride,
1715
                                 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1716
                                 x_off0 - EPEL_EXTRA_BEFORE,
1717
                                 y_off0 - EPEL_EXTRA_BEFORE,
1718
                                 pic_width, pic_height);
1719
1720
825266
        src1 = lc->edge_emu_buffer + buf_offset1;
1721
825266
        src1stride = edge_emu_stride;
1722
    }
1723
1724

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

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

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

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

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

3861170
            if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2196
162684
                log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2197
160815
                log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2198
153183
                pcm_flag = ff_hevc_pcm_flag_decode(s);
2199
            }
2200
3861170
            if (pcm_flag) {
2201
12433
                intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2202
12433
                ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2203
12433
                if (s->ps.sps->pcm.loop_filter_disable_flag)
2204
8
                    set_deblocking_bypass(s, x0, y0, log2_cb_size);
2205
2206
12433
                if (ret < 0)
2207
                    return ret;
2208
            } else {
2209
3848737
                intra_prediction_unit(s, x0, y0, log2_cb_size);
2210
            }
2211
        } else {
2212
3117079
            intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2213


3117079
            switch (lc->cu.part_mode) {
2214
1738576
            case PART_2Nx2N:
2215
1738576
                hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2216
1738576
                break;
2217
445726
            case PART_2NxN:
2218
445726
                hls_prediction_unit(s, x0, y0,               cb_size, cb_size / 2, log2_cb_size, 0, idx);
2219
445726
                hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2220
445726
                break;
2221
535018
            case PART_Nx2N:
2222
535018
                hls_prediction_unit(s, x0,               y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2223
535018
                hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2224
535018
                break;
2225
63734
            case PART_2NxnU:
2226
63734
                hls_prediction_unit(s, x0, y0,               cb_size, cb_size     / 4, log2_cb_size, 0, idx);
2227
63734
                hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2228
63734
                break;
2229
55171
            case PART_2NxnD:
2230
55171
                hls_prediction_unit(s, x0, y0,                   cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2231
55171
                hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size     / 4, log2_cb_size, 1, idx);
2232
55171
                break;
2233
93167
            case PART_nLx2N:
2234
93167
                hls_prediction_unit(s, x0,               y0, cb_size     / 4, cb_size, log2_cb_size, 0, idx - 2);
2235
93167
                hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2236
93167
                break;
2237
80051
            case PART_nRx2N:
2238
80051
                hls_prediction_unit(s, x0,                   y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2239
80051
                hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size     / 4, cb_size, log2_cb_size, 1, idx - 2);
2240
80051
                break;
2241
105636
            case PART_NxN:
2242
105636
                hls_prediction_unit(s, x0,               y0,               cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2243
105636
                hls_prediction_unit(s, x0 + cb_size / 2, y0,               cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2244
105636
                hls_prediction_unit(s, x0,               y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2245
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);
2246
105636
                break;
2247
            }
2248
6978249
        }
2249
2250
6978249
        if (!pcm_flag) {
2251
6965816
            int rqt_root_cbf = 1;
2252
2253
6965816
            if (lc->cu.pred_mode != MODE_INTRA &&
2254

3117079
                !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2255
2346082
                rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2256
            }
2257
6965816
            if (rqt_root_cbf) {
2258
                const static int cbf[2] = { 0 };
2259
5650099
                lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2260
3848737
                                         s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2261
1801362
                                         s->ps.sps->max_transform_hierarchy_depth_inter;
2262
5650099
                ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2263
                                         log2_cb_size,
2264
                                         log2_cb_size, 0, 0, cbf, cbf);
2265
5650099
                if (ret < 0)
2266
1
                    return ret;
2267
            } else {
2268
1315717
                if (!s->sh.disable_deblocking_filter_flag)
2269
1259285
                    ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2270
            }
2271
        }
2272
    }
2273
2274

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

3313558
        if (more_data && x1 < s->ps.sps->width) {
2333
3285868
            more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2334
3285868
            if (more_data < 0)
2335
                return more_data;
2336
        }
2337

3313558
        if (more_data && y1 < s->ps.sps->height) {
2338
3107421
            more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2339
3107421
            if (more_data < 0)
2340
                return more_data;
2341
        }
2342

3313558
        if (more_data && x1 < s->ps.sps->width &&
2343
3275663
            y1 < s->ps.sps->height) {
2344
3079740
            more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2345
3079740
            if (more_data < 0)
2346
1
                return more_data;
2347
        }
2348
2349
3313557
        if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2350
1853526
            ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2351
1376880
            lc->qPy_pred = lc->qp_y;
2352
2353
3313557
        if (more_data)
2354
3368573
            return ((x1 + cb_size_split) < s->ps.sps->width ||
2355
90453
                    (y1 + cb_size_split) < s->ps.sps->height);
2356
        else
2357
35437
            return 0;
2358
    } else {
2359
10850435
        ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2360
10850435
        if (ret < 0)
2361
1
            return ret;
2362
10850434
        if ((!((x0 + cb_size) %
2363
10850434
               (1 << (s->ps.sps->log2_ctb_size))) ||
2364
7944655
             (x0 + cb_size >= s->ps.sps->width)) &&
2365
2976476
            (!((y0 + cb_size) %
2366
2976476
               (1 << (s->ps.sps->log2_ctb_size))) ||
2367
1694448
             (y0 + cb_size >= s->ps.sps->height))) {
2368
1377405
            int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2369
1377405
            return !end_of_slice_flag;
2370
        } else {
2371
9473029
            return 1;
2372
        }
2373
    }
2374
2375
    return 0;
2376
}
2377
2378
1377406
static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2379
                                 int ctb_addr_ts)
2380
{
2381
1377406
    HEVCLocalContext *lc  = s->HEVClc;
2382
1377406
    int ctb_size          = 1 << s->ps.sps->log2_ctb_size;
2383
1377406
    int ctb_addr_rs       = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2384
1377406
    int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2385
2386
1377406
    s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2387
2388
1377406
    if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2389

93384
        if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2390
5334
            lc->first_qp_group = 1;
2391
93384
        lc->end_of_tiles_x = s->ps.sps->width;
2392
1284022
    } else if (s->ps.pps->tiles_enabled_flag) {
2393

271890
        if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2394
6253
            int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2395
6253
            lc->end_of_tiles_x   = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2396
6253
            lc->first_qp_group   = 1;
2397
        }
2398
    } else {
2399
1012132
        lc->end_of_tiles_x = s->ps.sps->width;
2400
    }
2401
2402
1377406
    lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2403
2404
1377406
    lc->boundary_flags = 0;
2405
1377406
    if (s->ps.pps->tiles_enabled_flag) {
2406

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]])
2407
30253
            lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2408

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

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]])
2411
33061
            lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2412

271890
        if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2413
13770
            lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2414
    } else {
2415
1105516
        if (ctb_addr_in_slice <= 0)
2416
17551
            lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2417
1105516
        if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2418
183824
            lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2419
    }
2420
2421

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

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

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]]));
2424


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]]));
2425
1377406
}
2426
2427
27461
static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2428
{
2429
27461
    HEVCContext *s  = avctxt->priv_data;
2430
27461
    int ctb_size    = 1 << s->ps.sps->log2_ctb_size;
2431
27461
    int more_data   = 1;
2432
27461
    int x_ctb       = 0;
2433
27461
    int y_ctb       = 0;
2434
27461
    int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2435
    int ret;
2436
2437

27461
    if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2438
        av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2439
        return AVERROR_INVALIDDATA;
2440
    }
2441
2442
27461
    if (s->sh.dependent_slice_segment_flag) {
2443
7947
        int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2444
7947
        if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2445
            av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2446
            return AVERROR_INVALIDDATA;
2447
        }
2448
    }
2449
2450

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



9480
    s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2873
2874
9480
    if (s->ps.pps->tiles_enabled_flag)
2875
620
        lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2876
2877
9480
    ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2878
9480
    if (ret < 0)
2879
        goto fail;
2880
2881
9480
    ret = ff_hevc_frame_rps(s);
2882
9480
    if (ret < 0) {
2883
        av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2884
        goto fail;
2885
    }
2886
2887

9480
    s->ref->frame->key_frame = IS_IRAP(s);
2888
2889
9480
    ret = set_side_data(s);
2890
9480
    if (ret < 0)
2891
        goto fail;
2892
2893
9480
    s->frame->pict_type = 3 - s->sh.slice_type;
2894
2895

9480
    if (!IS_IRAP(s))
2896
8949
        ff_hevc_bump_frame(s);
2897
2898
9480
    av_frame_unref(s->output_frame);
2899
9480
    ret = ff_hevc_output_frame(s, s->output_frame, 0);
2900
9480
    if (ret < 0)
2901
        goto fail;
2902
2903
9480
    if (!s->avctx->hwaccel)
2904
9480
        ff_thread_finish_setup(s->avctx);
2905
2906
9480
    return 0;
2907
2908
fail:
2909
    if (s->ref)
2910
        ff_hevc_unref_frame(s, s->ref, ~0);
2911
    s->ref = NULL;
2912
    return ret;
2913
}
2914
2915
37746
static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2916
{
2917
37746
    HEVCLocalContext *lc = s->HEVClc;
2918
37746
    GetBitContext *gb    = &lc->gb;
2919
    int ctb_addr_ts, ret;
2920
2921
37746
    *gb              = nal->gb;
2922
37746
    s->nal_unit_type = nal->type;
2923
37746
    s->temporal_id   = nal->temporal_id;
2924
2925


37746
    switch (s->nal_unit_type) {
2926
396
    case HEVC_NAL_VPS:
2927

396
        if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2928
            ret = s->avctx->hwaccel->decode_params(s->avctx,
2929
                                                   nal->type,
2930
                                                   nal->raw_data,
2931
                                                   nal->raw_size);
2932
            if (ret < 0)
2933
                goto fail;
2934
        }
2935
396
        ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2936
396
        if (ret < 0)
2937
            goto fail;
2938
396
        break;
2939
393
    case HEVC_NAL_SPS:
2940

393
        if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2941
            ret = s->avctx->hwaccel->decode_params(s->avctx,
2942
                                                   nal->type,
2943
                                                   nal->raw_data,
2944
                                                   nal->raw_size);
2945
            if (ret < 0)
2946
                goto fail;
2947
        }
2948
393
        ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2949
                                     s->apply_defdispwin);
2950
393
        if (ret < 0)
2951
            goto fail;
2952
393
        break;
2953
1351
    case HEVC_NAL_PPS:
2954

1351
        if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2955
            ret = s->avctx->hwaccel->decode_params(s->avctx,
2956
                                                   nal->type,
2957
                                                   nal->raw_data,
2958
                                                   nal->raw_size);
2959
            if (ret < 0)
2960
                goto fail;
2961
        }
2962
1351
        ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2963
1351
        if (ret < 0)
2964
2
            goto fail;
2965
1349
        break;
2966
7466
    case HEVC_NAL_SEI_PREFIX:
2967
    case HEVC_NAL_SEI_SUFFIX:
2968

7466
        if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2969
            ret = s->avctx->hwaccel->decode_params(s->avctx,
2970
                                                   nal->type,
2971
                                                   nal->raw_data,
2972
                                                   nal->raw_size);
2973
            if (ret < 0)
2974
                goto fail;
2975
        }
2976
7466
        ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
2977
7466
        if (ret < 0)
2978
46
            goto fail;
2979
7420
        break;
2980
27513
    case HEVC_NAL_TRAIL_R:
2981
    case HEVC_NAL_TRAIL_N:
2982
    case HEVC_NAL_TSA_N:
2983
    case HEVC_NAL_TSA_R:
2984
    case HEVC_NAL_STSA_N:
2985
    case HEVC_NAL_STSA_R:
2986
    case HEVC_NAL_BLA_W_LP:
2987
    case HEVC_NAL_BLA_W_RADL:
2988
    case HEVC_NAL_BLA_N_LP:
2989
    case HEVC_NAL_IDR_W_RADL:
2990
    case HEVC_NAL_IDR_N_LP:
2991
    case HEVC_NAL_CRA_NUT:
2992
    case HEVC_NAL_RADL_N:
2993
    case HEVC_NAL_RADL_R:
2994
    case HEVC_NAL_RASL_N:
2995
    case HEVC_NAL_RASL_R:
2996
27513
        ret = hls_slice_header(s);
2997
27513
        if (ret < 0)
2998
22
            return ret;
2999
27491
        if (ret == 1) {
3000
1
            ret = AVERROR_INVALIDDATA;
3001
1
            goto fail;
3002
        }
3003
3004
3005
27490
        if (
3006

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

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

27490
            (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IRAP(s))) {
3009
            break;
3010
        }
3011
3012
27490
        if (s->sh.first_slice_in_pic_flag) {
3013
9509
            if (s->max_ra == INT_MAX) {
3014


386
                if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
3015
18
                    s->max_ra = s->poc;
3016
                } else {
3017

368
                    if (IS_IDR(s))
3018
368
                        s->max_ra = INT_MIN;
3019
                }
3020
            }
3021
3022

9509
            if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
3023
829
                s->poc <= s->max_ra) {
3024
29
                s->is_decoded = 0;
3025
29
                break;
3026
            } else {
3027

9480
                if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
3028
463
                    s->max_ra = INT_MIN;
3029
            }
3030
3031
9480
            s->overlap ++;
3032
9480
            ret = hevc_frame_start(s);
3033
9480
            if (ret < 0)
3034
                return ret;
3035
17981
        } else if (!s->ref) {
3036
            av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
3037
            goto fail;
3038
        }
3039
3040
27461
        if (s->nal_unit_type != s->first_nal_type) {
3041
            av_log(s->avctx, AV_LOG_ERROR,
3042
                   "Non-matching NAL types of the VCL NALUs: %d %d\n",
3043
                   s->first_nal_type, s->nal_unit_type);
3044
            return AVERROR_INVALIDDATA;
3045
        }
3046
3047
27461
        if (!s->sh.dependent_slice_segment_flag &&
3048
19514
            s->sh.slice_type != HEVC_SLICE_I) {
3049
18398
            ret = ff_hevc_slice_rpl(s);
3050
18398
            if (ret < 0) {
3051
                av_log(s->avctx, AV_LOG_WARNING,
3052
                       "Error constructing the reference lists for the current slice.\n");
3053
                goto fail;
3054
            }
3055
        }
3056
3057

27461
        if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
3058
            ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
3059
            if (ret < 0)
3060
                goto fail;
3061
        }
3062
3063
27461
        if (s->avctx->hwaccel) {
3064
            ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
3065
            if (ret < 0)
3066
                goto fail;
3067
        } else {
3068

27461
            if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
3069
                ctb_addr_ts = hls_slice_data_wpp(s, nal);
3070
            else
3071
27461
                ctb_addr_ts = hls_slice_data(s);
3072
27461
            if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
3073
9479
                s->is_decoded = 1;
3074
            }
3075
3076
27461
            if (ctb_addr_ts < 0) {
3077
1
                ret = ctb_addr_ts;
3078
1
                goto fail;
3079
            }
3080
        }
3081
27460
        break;
3082
4
    case HEVC_NAL_EOS_NUT:
3083
    case HEVC_NAL_EOB_NUT:
3084
4
        s->seq_decode = (s->seq_decode + 1) & 0xff;
3085
4
        s->max_ra     = INT_MAX;
3086
4
        break;
3087
623
    case HEVC_NAL_AUD:
3088
    case HEVC_NAL_FD_NUT:
3089
623
        break;
3090
    default:
3091
        av_log(s->avctx, AV_LOG_INFO,
3092
               "Skipping NAL unit %d\n", s->nal_unit_type);
3093
    }
3094
3095
37674
    return 0;
3096
50
fail:
3097
50
    if (s->avctx->err_recognition & AV_EF_EXPLODE)
3098
        return ret;
3099
50
    return 0;
3100
}
3101
3102
9532
static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
3103
{
3104
9532
    int i, ret = 0;
3105
9532
    int eos_at_start = 1;
3106
3107
9532
    s->ref = NULL;
3108
9532
    s->last_eos = s->eos;
3109
9532
    s->eos = 0;
3110
9532
    s->overlap = 0;
3111
3112
    /* split the input packet into NAL units, so we know the upper bound on the
3113
     * number of slices in the frame */
3114
9532
    ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
3115
9532
                                s->nal_length_size, s->avctx->codec_id, 1, 0);
3116
9532
    if (ret < 0) {
3117
        av_log(s->avctx, AV_LOG_ERROR,
3118
               "Error splitting the input into NAL units.\n");
3119
        return ret;
3120
    }
3121
3122
47278
    for (i = 0; i < s->pkt.nb_nals; i++) {
3123
37746
        if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
3124
37745
            s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
3125
4
            if (eos_at_start) {
3126
4
                s->last_eos = 1;
3127
            } else {
3128
                s->eos = 1;
3129
            }
3130
        } else {
3131
37742
            eos_at_start = 0;
3132
        }
3133
    }
3134
3135
    /* decode the NAL units */
3136
47256
    for (i = 0; i < s->pkt.nb_nals; i++) {
3137
37746
        H2645NAL *nal = &s->pkt.nals[i];
3138
3139
37746
        if (s->avctx->skip_frame >= AVDISCARD_ALL ||
3140
37746
            (s->avctx->skip_frame >= AVDISCARD_NONREF
3141

37746
            && ff_hevc_nal_is_nonref(nal->type)) || nal->nuh_layer_id > 0)
3142
            continue;
3143
3144
37746
        ret = decode_nal_unit(s, nal);
3145

37746
        if (ret >= 0 && s->overlap > 2)
3146
            ret = AVERROR_INVALIDDATA;
3147
37746
        if (ret < 0) {
3148
22
            av_log(s->avctx, AV_LOG_WARNING,
3149
                   "Error parsing NAL unit #%d.\n", i);
3150
22
            goto fail;
3151
        }
3152
    }
3153
3154
9510
fail:
3155

9532
    if (s->ref && s->threads_type == FF_THREAD_FRAME)
3156
32
        ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3157
3158
9532
    return ret;
3159
}
3160
3161
static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3162
{
3163
    int i;
3164
    for (i = 0; i < 16; i++)
3165
        av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3166
}
3167
3168
static int verify_md5(HEVCContext *s, AVFrame *frame)
3169
{
3170
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3171
    int pixel_shift;
3172
    int i, j;
3173
3174
    if (!desc)
3175
        return AVERROR(EINVAL);
3176
3177
    pixel_shift = desc->comp[0].depth > 8;
3178
3179
    av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3180
           s->poc);
3181
3182
    /* the checksums are LE, so we have to byteswap for >8bpp formats
3183
     * on BE arches */
3184
#if HAVE_BIGENDIAN
3185
    if (pixel_shift && !s->checksum_buf) {
3186
        av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3187
                       FFMAX3(frame->linesize[0], frame->linesize[1],
3188
                              frame->linesize[2]));
3189
        if (!s->checksum_buf)
3190
            return AVERROR(ENOMEM);
3191
    }
3192
#endif
3193
3194
    for (i = 0; frame->data[i]; i++) {
3195
        int width  = s->avctx->coded_width;
3196
        int height = s->avctx->coded_height;
3197
        int w = (i == 1 || i == 2) ? (width  >> desc->log2_chroma_w) : width;
3198
        int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3199
        uint8_t md5[16];
3200
3201
        av_md5_init(s->md5_ctx);
3202
        for (j = 0; j < h; j++) {
3203
            const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3204
#if HAVE_BIGENDIAN
3205
            if (pixel_shift) {
3206
                s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3207
                                    (const uint16_t *) src, w);
3208
                src = s->checksum_buf;
3209
            }
3210
#endif
3211
            av_md5_update(s->md5_ctx, src, w << pixel_shift);
3212
        }
3213
        av_md5_final(s->md5_ctx, md5);
3214
3215
        if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3216
            av_log   (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3217
            print_md5(s->avctx, AV_LOG_DEBUG, md5);
3218
            av_log   (s->avctx, AV_LOG_DEBUG, "; ");
3219
        } else {
3220
            av_log   (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3221
            print_md5(s->avctx, AV_LOG_ERROR, md5);
3222
            av_log   (s->avctx, AV_LOG_ERROR, " != ");
3223
            print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
3224
            av_log   (s->avctx, AV_LOG_ERROR, "\n");
3225
            return AVERROR_INVALIDDATA;