git.sesse.net Git - ffmpeg/blob - libavcodec/hevcdec.c

   1 /*
   2  * HEVC video Decoder
   3  *
   4  * Copyright (C) 2012 - 2013 Guillaume Martres
   5  * Copyright (C) 2012 - 2013 Mickael Raulet
   6  * Copyright (C) 2012 - 2013 Gildas Cocherel
   7  * Copyright (C) 2012 - 2013 Wassim Hamidouche
   8  *
   9  * This file is part of FFmpeg.
  10  *
  11  * FFmpeg is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * FFmpeg is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with FFmpeg; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24  */
  25
  26 #include "libavutil/attributes.h"
  27 #include "libavutil/common.h"
  28 #include "libavutil/display.h"
  29 #include "libavutil/internal.h"
  30 #include "libavutil/mastering_display_metadata.h"
  31 #include "libavutil/md5.h"
  32 #include "libavutil/opt.h"
  33 #include "libavutil/pixdesc.h"
  34 #include "libavutil/stereo3d.h"
  35
  36 #include "bswapdsp.h"
  37 #include "bytestream.h"
  38 #include "cabac_functions.h"
  39 #include "golomb.h"
  40 #include "hevc.h"
  41 #include "hevc_data.h"
  42 #include "hevc_parse.h"
  43 #include "hevcdec.h"
  44 #include "hwaccel.h"
  45 #include "profiles.h"
  46
  47 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
  48
  49 /**
  50  * NOTE: Each function hls_foo correspond to the function foo in the
  51  * specification (HLS stands for High Level Syntax).
  52  */
  53
  54 /**
  55  * Section 5.7
  56  */
  57
  58 /* free everything allocated  by pic_arrays_init() */
  59 static void pic_arrays_free(HEVCContext *s)
  60 {
  61     av_freep(&s->sao);
  62     av_freep(&s->deblock);
  63
  64     av_freep(&s->skip_flag);
  65     av_freep(&s->tab_ct_depth);
  66
  67     av_freep(&s->tab_ipm);
  68     av_freep(&s->cbf_luma);
  69     av_freep(&s->is_pcm);
  70
  71     av_freep(&s->qp_y_tab);
  72     av_freep(&s->tab_slice_address);
  73     av_freep(&s->filter_slice_edges);
  74
  75     av_freep(&s->horizontal_bs);
  76     av_freep(&s->vertical_bs);
  77
  78     av_freep(&s->sh.entry_point_offset);
  79     av_freep(&s->sh.size);
  80     av_freep(&s->sh.offset);
  81
  82     av_buffer_pool_uninit(&s->tab_mvf_pool);
  83     av_buffer_pool_uninit(&s->rpl_tab_pool);
  84 }
  85
  86 /* allocate arrays that depend on frame dimensions */
  87 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
  88 {
  89     int log2_min_cb_size = sps->log2_min_cb_size;
  90     int width            = sps->width;
  91     int height           = sps->height;
  92     int pic_size_in_ctb  = ((width  >> log2_min_cb_size) + 1) *
  93                            ((height >> log2_min_cb_size) + 1);
  94     int ctb_count        = sps->ctb_width * sps->ctb_height;
  95     int min_pu_size      = sps->min_pu_width * sps->min_pu_height;
  96
  97     s->bs_width  = (width  >> 2) + 1;
  98     s->bs_height = (height >> 2) + 1;
  99
 100     s->sao           = av_mallocz_array(ctb_count, sizeof(*s->sao));
 101     s->deblock       = av_mallocz_array(ctb_count, sizeof(*s->deblock));
 102     if (!s->sao || !s->deblock)
 103         goto fail;
 104
 105     s->skip_flag    = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
 106     s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
 107     if (!s->skip_flag || !s->tab_ct_depth)
 108         goto fail;
 109
 110     s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
 111     s->tab_ipm  = av_mallocz(min_pu_size);
 112     s->is_pcm   = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
 113     if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
 114         goto fail;
 115
 116     s->filter_slice_edges = av_mallocz(ctb_count);
 117     s->tab_slice_address  = av_malloc_array(pic_size_in_ctb,
 118                                       sizeof(*s->tab_slice_address));
 119     s->qp_y_tab           = av_malloc_array(pic_size_in_ctb,
 120                                       sizeof(*s->qp_y_tab));
 121     if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
 122         goto fail;
 123
 124     s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
 125     s->vertical_bs   = av_mallocz_array(s->bs_width, s->bs_height);
 126     if (!s->horizontal_bs || !s->vertical_bs)
 127         goto fail;
 128
 129     s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
 130                                           av_buffer_allocz);
 131     s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
 132                                           av_buffer_allocz);
 133     if (!s->tab_mvf_pool || !s->rpl_tab_pool)
 134         goto fail;
 135
 136     return 0;
 137
 138 fail:
 139     pic_arrays_free(s);
 140     return AVERROR(ENOMEM);
 141 }
 142
 143 static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
 144 {
 145     int i = 0;
 146     int j = 0;
 147     uint8_t luma_weight_l0_flag[16];
 148     uint8_t chroma_weight_l0_flag[16];
 149     uint8_t luma_weight_l1_flag[16];
 150     uint8_t chroma_weight_l1_flag[16];
 151     int luma_log2_weight_denom;
 152
 153     luma_log2_weight_denom = get_ue_golomb_long(gb);
 154     if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
 155         av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
 156         return AVERROR_INVALIDDATA;
 157     }
 158     s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
 159     if (s->ps.sps->chroma_format_idc != 0) {
 160         int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)get_se_golomb(gb);
 161         if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
 162             av_log(s->avctx, AV_LOG_ERROR, "chroma_log2_weight_denom %"PRId64" is invalid\n", chroma_log2_weight_denom);
 163             return AVERROR_INVALIDDATA;
 164         }
 165         s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
 166     }
 167
 168     for (i = 0; i < s->sh.nb_refs[L0]; i++) {
 169         luma_weight_l0_flag[i] = get_bits1(gb);
 170         if (!luma_weight_l0_flag[i]) {
 171             s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
 172             s->sh.luma_offset_l0[i] = 0;
 173         }
 174     }
 175     if (s->ps.sps->chroma_format_idc != 0) {
 176         for (i = 0; i < s->sh.nb_refs[L0]; i++)
 177             chroma_weight_l0_flag[i] = get_bits1(gb);
 178     } else {
 179         for (i = 0; i < s->sh.nb_refs[L0]; i++)
 180             chroma_weight_l0_flag[i] = 0;
 181     }
 182     for (i = 0; i < s->sh.nb_refs[L0]; i++) {
 183         if (luma_weight_l0_flag[i]) {
 184             int delta_luma_weight_l0 = get_se_golomb(gb);
 185             s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
 186             s->sh.luma_offset_l0[i] = get_se_golomb(gb);
 187         }
 188         if (chroma_weight_l0_flag[i]) {
 189             for (j = 0; j < 2; j++) {
 190                 int delta_chroma_weight_l0 = get_se_golomb(gb);
 191                 int delta_chroma_offset_l0 = get_se_golomb(gb);
 192
 193                 if (   (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
 194                     || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
 195                     return AVERROR_INVALIDDATA;
 196                 }
 197
 198                 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
 199                 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
 200                                                                                     >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
 201             }
 202         } else {
 203             s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
 204             s->sh.chroma_offset_l0[i][0] = 0;
 205             s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
 206             s->sh.chroma_offset_l0[i][1] = 0;
 207         }
 208     }
 209     if (s->sh.slice_type == HEVC_SLICE_B) {
 210         for (i = 0; i < s->sh.nb_refs[L1]; i++) {
 211             luma_weight_l1_flag[i] = get_bits1(gb);
 212             if (!luma_weight_l1_flag[i]) {
 213                 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
 214                 s->sh.luma_offset_l1[i] = 0;
 215             }
 216         }
 217         if (s->ps.sps->chroma_format_idc != 0) {
 218             for (i = 0; i < s->sh.nb_refs[L1]; i++)
 219                 chroma_weight_l1_flag[i] = get_bits1(gb);
 220         } else {
 221             for (i = 0; i < s->sh.nb_refs[L1]; i++)
 222                 chroma_weight_l1_flag[i] = 0;
 223         }
 224         for (i = 0; i < s->sh.nb_refs[L1]; i++) {
 225             if (luma_weight_l1_flag[i]) {
 226                 int delta_luma_weight_l1 = get_se_golomb(gb);
 227                 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
 228                 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
 229             }
 230             if (chroma_weight_l1_flag[i]) {
 231                 for (j = 0; j < 2; j++) {
 232                     int delta_chroma_weight_l1 = get_se_golomb(gb);
 233                     int delta_chroma_offset_l1 = get_se_golomb(gb);
 234
 235                     if (   (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
 236                         || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
 237                         return AVERROR_INVALIDDATA;
 238                     }
 239
 240                     s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
 241                     s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
 242                                                                                         >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
 243                 }
 244             } else {
 245                 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
 246                 s->sh.chroma_offset_l1[i][0] = 0;
 247                 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
 248                 s->sh.chroma_offset_l1[i][1] = 0;
 249             }
 250         }
 251     }
 252     return 0;
 253 }
 254
 255 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
 256 {
 257     const HEVCSPS *sps = s->ps.sps;
 258     int max_poc_lsb    = 1 << sps->log2_max_poc_lsb;
 259     int prev_delta_msb = 0;
 260     unsigned int nb_sps = 0, nb_sh;
 261     int i;
 262
 263     rps->nb_refs = 0;
 264     if (!sps->long_term_ref_pics_present_flag)
 265         return 0;
 266
 267     if (sps->num_long_term_ref_pics_sps > 0)
 268         nb_sps = get_ue_golomb_long(gb);
 269     nb_sh = get_ue_golomb_long(gb);
 270
 271     if (nb_sps > sps->num_long_term_ref_pics_sps)
 272         return AVERROR_INVALIDDATA;
 273     if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
 274         return AVERROR_INVALIDDATA;
 275
 276     rps->nb_refs = nb_sh + nb_sps;
 277
 278     for (i = 0; i < rps->nb_refs; i++) {
 279         uint8_t delta_poc_msb_present;
 280
 281         if (i < nb_sps) {
 282             uint8_t lt_idx_sps = 0;
 283
 284             if (sps->num_long_term_ref_pics_sps > 1)
 285                 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
 286
 287             rps->poc[i]  = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
 288             rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
 289         } else {
 290             rps->poc[i]  = get_bits(gb, sps->log2_max_poc_lsb);
 291             rps->used[i] = get_bits1(gb);
 292         }
 293
 294         delta_poc_msb_present = get_bits1(gb);
 295         if (delta_poc_msb_present) {
 296             int64_t delta = get_ue_golomb_long(gb);
 297             int64_t poc;
 298
 299             if (i && i != nb_sps)
 300                 delta += prev_delta_msb;
 301
 302             poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
 303             if (poc != (int32_t)poc)
 304                 return AVERROR_INVALIDDATA;
 305             rps->poc[i] = poc;
 306             prev_delta_msb = delta;
 307         }
 308     }
 309
 310     return 0;
 311 }
 312
 313 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
 314                                  const HEVCSPS *sps)
 315 {
 316     const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
 317     const HEVCWindow *ow = &sps->output_window;
 318     unsigned int num = 0, den = 0;
 319
 320     avctx->pix_fmt             = sps->pix_fmt;
 321     avctx->coded_width         = sps->width;
 322     avctx->coded_height        = sps->height;
 323     avctx->width               = sps->width  - ow->left_offset - ow->right_offset;
 324     avctx->height              = sps->height - ow->top_offset  - ow->bottom_offset;
 325     avctx->has_b_frames        = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
 326     avctx->profile             = sps->ptl.general_ptl.profile_idc;
 327     avctx->level               = sps->ptl.general_ptl.level_idc;
 328
 329     ff_set_sar(avctx, sps->vui.sar);
 330
 331     if (sps->vui.video_signal_type_present_flag)
 332         avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
 333                                                             : AVCOL_RANGE_MPEG;
 334     else
 335         avctx->color_range = AVCOL_RANGE_MPEG;
 336
 337     if (sps->vui.colour_description_present_flag) {
 338         avctx->color_primaries = sps->vui.colour_primaries;
 339         avctx->color_trc       = sps->vui.transfer_characteristic;
 340         avctx->colorspace      = sps->vui.matrix_coeffs;
 341     } else {
 342         avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
 343         avctx->color_trc       = AVCOL_TRC_UNSPECIFIED;
 344         avctx->colorspace      = AVCOL_SPC_UNSPECIFIED;
 345     }
 346
 347     if (vps->vps_timing_info_present_flag) {
 348         num = vps->vps_num_units_in_tick;
 349         den = vps->vps_time_scale;
 350     } else if (sps->vui.vui_timing_info_present_flag) {
 351         num = sps->vui.vui_num_units_in_tick;
 352         den = sps->vui.vui_time_scale;
 353     }
 354
 355     if (num != 0 && den != 0)
 356         av_reduce(&avctx->framerate.den, &avctx->framerate.num,
 357                   num, den, 1 << 30);
 358 }
 359
 360 static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
 361 {
 362 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
 363                      CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
 364                      CONFIG_HEVC_NVDEC_HWACCEL + \
 365                      CONFIG_HEVC_VAAPI_HWACCEL + \
 366                      CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
 367                      CONFIG_HEVC_VDPAU_HWACCEL)
 368     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
 369
 370     switch (sps->pix_fmt) {
 371     case AV_PIX_FMT_YUV420P:
 372     case AV_PIX_FMT_YUVJ420P:
 373 #if CONFIG_HEVC_DXVA2_HWACCEL
 374         *fmt++ = AV_PIX_FMT_DXVA2_VLD;
 375 #endif
 376 #if CONFIG_HEVC_D3D11VA_HWACCEL
 377         *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
 378         *fmt++ = AV_PIX_FMT_D3D11;
 379 #endif
 380 #if CONFIG_HEVC_VAAPI_HWACCEL
 381         *fmt++ = AV_PIX_FMT_VAAPI;
 382 #endif
 383 #if CONFIG_HEVC_VDPAU_HWACCEL
 384         *fmt++ = AV_PIX_FMT_VDPAU;
 385 #endif
 386 #if CONFIG_HEVC_NVDEC_HWACCEL
 387         *fmt++ = AV_PIX_FMT_CUDA;
 388 #endif
 389 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
 390         *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
 391 #endif
 392         break;
 393     case AV_PIX_FMT_YUV420P10:
 394 #if CONFIG_HEVC_DXVA2_HWACCEL
 395         *fmt++ = AV_PIX_FMT_DXVA2_VLD;
 396 #endif
 397 #if CONFIG_HEVC_D3D11VA_HWACCEL
 398         *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
 399         *fmt++ = AV_PIX_FMT_D3D11;
 400 #endif
 401 #if CONFIG_HEVC_VAAPI_HWACCEL
 402         *fmt++ = AV_PIX_FMT_VAAPI;
 403 #endif
 404 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
 405         *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
 406 #endif
 407 #if CONFIG_HEVC_NVDEC_HWACCEL
 408         *fmt++ = AV_PIX_FMT_CUDA;
 409 #endif
 410         break;
 411     }
 412
 413     *fmt++ = sps->pix_fmt;
 414     *fmt = AV_PIX_FMT_NONE;
 415
 416     return ff_thread_get_format(s->avctx, pix_fmts);
 417 }
 418
 419 static int set_sps(HEVCContext *s, const HEVCSPS *sps,
 420                    enum AVPixelFormat pix_fmt)
 421 {
 422     int ret, i;
 423
 424     pic_arrays_free(s);
 425     s->ps.sps = NULL;
 426     s->ps.vps = NULL;
 427
 428     if (!sps)
 429         return 0;
 430
 431     ret = pic_arrays_init(s, sps);
 432     if (ret < 0)
 433         goto fail;
 434
 435     export_stream_params(s->avctx, &s->ps, sps);
 436
 437     s->avctx->pix_fmt = pix_fmt;
 438
 439     ff_hevc_pred_init(&s->hpc,     sps->bit_depth);
 440     ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
 441     ff_videodsp_init (&s->vdsp,    sps->bit_depth);
 442
 443     for (i = 0; i < 3; i++) {
 444         av_freep(&s->sao_pixel_buffer_h[i]);
 445         av_freep(&s->sao_pixel_buffer_v[i]);
 446     }
 447
 448     if (sps->sao_enabled && !s->avctx->hwaccel) {
 449         int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
 450         int c_idx;
 451
 452         for(c_idx = 0; c_idx < c_count; c_idx++) {
 453             int w = sps->width >> sps->hshift[c_idx];
 454             int h = sps->height >> sps->vshift[c_idx];
 455             s->sao_pixel_buffer_h[c_idx] =
 456                 av_malloc((w * 2 * sps->ctb_height) <<
 457                           sps->pixel_shift);
 458             s->sao_pixel_buffer_v[c_idx] =
 459                 av_malloc((h * 2 * sps->ctb_width) <<
 460                           sps->pixel_shift);
 461         }
 462     }
 463
 464     s->ps.sps = sps;
 465     s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
 466
 467     return 0;
 468
 469 fail:
 470     pic_arrays_free(s);
 471     s->ps.sps = NULL;
 472     return ret;
 473 }
 474
 475 static int hls_slice_header(HEVCContext *s)
 476 {
 477     GetBitContext *gb = &s->HEVClc->gb;
 478     SliceHeader *sh   = &s->sh;
 479     int i, ret;
 480
 481     // Coded parameters
 482     sh->first_slice_in_pic_flag = get_bits1(gb);
 483     if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
 484         s->seq_decode = (s->seq_decode + 1) & 0xff;
 485         s->max_ra     = INT_MAX;
 486         if (IS_IDR(s))
 487             ff_hevc_clear_refs(s);
 488     }
 489     sh->no_output_of_prior_pics_flag = 0;
 490     if (IS_IRAP(s))
 491         sh->no_output_of_prior_pics_flag = get_bits1(gb);
 492
 493     sh->pps_id = get_ue_golomb_long(gb);
 494     if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
 495         av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
 496         return AVERROR_INVALIDDATA;
 497     }
 498     if (!sh->first_slice_in_pic_flag &&
 499         s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
 500         av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
 501         return AVERROR_INVALIDDATA;
 502     }
 503     s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
 504     if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
 505         sh->no_output_of_prior_pics_flag = 1;
 506
 507     if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
 508         const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
 509         const HEVCSPS *last_sps = s->ps.sps;
 510         enum AVPixelFormat pix_fmt;
 511
 512         if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
 513             if (sps->width != last_sps->width || sps->height != last_sps->height ||
 514                 sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering !=
 515                 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
 516                 sh->no_output_of_prior_pics_flag = 0;
 517         }
 518         ff_hevc_clear_refs(s);
 519
 520         ret = set_sps(s, sps, sps->pix_fmt);
 521         if (ret < 0)
 522             return ret;
 523
 524         pix_fmt = get_format(s, sps);
 525         if (pix_fmt < 0)
 526             return pix_fmt;
 527         s->avctx->pix_fmt = pix_fmt;
 528
 529         s->seq_decode = (s->seq_decode + 1) & 0xff;
 530         s->max_ra     = INT_MAX;
 531     }
 532
 533     sh->dependent_slice_segment_flag = 0;
 534     if (!sh->first_slice_in_pic_flag) {
 535         int slice_address_length;
 536
 537         if (s->ps.pps->dependent_slice_segments_enabled_flag)
 538             sh->dependent_slice_segment_flag = get_bits1(gb);
 539
 540         slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
 541                                             s->ps.sps->ctb_height);
 542         sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
 543         if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
 544             av_log(s->avctx, AV_LOG_ERROR,
 545                    "Invalid slice segment address: %u.\n",
 546                    sh->slice_segment_addr);
 547             return AVERROR_INVALIDDATA;
 548         }
 549
 550         if (!sh->dependent_slice_segment_flag) {
 551             sh->slice_addr = sh->slice_segment_addr;
 552             s->slice_idx++;
 553         }
 554     } else {
 555         sh->slice_segment_addr = sh->slice_addr = 0;
 556         s->slice_idx           = 0;
 557         s->slice_initialized   = 0;
 558     }
 559
 560     if (!sh->dependent_slice_segment_flag) {
 561         s->slice_initialized = 0;
 562
 563         for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
 564             skip_bits(gb, 1);  // slice_reserved_undetermined_flag[]
 565
 566         sh->slice_type = get_ue_golomb_long(gb);
 567         if (!(sh->slice_type == HEVC_SLICE_I ||
 568               sh->slice_type == HEVC_SLICE_P ||
 569               sh->slice_type == HEVC_SLICE_B)) {
 570             av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
 571                    sh->slice_type);
 572             return AVERROR_INVALIDDATA;
 573         }
 574         if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
 575             av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
 576             return AVERROR_INVALIDDATA;
 577         }
 578
 579         // when flag is not present, picture is inferred to be output
 580         sh->pic_output_flag = 1;
 581         if (s->ps.pps->output_flag_present_flag)
 582             sh->pic_output_flag = get_bits1(gb);
 583
 584         if (s->ps.sps->separate_colour_plane_flag)
 585             sh->colour_plane_id = get_bits(gb, 2);
 586
 587         if (!IS_IDR(s)) {
 588             int poc, pos;
 589
 590             sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
 591             poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
 592             if (!sh->first_slice_in_pic_flag && poc != s->poc) {
 593                 av_log(s->avctx, AV_LOG_WARNING,
 594                        "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
 595                 if (s->avctx->err_recognition & AV_EF_EXPLODE)
 596                     return AVERROR_INVALIDDATA;
 597                 poc = s->poc;
 598             }
 599             s->poc = poc;
 600
 601             sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
 602             pos = get_bits_left(gb);
 603             if (!sh->short_term_ref_pic_set_sps_flag) {
 604                 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
 605                 if (ret < 0)
 606                     return ret;
 607
 608                 sh->short_term_rps = &sh->slice_rps;
 609             } else {
 610                 int numbits, rps_idx;
 611
 612                 if (!s->ps.sps->nb_st_rps) {
 613                     av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
 614                     return AVERROR_INVALIDDATA;
 615                 }
 616
 617                 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
 618                 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
 619                 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
 620             }
 621             sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
 622
 623             pos = get_bits_left(gb);
 624             ret = decode_lt_rps(s, &sh->long_term_rps, gb);
 625             if (ret < 0) {
 626                 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
 627                 if (s->avctx->err_recognition & AV_EF_EXPLODE)
 628                     return AVERROR_INVALIDDATA;
 629             }
 630             sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
 631
 632             if (s->ps.sps->sps_temporal_mvp_enabled_flag)
 633                 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
 634             else
 635                 sh->slice_temporal_mvp_enabled_flag = 0;
 636         } else {
 637             s->sh.short_term_rps = NULL;
 638             s->poc               = 0;
 639         }
 640
 641         /* 8.3.1 */
 642         if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
 643             s->nal_unit_type != HEVC_NAL_TRAIL_N &&
 644             s->nal_unit_type != HEVC_NAL_TSA_N   &&
 645             s->nal_unit_type != HEVC_NAL_STSA_N  &&
 646             s->nal_unit_type != HEVC_NAL_RADL_N  &&
 647             s->nal_unit_type != HEVC_NAL_RADL_R  &&
 648             s->nal_unit_type != HEVC_NAL_RASL_N  &&
 649             s->nal_unit_type != HEVC_NAL_RASL_R)
 650             s->pocTid0 = s->poc;
 651
 652         if (s->ps.sps->sao_enabled) {
 653             sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
 654             if (s->ps.sps->chroma_format_idc) {
 655                 sh->slice_sample_adaptive_offset_flag[1] =
 656                 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
 657             }
 658         } else {
 659             sh->slice_sample_adaptive_offset_flag[0] = 0;
 660             sh->slice_sample_adaptive_offset_flag[1] = 0;
 661             sh->slice_sample_adaptive_offset_flag[2] = 0;
 662         }
 663
 664         sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
 665         if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
 666             int nb_refs;
 667
 668             sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
 669             if (sh->slice_type == HEVC_SLICE_B)
 670                 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
 671
 672             if (get_bits1(gb)) { // num_ref_idx_active_override_flag
 673                 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
 674                 if (sh->slice_type == HEVC_SLICE_B)
 675                     sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
 676             }
 677             if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
 678                 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
 679                        sh->nb_refs[L0], sh->nb_refs[L1]);
 680                 return AVERROR_INVALIDDATA;
 681             }
 682
 683             sh->rpl_modification_flag[0] = 0;
 684             sh->rpl_modification_flag[1] = 0;
 685             nb_refs = ff_hevc_frame_nb_refs(s);
 686             if (!nb_refs) {
 687                 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
 688                 return AVERROR_INVALIDDATA;
 689             }
 690
 691             if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
 692                 sh->rpl_modification_flag[0] = get_bits1(gb);
 693                 if (sh->rpl_modification_flag[0]) {
 694                     for (i = 0; i < sh->nb_refs[L0]; i++)
 695                         sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
 696                 }
 697
 698                 if (sh->slice_type == HEVC_SLICE_B) {
 699                     sh->rpl_modification_flag[1] = get_bits1(gb);
 700                     if (sh->rpl_modification_flag[1] == 1)
 701                         for (i = 0; i < sh->nb_refs[L1]; i++)
 702                             sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
 703                 }
 704             }
 705
 706             if (sh->slice_type == HEVC_SLICE_B)
 707                 sh->mvd_l1_zero_flag = get_bits1(gb);
 708
 709             if (s->ps.pps->cabac_init_present_flag)
 710                 sh->cabac_init_flag = get_bits1(gb);
 711             else
 712                 sh->cabac_init_flag = 0;
 713
 714             sh->collocated_ref_idx = 0;
 715             if (sh->slice_temporal_mvp_enabled_flag) {
 716                 sh->collocated_list = L0;
 717                 if (sh->slice_type == HEVC_SLICE_B)
 718                     sh->collocated_list = !get_bits1(gb);
 719
 720                 if (sh->nb_refs[sh->collocated_list] > 1) {
 721                     sh->collocated_ref_idx = get_ue_golomb_long(gb);
 722                     if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
 723                         av_log(s->avctx, AV_LOG_ERROR,
 724                                "Invalid collocated_ref_idx: %d.\n",
 725                                sh->collocated_ref_idx);
 726                         return AVERROR_INVALIDDATA;
 727                     }
 728                 }
 729             }
 730
 731             if ((s->ps.pps->weighted_pred_flag   && sh->slice_type == HEVC_SLICE_P) ||
 732                 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
 733                 int ret = pred_weight_table(s, gb);
 734                 if (ret < 0)
 735                     return ret;
 736             }
 737
 738             sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
 739             if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
 740                 av_log(s->avctx, AV_LOG_ERROR,
 741                        "Invalid number of merging MVP candidates: %d.\n",
 742                        sh->max_num_merge_cand);
 743                 return AVERROR_INVALIDDATA;
 744             }
 745         }
 746
 747         sh->slice_qp_delta = get_se_golomb(gb);
 748
 749         if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
 750             sh->slice_cb_qp_offset = get_se_golomb(gb);
 751             sh->slice_cr_qp_offset = get_se_golomb(gb);
 752         } else {
 753             sh->slice_cb_qp_offset = 0;
 754             sh->slice_cr_qp_offset = 0;
 755         }
 756
 757         if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
 758             sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
 759         else
 760             sh->cu_chroma_qp_offset_enabled_flag = 0;
 761
 762         if (s->ps.pps->deblocking_filter_control_present_flag) {
 763             int deblocking_filter_override_flag = 0;
 764
 765             if (s->ps.pps->deblocking_filter_override_enabled_flag)
 766                 deblocking_filter_override_flag = get_bits1(gb);
 767
 768             if (deblocking_filter_override_flag) {
 769                 sh->disable_deblocking_filter_flag = get_bits1(gb);
 770                 if (!sh->disable_deblocking_filter_flag) {
 771                     int beta_offset_div2 = get_se_golomb(gb);
 772                     int tc_offset_div2   = get_se_golomb(gb) ;
 773                     if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
 774                         tc_offset_div2   < -6 || tc_offset_div2   > 6) {
 775                         av_log(s->avctx, AV_LOG_ERROR,
 776                             "Invalid deblock filter offsets: %d, %d\n",
 777                             beta_offset_div2, tc_offset_div2);
 778                         return AVERROR_INVALIDDATA;
 779                     }
 780                     sh->beta_offset = beta_offset_div2 * 2;
 781                     sh->tc_offset   =   tc_offset_div2 * 2;
 782                 }
 783             } else {
 784                 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
 785                 sh->beta_offset                    = s->ps.pps->beta_offset;
 786                 sh->tc_offset                      = s->ps.pps->tc_offset;
 787             }
 788         } else {
 789             sh->disable_deblocking_filter_flag = 0;
 790             sh->beta_offset                    = 0;
 791             sh->tc_offset                      = 0;
 792         }
 793
 794         if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
 795             (sh->slice_sample_adaptive_offset_flag[0] ||
 796              sh->slice_sample_adaptive_offset_flag[1] ||
 797              !sh->disable_deblocking_filter_flag)) {
 798             sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
 799         } else {
 800             sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
 801         }
 802     } else if (!s->slice_initialized) {
 803         av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
 804         return AVERROR_INVALIDDATA;
 805     }
 806
 807     sh->num_entry_point_offsets = 0;
 808     if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
 809         unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
 810         // It would be possible to bound this tighter but this here is simpler
 811         if (num_entry_point_offsets > get_bits_left(gb)) {
 812             av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
 813             return AVERROR_INVALIDDATA;
 814         }
 815
 816         sh->num_entry_point_offsets = num_entry_point_offsets;
 817         if (sh->num_entry_point_offsets > 0) {
 818             int offset_len = get_ue_golomb_long(gb) + 1;
 819
 820             if (offset_len < 1 || offset_len > 32) {
 821                 sh->num_entry_point_offsets = 0;
 822                 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
 823                 return AVERROR_INVALIDDATA;
 824             }
 825
 826             av_freep(&sh->entry_point_offset);
 827             av_freep(&sh->offset);
 828             av_freep(&sh->size);
 829             sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
 830             sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
 831             sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
 832             if (!sh->entry_point_offset || !sh->offset || !sh->size) {
 833                 sh->num_entry_point_offsets = 0;
 834                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
 835                 return AVERROR(ENOMEM);
 836             }
 837             for (i = 0; i < sh->num_entry_point_offsets; i++) {
 838                 unsigned val = get_bits_long(gb, offset_len);
 839                 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
 840             }
 841             if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
 842                 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
 843                 s->threads_number = 1;
 844             } else
 845                 s->enable_parallel_tiles = 0;
 846         } else
 847             s->enable_parallel_tiles = 0;
 848     }
 849
 850     if (s->ps.pps->slice_header_extension_present_flag) {
 851         unsigned int length = get_ue_golomb_long(gb);
 852         if (length*8LL > get_bits_left(gb)) {
 853             av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
 854             return AVERROR_INVALIDDATA;
 855         }
 856         for (i = 0; i < length; i++)
 857             skip_bits(gb, 8);  // slice_header_extension_data_byte
 858     }
 859
 860     // Inferred parameters
 861     sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
 862     if (sh->slice_qp > 51 ||
 863         sh->slice_qp < -s->ps.sps->qp_bd_offset) {
 864         av_log(s->avctx, AV_LOG_ERROR,
 865                "The slice_qp %d is outside the valid range "
 866                "[%d, 51].\n",
 867                sh->slice_qp,
 868                -s->ps.sps->qp_bd_offset);
 869         return AVERROR_INVALIDDATA;
 870     }
 871
 872     sh->slice_ctb_addr_rs = sh->slice_segment_addr;
 873
 874     if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
 875         av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
 876         return AVERROR_INVALIDDATA;
 877     }
 878
 879     if (get_bits_left(gb) < 0) {
 880         av_log(s->avctx, AV_LOG_ERROR,
 881                "Overread slice header by %d bits\n", -get_bits_left(gb));
 882         return AVERROR_INVALIDDATA;
 883     }
 884
 885     s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
 886
 887     if (!s->ps.pps->cu_qp_delta_enabled_flag)
 888         s->HEVClc->qp_y = s->sh.slice_qp;
 889
 890     s->slice_initialized = 1;
 891     s->HEVClc->tu.cu_qp_offset_cb = 0;
 892     s->HEVClc->tu.cu_qp_offset_cr = 0;
 893
 894     return 0;
 895 }
 896
 897 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
 898
 899 #define SET_SAO(elem, value)                            \
 900 do {                                                    \
 901     if (!sao_merge_up_flag && !sao_merge_left_flag)     \
 902         sao->elem = value;                              \
 903     else if (sao_merge_left_flag)                       \
 904         sao->elem = CTB(s->sao, rx-1, ry).elem;         \
 905     else if (sao_merge_up_flag)                         \
 906         sao->elem = CTB(s->sao, rx, ry-1).elem;         \
 907     else                                                \
 908         sao->elem = 0;                                  \
 909 } while (0)
 910
 911 static void hls_sao_param(HEVCContext *s, int rx, int ry)
 912 {
 913     HEVCLocalContext *lc    = s->HEVClc;
 914     int sao_merge_left_flag = 0;
 915     int sao_merge_up_flag   = 0;
 916     SAOParams *sao          = &CTB(s->sao, rx, ry);
 917     int c_idx, i;
 918
 919     if (s->sh.slice_sample_adaptive_offset_flag[0] ||
 920         s->sh.slice_sample_adaptive_offset_flag[1]) {
 921         if (rx > 0) {
 922             if (lc->ctb_left_flag)
 923                 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
 924         }
 925         if (ry > 0 && !sao_merge_left_flag) {
 926             if (lc->ctb_up_flag)
 927                 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
 928         }
 929     }
 930
 931     for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
 932         int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
 933                                                  s->ps.pps->log2_sao_offset_scale_chroma;
 934
 935         if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
 936             sao->type_idx[c_idx] = SAO_NOT_APPLIED;
 937             continue;
 938         }
 939
 940         if (c_idx == 2) {
 941             sao->type_idx[2] = sao->type_idx[1];
 942             sao->eo_class[2] = sao->eo_class[1];
 943         } else {
 944             SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
 945         }
 946
 947         if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
 948             continue;
 949
 950         for (i = 0; i < 4; i++)
 951             SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
 952
 953         if (sao->type_idx[c_idx] == SAO_BAND) {
 954             for (i = 0; i < 4; i++) {
 955                 if (sao->offset_abs[c_idx][i]) {
 956                     SET_SAO(offset_sign[c_idx][i],
 957                             ff_hevc_sao_offset_sign_decode(s));
 958                 } else {
 959                     sao->offset_sign[c_idx][i] = 0;
 960                 }
 961             }
 962             SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
 963         } else if (c_idx != 2) {
 964             SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
 965         }
 966
 967         // Inferred parameters
 968         sao->offset_val[c_idx][0] = 0;
 969         for (i = 0; i < 4; i++) {
 970             sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
 971             if (sao->type_idx[c_idx] == SAO_EDGE) {
 972                 if (i > 1)
 973                     sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
 974             } else if (sao->offset_sign[c_idx][i]) {
 975                 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
 976             }
 977             sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
 978         }
 979     }
 980 }
 981
 982 #undef SET_SAO
 983 #undef CTB
 984
 985 static int hls_cross_component_pred(HEVCContext *s, int idx) {
 986     HEVCLocalContext *lc    = s->HEVClc;
 987     int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
 988
 989     if (log2_res_scale_abs_plus1 !=  0) {
 990         int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
 991         lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
 992                                (1 - 2 * res_scale_sign_flag);
 993     } else {
 994         lc->tu.res_scale_val = 0;
 995     }
 996
 997
 998     return 0;
 999 }
1000
1001 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1002                               int xBase, int yBase, int cb_xBase, int cb_yBase,
1003                               int log2_cb_size, int log2_trafo_size,
1004                               int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
1005 {
1006     HEVCLocalContext *lc = s->HEVClc;
1007     const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
1008     int i;
1009
1010     if (lc->cu.pred_mode == MODE_INTRA) {
1011         int trafo_size = 1 << log2_trafo_size;
1012         ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1013
1014         s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1015     }
1016
1017     if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1018         (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1019         int scan_idx   = SCAN_DIAG;
1020         int scan_idx_c = SCAN_DIAG;
1021         int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1022                          (s->ps.sps->chroma_format_idc == 2 &&
1023                          (cbf_cb[1] || cbf_cr[1]));
1024
1025         if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1026             lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1027             if (lc->tu.cu_qp_delta != 0)
1028                 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1029                     lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1030             lc->tu.is_cu_qp_delta_coded = 1;
1031
1032             if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1033                 lc->tu.cu_qp_delta >  (25 + s->ps.sps->qp_bd_offset / 2)) {
1034                 av_log(s->avctx, AV_LOG_ERROR,
1035                        "The cu_qp_delta %d is outside the valid range "
1036                        "[%d, %d].\n",
1037                        lc->tu.cu_qp_delta,
1038                        -(26 + s->ps.sps->qp_bd_offset / 2),
1039                         (25 + s->ps.sps->qp_bd_offset / 2));
1040                 return AVERROR_INVALIDDATA;
1041             }
1042
1043             ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1044         }
1045
1046         if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1047             !lc->cu.cu_transquant_bypass_flag  &&  !lc->tu.is_cu_chroma_qp_offset_coded) {
1048             int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1049             if (cu_chroma_qp_offset_flag) {
1050                 int cu_chroma_qp_offset_idx  = 0;
1051                 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1052                     cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1053                     av_log(s->avctx, AV_LOG_ERROR,
1054                         "cu_chroma_qp_offset_idx not yet tested.\n");
1055                 }
1056                 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1057                 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1058             } else {
1059                 lc->tu.cu_qp_offset_cb = 0;
1060                 lc->tu.cu_qp_offset_cr = 0;
1061             }
1062             lc->tu.is_cu_chroma_qp_offset_coded = 1;
1063         }
1064
1065         if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1066             if (lc->tu.intra_pred_mode >= 6 &&
1067                 lc->tu.intra_pred_mode <= 14) {
1068                 scan_idx = SCAN_VERT;
1069             } else if (lc->tu.intra_pred_mode >= 22 &&
1070                        lc->tu.intra_pred_mode <= 30) {
1071                 scan_idx = SCAN_HORIZ;
1072             }
1073
1074             if (lc->tu.intra_pred_mode_c >=  6 &&
1075                 lc->tu.intra_pred_mode_c <= 14) {
1076                 scan_idx_c = SCAN_VERT;
1077             } else if (lc->tu.intra_pred_mode_c >= 22 &&
1078                        lc->tu.intra_pred_mode_c <= 30) {
1079                 scan_idx_c = SCAN_HORIZ;
1080             }
1081         }
1082
1083         lc->tu.cross_pf = 0;
1084
1085         if (cbf_luma)
1086             ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1087         if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1088             int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1089             int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1090             lc->tu.cross_pf  = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1091                                 (lc->cu.pred_mode == MODE_INTER ||
1092                                  (lc->tu.chroma_mode_c ==  4)));
1093
1094             if (lc->tu.cross_pf) {
1095                 hls_cross_component_pred(s, 0);
1096             }
1097             for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1098                 if (lc->cu.pred_mode == MODE_INTRA) {
1099                     ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1100                     s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1101                 }
1102                 if (cbf_cb[i])
1103                     ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1104                                                 log2_trafo_size_c, scan_idx_c, 1);
1105                 else
1106                     if (lc->tu.cross_pf) {
1107                         ptrdiff_t stride = s->frame->linesize[1];
1108                         int hshift = s->ps.sps->hshift[1];
1109                         int vshift = s->ps.sps->vshift[1];
1110                         int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1111                         int16_t *coeffs   = (int16_t*)lc->edge_emu_buffer2;
1112                         int size = 1 << log2_trafo_size_c;
1113
1114                         uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1115                                                               ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1116                         for (i = 0; i < (size * size); i++) {
1117                             coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1118                         }
1119                         s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1120                     }
1121             }
1122
1123             if (lc->tu.cross_pf) {
1124                 hls_cross_component_pred(s, 1);
1125             }
1126             for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1127                 if (lc->cu.pred_mode == MODE_INTRA) {
1128                     ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1129                     s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1130                 }
1131                 if (cbf_cr[i])
1132                     ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1133                                                 log2_trafo_size_c, scan_idx_c, 2);
1134                 else
1135                     if (lc->tu.cross_pf) {
1136                         ptrdiff_t stride = s->frame->linesize[2];
1137                         int hshift = s->ps.sps->hshift[2];
1138                         int vshift = s->ps.sps->vshift[2];
1139                         int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1140                         int16_t *coeffs   = (int16_t*)lc->edge_emu_buffer2;
1141                         int size = 1 << log2_trafo_size_c;
1142
1143                         uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1144                                                           ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1145                         for (i = 0; i < (size * size); i++) {
1146                             coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1147                         }
1148                         s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1149                     }
1150             }
1151         } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1152             int trafo_size_h = 1 << (log2_trafo_size + 1);
1153             int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1154             for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1155                 if (lc->cu.pred_mode == MODE_INTRA) {
1156                     ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1157                                                     trafo_size_h, trafo_size_v);
1158                     s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1159                 }
1160                 if (cbf_cb[i])
1161                     ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1162                                                 log2_trafo_size, scan_idx_c, 1);
1163             }
1164             for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1165                 if (lc->cu.pred_mode == MODE_INTRA) {
1166                     ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1167                                                 trafo_size_h, trafo_size_v);
1168                     s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1169                 }
1170                 if (cbf_cr[i])
1171                     ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1172                                                 log2_trafo_size, scan_idx_c, 2);
1173             }
1174         }
1175     } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1176         if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1177             int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1178             int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1179             ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1180             s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1181             s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1182             if (s->ps.sps->chroma_format_idc == 2) {
1183                 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1184                                                 trafo_size_h, trafo_size_v);
1185                 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1186                 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1187             }
1188         } else if (blk_idx == 3) {
1189             int trafo_size_h = 1 << (log2_trafo_size + 1);
1190             int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1191             ff_hevc_set_neighbour_available(s, xBase, yBase,
1192                                             trafo_size_h, trafo_size_v);
1193             s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1194             s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1195             if (s->ps.sps->chroma_format_idc == 2) {
1196                 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1197                                                 trafo_size_h, trafo_size_v);
1198                 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1199                 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1200             }
1201         }
1202     }
1203
1204     return 0;
1205 }
1206
1207 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1208 {
1209     int cb_size          = 1 << log2_cb_size;
1210     int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1211
1212     int min_pu_width     = s->ps.sps->min_pu_width;
1213     int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1214     int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1215     int i, j;
1216
1217     for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1218         for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1219             s->is_pcm[i + j * min_pu_width] = 2;
1220 }
1221
1222 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1223                               int xBase, int yBase, int cb_xBase, int cb_yBase,
1224                               int log2_cb_size, int log2_trafo_size,
1225                               int trafo_depth, int blk_idx,
1226                               const int *base_cbf_cb, const int *base_cbf_cr)
1227 {
1228     HEVCLocalContext *lc = s->HEVClc;
1229     uint8_t split_transform_flag;
1230     int cbf_cb[2];
1231     int cbf_cr[2];
1232     int ret;
1233
1234     cbf_cb[0] = base_cbf_cb[0];
1235     cbf_cb[1] = base_cbf_cb[1];
1236     cbf_cr[0] = base_cbf_cr[0];
1237     cbf_cr[1] = base_cbf_cr[1];
1238
1239     if (lc->cu.intra_split_flag) {
1240         if (trafo_depth == 1) {
1241             lc->tu.intra_pred_mode   = lc->pu.intra_pred_mode[blk_idx];
1242             if (s->ps.sps->chroma_format_idc == 3) {
1243                 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1244                 lc->tu.chroma_mode_c     = lc->pu.chroma_mode_c[blk_idx];
1245             } else {
1246                 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1247                 lc->tu.chroma_mode_c     = lc->pu.chroma_mode_c[0];
1248             }
1249         }
1250     } else {
1251         lc->tu.intra_pred_mode   = lc->pu.intra_pred_mode[0];
1252         lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1253         lc->tu.chroma_mode_c     = lc->pu.chroma_mode_c[0];
1254     }
1255
1256     if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1257         log2_trafo_size >  s->ps.sps->log2_min_tb_size    &&
1258         trafo_depth     < lc->cu.max_trafo_depth       &&
1259         !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1260         split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1261     } else {
1262         int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1263                           lc->cu.pred_mode == MODE_INTER &&
1264                           lc->cu.part_mode != PART_2Nx2N &&
1265                           trafo_depth == 0;
1266
1267         split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1268                                (lc->cu.intra_split_flag && trafo_depth == 0) ||
1269                                inter_split;
1270     }
1271
1272     if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1273         if (trafo_depth == 0 || cbf_cb[0]) {
1274             cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1275             if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1276                 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1277             }
1278         }
1279
1280         if (trafo_depth == 0 || cbf_cr[0]) {
1281             cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1282             if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1283                 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1284             }
1285         }
1286     }
1287
1288     if (split_transform_flag) {
1289         const int trafo_size_split = 1 << (log2_trafo_size - 1);
1290         const int x1 = x0 + trafo_size_split;
1291         const int y1 = y0 + trafo_size_split;
1292
1293 #define SUBDIVIDE(x, y, idx)                                                    \
1294 do {                                                                            \
1295     ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1296                              log2_trafo_size - 1, trafo_depth + 1, idx,         \
1297                              cbf_cb, cbf_cr);                                   \
1298     if (ret < 0)                                                                \
1299         return ret;                                                             \
1300 } while (0)
1301
1302         SUBDIVIDE(x0, y0, 0);
1303         SUBDIVIDE(x1, y0, 1);
1304         SUBDIVIDE(x0, y1, 2);
1305         SUBDIVIDE(x1, y1, 3);
1306
1307 #undef SUBDIVIDE
1308     } else {
1309         int min_tu_size      = 1 << s->ps.sps->log2_min_tb_size;
1310         int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1311         int min_tu_width     = s->ps.sps->min_tb_width;
1312         int cbf_luma         = 1;
1313
1314         if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1315             cbf_cb[0] || cbf_cr[0] ||
1316             (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1317             cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1318         }
1319
1320         ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1321                                  log2_cb_size, log2_trafo_size,
1322                                  blk_idx, cbf_luma, cbf_cb, cbf_cr);
1323         if (ret < 0)
1324             return ret;
1325         // TODO: store cbf_luma somewhere else
1326         if (cbf_luma) {
1327             int i, j;
1328             for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1329                 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1330                     int x_tu = (x0 + j) >> log2_min_tu_size;
1331                     int y_tu = (y0 + i) >> log2_min_tu_size;
1332                     s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1333                 }
1334         }
1335         if (!s->sh.disable_deblocking_filter_flag) {
1336             ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1337             if (s->ps.pps->transquant_bypass_enable_flag &&
1338                 lc->cu.cu_transquant_bypass_flag)
1339                 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1340         }
1341     }
1342     return 0;
1343 }
1344
1345 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1346 {
1347     HEVCLocalContext *lc = s->HEVClc;
1348     GetBitContext gb;
1349     int cb_size   = 1 << log2_cb_size;
1350     ptrdiff_t stride0 = s->frame->linesize[0];
1351     ptrdiff_t stride1 = s->frame->linesize[1];
1352     ptrdiff_t stride2 = s->frame->linesize[2];
1353     uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1354     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)];
1355     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)];
1356
1357     int length         = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1358                          (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1359                           ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1360                           s->ps.sps->pcm.bit_depth_chroma;
1361     const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1362     int ret;
1363
1364     if (!s->sh.disable_deblocking_filter_flag)
1365         ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1366
1367     ret = init_get_bits(&gb, pcm, length);
1368     if (ret < 0)
1369         return ret;
1370
1371     s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size,     &gb, s->ps.sps->pcm.bit_depth);
1372     if (s->ps.sps->chroma_format_idc) {
1373         s->hevcdsp.put_pcm(dst1, stride1,
1374                            cb_size >> s->ps.sps->hshift[1],
1375                            cb_size >> s->ps.sps->vshift[1],
1376                            &gb, s->ps.sps->pcm.bit_depth_chroma);
1377         s->hevcdsp.put_pcm(dst2, stride2,
1378                            cb_size >> s->ps.sps->hshift[2],
1379                            cb_size >> s->ps.sps->vshift[2],
1380                            &gb, s->ps.sps->pcm.bit_depth_chroma);
1381     }
1382
1383     return 0;
1384 }
1385
1386 /**
1387  * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1388  *
1389  * @param s HEVC decoding context
1390  * @param dst target buffer for block data at block position
1391  * @param dststride stride of the dst buffer
1392  * @param ref reference picture buffer at origin (0, 0)
1393  * @param mv motion vector (relative to block position) to get pixel data from
1394  * @param x_off horizontal position of block from origin (0, 0)
1395  * @param y_off vertical position of block from origin (0, 0)
1396  * @param block_w width of block
1397  * @param block_h height of block
1398  * @param luma_weight weighting factor applied to the luma prediction
1399  * @param luma_offset additive offset applied to the luma prediction value
1400  */
1401
1402 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1403                         AVFrame *ref, const Mv *mv, int x_off, int y_off,
1404                         int block_w, int block_h, int luma_weight, int luma_offset)
1405 {
1406     HEVCLocalContext *lc = s->HEVClc;
1407     uint8_t *src         = ref->data[0];
1408     ptrdiff_t srcstride  = ref->linesize[0];
1409     int pic_width        = s->ps.sps->width;
1410     int pic_height       = s->ps.sps->height;
1411     int mx               = mv->x & 3;
1412     int my               = mv->y & 3;
1413     int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1414                            (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1415     int idx              = ff_hevc_pel_weight[block_w];
1416
1417     x_off += mv->x >> 2;
1418     y_off += mv->y >> 2;
1419     src   += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1420
1421     if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1422         x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1423         y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1424         const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1425         int offset     = QPEL_EXTRA_BEFORE * srcstride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1426         int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1427
1428         s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1429                                  edge_emu_stride, srcstride,
1430                                  block_w + QPEL_EXTRA,
1431                                  block_h + QPEL_EXTRA,
1432                                  x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1433                                  pic_width, pic_height);
1434         src = lc->edge_emu_buffer + buf_offset;
1435         srcstride = edge_emu_stride;
1436     }
1437
1438     if (!weight_flag)
1439         s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1440                                                       block_h, mx, my, block_w);
1441     else
1442         s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1443                                                         block_h, s->sh.luma_log2_weight_denom,
1444                                                         luma_weight, luma_offset, mx, my, block_w);
1445 }
1446
1447 /**
1448  * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1449  *
1450  * @param s HEVC decoding context
1451  * @param dst target buffer for block data at block position
1452  * @param dststride stride of the dst buffer
1453  * @param ref0 reference picture0 buffer at origin (0, 0)
1454  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1455  * @param x_off horizontal position of block from origin (0, 0)
1456  * @param y_off vertical position of block from origin (0, 0)
1457  * @param block_w width of block
1458  * @param block_h height of block
1459  * @param ref1 reference picture1 buffer at origin (0, 0)
1460  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1461  * @param current_mv current motion vector structure
1462  */
1463  static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1464                        AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1465                        int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1466 {
1467     HEVCLocalContext *lc = s->HEVClc;
1468     ptrdiff_t src0stride  = ref0->linesize[0];
1469     ptrdiff_t src1stride  = ref1->linesize[0];
1470     int pic_width        = s->ps.sps->width;
1471     int pic_height       = s->ps.sps->height;
1472     int mx0              = mv0->x & 3;
1473     int my0              = mv0->y & 3;
1474     int mx1              = mv1->x & 3;
1475     int my1              = mv1->y & 3;
1476     int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1477                            (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1478     int x_off0           = x_off + (mv0->x >> 2);
1479     int y_off0           = y_off + (mv0->y >> 2);
1480     int x_off1           = x_off + (mv1->x >> 2);
1481     int y_off1           = y_off + (mv1->y >> 2);
1482     int idx              = ff_hevc_pel_weight[block_w];
1483
1484     uint8_t *src0  = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1485     uint8_t *src1  = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1486
1487     if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1488         x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1489         y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1490         const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1491         int offset     = QPEL_EXTRA_BEFORE * src0stride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1492         int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1493
1494         s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1495                                  edge_emu_stride, src0stride,
1496                                  block_w + QPEL_EXTRA,
1497                                  block_h + QPEL_EXTRA,
1498                                  x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1499                                  pic_width, pic_height);
1500         src0 = lc->edge_emu_buffer + buf_offset;
1501         src0stride = edge_emu_stride;
1502     }
1503
1504     if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1505         x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1506         y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1507         const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1508         int offset     = QPEL_EXTRA_BEFORE * src1stride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1509         int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1510
1511         s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1512                                  edge_emu_stride, src1stride,
1513                                  block_w + QPEL_EXTRA,
1514                                  block_h + QPEL_EXTRA,
1515                                  x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1516                                  pic_width, pic_height);
1517         src1 = lc->edge_emu_buffer2 + buf_offset;
1518         src1stride = edge_emu_stride;
1519     }
1520
1521     s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1522                                                 block_h, mx0, my0, block_w);
1523     if (!weight_flag)
1524         s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1525                                                        block_h, mx1, my1, block_w);
1526     else
1527         s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1528                                                          block_h, s->sh.luma_log2_weight_denom,
1529                                                          s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1530                                                          s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1531                                                          s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1532                                                          s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1533                                                          mx1, my1, block_w);
1534
1535 }
1536
1537 /**
1538  * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1539  *
1540  * @param s HEVC decoding context
1541  * @param dst1 target buffer for block data at block position (U plane)
1542  * @param dst2 target buffer for block data at block position (V plane)
1543  * @param dststride stride of the dst1 and dst2 buffers
1544  * @param ref reference picture buffer at origin (0, 0)
1545  * @param mv motion vector (relative to block position) to get pixel data from
1546  * @param x_off horizontal position of block from origin (0, 0)
1547  * @param y_off vertical position of block from origin (0, 0)
1548  * @param block_w width of block
1549  * @param block_h height of block
1550  * @param chroma_weight weighting factor applied to the chroma prediction
1551  * @param chroma_offset additive offset applied to the chroma prediction value
1552  */
1553
1554 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1555                           ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1556                           int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1557 {
1558     HEVCLocalContext *lc = s->HEVClc;
1559     int pic_width        = s->ps.sps->width >> s->ps.sps->hshift[1];
1560     int pic_height       = s->ps.sps->height >> s->ps.sps->vshift[1];
1561     const Mv *mv         = &current_mv->mv[reflist];
1562     int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1563                            (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1564     int idx              = ff_hevc_pel_weight[block_w];
1565     int hshift           = s->ps.sps->hshift[1];
1566     int vshift           = s->ps.sps->vshift[1];
1567     intptr_t mx          = av_mod_uintp2(mv->x, 2 + hshift);
1568     intptr_t my          = av_mod_uintp2(mv->y, 2 + vshift);
1569     intptr_t _mx         = mx << (1 - hshift);
1570     intptr_t _my         = my << (1 - vshift);
1571
1572     x_off += mv->x >> (2 + hshift);
1573     y_off += mv->y >> (2 + vshift);
1574     src0  += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1575
1576     if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1577         x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1578         y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1579         const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1580         int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1581         int buf_offset0 = EPEL_EXTRA_BEFORE *
1582                           (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1583         s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1584                                  edge_emu_stride, srcstride,
1585                                  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1586                                  x_off - EPEL_EXTRA_BEFORE,
1587                                  y_off - EPEL_EXTRA_BEFORE,
1588                                  pic_width, pic_height);
1589
1590         src0 = lc->edge_emu_buffer + buf_offset0;
1591         srcstride = edge_emu_stride;
1592     }
1593     if (!weight_flag)
1594         s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1595                                                   block_h, _mx, _my, block_w);
1596     else
1597         s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1598                                                         block_h, s->sh.chroma_log2_weight_denom,
1599                                                         chroma_weight, chroma_offset, _mx, _my, block_w);
1600 }
1601
1602 /**
1603  * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1604  *
1605  * @param s HEVC decoding context
1606  * @param dst target buffer for block data at block position
1607  * @param dststride stride of the dst buffer
1608  * @param ref0 reference picture0 buffer at origin (0, 0)
1609  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1610  * @param x_off horizontal position of block from origin (0, 0)
1611  * @param y_off vertical position of block from origin (0, 0)
1612  * @param block_w width of block
1613  * @param block_h height of block
1614  * @param ref1 reference picture1 buffer at origin (0, 0)
1615  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1616  * @param current_mv current motion vector structure
1617  * @param cidx chroma component(cb, cr)
1618  */
1619 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1620                          int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1621 {
1622     HEVCLocalContext *lc = s->HEVClc;
1623     uint8_t *src1        = ref0->data[cidx+1];
1624     uint8_t *src2        = ref1->data[cidx+1];
1625     ptrdiff_t src1stride = ref0->linesize[cidx+1];
1626     ptrdiff_t src2stride = ref1->linesize[cidx+1];
1627     int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1628                            (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1629     int pic_width        = s->ps.sps->width >> s->ps.sps->hshift[1];
1630     int pic_height       = s->ps.sps->height >> s->ps.sps->vshift[1];
1631     Mv *mv0              = &current_mv->mv[0];
1632     Mv *mv1              = &current_mv->mv[1];
1633     int hshift = s->ps.sps->hshift[1];
1634     int vshift = s->ps.sps->vshift[1];
1635
1636     intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1637     intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1638     intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1639     intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1640     intptr_t _mx0 = mx0 << (1 - hshift);
1641     intptr_t _my0 = my0 << (1 - vshift);
1642     intptr_t _mx1 = mx1 << (1 - hshift);
1643     intptr_t _my1 = my1 << (1 - vshift);
1644
1645     int x_off0 = x_off + (mv0->x >> (2 + hshift));
1646     int y_off0 = y_off + (mv0->y >> (2 + vshift));
1647     int x_off1 = x_off + (mv1->x >> (2 + hshift));
1648     int y_off1 = y_off + (mv1->y >> (2 + vshift));
1649     int idx = ff_hevc_pel_weight[block_w];
1650     src1  += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1651     src2  += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1652
1653     if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1654         x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1655         y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1656         const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1657         int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1658         int buf_offset1 = EPEL_EXTRA_BEFORE *
1659                           (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1660
1661         s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1662                                  edge_emu_stride, src1stride,
1663                                  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1664                                  x_off0 - EPEL_EXTRA_BEFORE,
1665                                  y_off0 - EPEL_EXTRA_BEFORE,
1666                                  pic_width, pic_height);
1667
1668         src1 = lc->edge_emu_buffer + buf_offset1;
1669         src1stride = edge_emu_stride;
1670     }
1671
1672     if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1673         x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1674         y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1675         const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1676         int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1677         int buf_offset1 = EPEL_EXTRA_BEFORE *
1678                           (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1679
1680         s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1681                                  edge_emu_stride, src2stride,
1682                                  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1683                                  x_off1 - EPEL_EXTRA_BEFORE,
1684                                  y_off1 - EPEL_EXTRA_BEFORE,
1685                                  pic_width, pic_height);
1686
1687         src2 = lc->edge_emu_buffer2 + buf_offset1;
1688         src2stride = edge_emu_stride;
1689     }
1690
1691     s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1692                                                 block_h, _mx0, _my0, block_w);
1693     if (!weight_flag)
1694         s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1695                                                        src2, src2stride, lc->tmp,
1696                                                        block_h, _mx1, _my1, block_w);
1697     else
1698         s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1699                                                          src2, src2stride, lc->tmp,
1700                                                          block_h,
1701                                                          s->sh.chroma_log2_weight_denom,
1702                                                          s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1703                                                          s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1704                                                          s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1705                                                          s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1706                                                          _mx1, _my1, block_w);
1707 }
1708
1709 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1710                                 const Mv *mv, int y0, int height)
1711 {
1712     if (s->threads_type == FF_THREAD_FRAME ) {
1713         int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1714
1715         ff_thread_await_progress(&ref->tf, y, 0);
1716     }
1717 }
1718
1719 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1720                                   int nPbH, int log2_cb_size, int part_idx,
1721                                   int merge_idx, MvField *mv)
1722 {
1723     HEVCLocalContext *lc = s->HEVClc;
1724     enum InterPredIdc inter_pred_idc = PRED_L0;
1725     int mvp_flag;
1726
1727     ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1728     mv->pred_flag = 0;
1729     if (s->sh.slice_type == HEVC_SLICE_B)
1730         inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1731
1732     if (inter_pred_idc != PRED_L1) {
1733         if (s->sh.nb_refs[L0])
1734             mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1735
1736         mv->pred_flag = PF_L0;
1737         ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1738         mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1739         ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1740                                  part_idx, merge_idx, mv, mvp_flag, 0);
1741         mv->mv[0].x += lc->pu.mvd.x;
1742         mv->mv[0].y += lc->pu.mvd.y;
1743     }
1744
1745     if (inter_pred_idc != PRED_L0) {
1746         if (s->sh.nb_refs[L1])
1747             mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1748
1749         if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1750             AV_ZERO32(&lc->pu.mvd);
1751         } else {
1752             ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1753         }
1754
1755         mv->pred_flag += PF_L1;
1756         mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1757         ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1758                                  part_idx, merge_idx, mv, mvp_flag, 1);
1759         mv->mv[1].x += lc->pu.mvd.x;
1760         mv->mv[1].y += lc->pu.mvd.y;
1761     }
1762 }
1763
1764 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1765                                 int nPbW, int nPbH,
1766                                 int log2_cb_size, int partIdx, int idx)
1767 {
1768 #define POS(c_idx, x, y)                                                              \
1769     &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1770                            (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1771     HEVCLocalContext *lc = s->HEVClc;
1772     int merge_idx = 0;
1773     struct MvField current_mv = {{{ 0 }}};
1774
1775     int min_pu_width = s->ps.sps->min_pu_width;
1776
1777     MvField *tab_mvf = s->ref->tab_mvf;
1778     RefPicList  *refPicList = s->ref->refPicList;
1779     HEVCFrame *ref0 = NULL, *ref1 = NULL;
1780     uint8_t *dst0 = POS(0, x0, y0);
1781     uint8_t *dst1 = POS(1, x0, y0);
1782     uint8_t *dst2 = POS(2, x0, y0);
1783     int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1784     int min_cb_width     = s->ps.sps->min_cb_width;
1785     int x_cb             = x0 >> log2_min_cb_size;
1786     int y_cb             = y0 >> log2_min_cb_size;
1787     int x_pu, y_pu;
1788     int i, j;
1789
1790     int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1791
1792     if (!skip_flag)
1793         lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1794
1795     if (skip_flag || lc->pu.merge_flag) {
1796         if (s->sh.max_num_merge_cand > 1)
1797             merge_idx = ff_hevc_merge_idx_decode(s);
1798         else
1799             merge_idx = 0;
1800
1801         ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1802                                    partIdx, merge_idx, &current_mv);
1803     } else {
1804         hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1805                               partIdx, merge_idx, &current_mv);
1806     }
1807
1808     x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1809     y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1810
1811     for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1812         for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1813             tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1814
1815     if (current_mv.pred_flag & PF_L0) {
1816         ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1817         if (!ref0)
1818             return;
1819         hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1820     }
1821     if (current_mv.pred_flag & PF_L1) {
1822         ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1823         if (!ref1)
1824             return;
1825         hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1826     }
1827
1828     if (current_mv.pred_flag == PF_L0) {
1829         int x0_c = x0 >> s->ps.sps->hshift[1];
1830         int y0_c = y0 >> s->ps.sps->vshift[1];
1831         int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1832         int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1833
1834         luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1835                     &current_mv.mv[0], x0, y0, nPbW, nPbH,
1836                     s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1837                     s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1838
1839         if (s->ps.sps->chroma_format_idc) {
1840             chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1841                           0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1842                           s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1843             chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1844                           0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1845                           s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1846         }
1847     } else if (current_mv.pred_flag == PF_L1) {
1848         int x0_c = x0 >> s->ps.sps->hshift[1];
1849         int y0_c = y0 >> s->ps.sps->vshift[1];
1850         int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1851         int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1852
1853         luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1854                     &current_mv.mv[1], x0, y0, nPbW, nPbH,
1855                     s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1856                     s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1857
1858         if (s->ps.sps->chroma_format_idc) {
1859             chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1860                           1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1861                           s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1862
1863             chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1864                           1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1865                           s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1866         }
1867     } else if (current_mv.pred_flag == PF_BI) {
1868         int x0_c = x0 >> s->ps.sps->hshift[1];
1869         int y0_c = y0 >> s->ps.sps->vshift[1];
1870         int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1871         int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1872
1873         luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1874                    &current_mv.mv[0], x0, y0, nPbW, nPbH,
1875                    ref1->frame, &current_mv.mv[1], &current_mv);
1876
1877         if (s->ps.sps->chroma_format_idc) {
1878             chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1879                          x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 0);
1880
1881             chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1882                          x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 1);
1883         }
1884     }
1885 }
1886
1887 /**
1888  * 8.4.1
1889  */
1890 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1891                                 int prev_intra_luma_pred_flag)
1892 {
1893     HEVCLocalContext *lc = s->HEVClc;
1894     int x_pu             = x0 >> s->ps.sps->log2_min_pu_size;
1895     int y_pu             = y0 >> s->ps.sps->log2_min_pu_size;
1896     int min_pu_width     = s->ps.sps->min_pu_width;
1897     int size_in_pus      = pu_size >> s->ps.sps->log2_min_pu_size;
1898     int x0b              = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1899     int y0b              = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1900
1901     int cand_up   = (lc->ctb_up_flag || y0b) ?
1902                     s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1903     int cand_left = (lc->ctb_left_flag || x0b) ?
1904                     s->tab_ipm[y_pu * min_pu_width + x_pu - 1]   : INTRA_DC;
1905
1906     int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1907
1908     MvField *tab_mvf = s->ref->tab_mvf;
1909     int intra_pred_mode;
1910     int candidate[3];
1911     int i, j;
1912
1913     // intra_pred_mode prediction does not cross vertical CTB boundaries
1914     if ((y0 - 1) < y_ctb)
1915         cand_up = INTRA_DC;
1916
1917     if (cand_left == cand_up) {
1918         if (cand_left < 2) {
1919             candidate[0] = INTRA_PLANAR;
1920             candidate[1] = INTRA_DC;
1921             candidate[2] = INTRA_ANGULAR_26;
1922         } else {
1923             candidate[0] = cand_left;
1924             candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1925             candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1926         }
1927     } else {
1928         candidate[0] = cand_left;
1929         candidate[1] = cand_up;
1930         if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1931             candidate[2] = INTRA_PLANAR;
1932         } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1933             candidate[2] = INTRA_DC;
1934         } else {
1935             candidate[2] = INTRA_ANGULAR_26;
1936         }
1937     }
1938
1939     if (prev_intra_luma_pred_flag) {
1940         intra_pred_mode = candidate[lc->pu.mpm_idx];
1941     } else {
1942         if (candidate[0] > candidate[1])
1943             FFSWAP(uint8_t, candidate[0], candidate[1]);
1944         if (candidate[0] > candidate[2])
1945             FFSWAP(uint8_t, candidate[0], candidate[2]);
1946         if (candidate[1] > candidate[2])
1947             FFSWAP(uint8_t, candidate[1], candidate[2]);
1948
1949         intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1950         for (i = 0; i < 3; i++)
1951             if (intra_pred_mode >= candidate[i])
1952                 intra_pred_mode++;
1953     }
1954
1955     /* write the intra prediction units into the mv array */
1956     if (!size_in_pus)
1957         size_in_pus = 1;
1958     for (i = 0; i < size_in_pus; i++) {
1959         memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1960                intra_pred_mode, size_in_pus);
1961
1962         for (j = 0; j < size_in_pus; j++) {
1963             tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1964         }
1965     }
1966
1967     return intra_pred_mode;
1968 }
1969
1970 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1971                                           int log2_cb_size, int ct_depth)
1972 {
1973     int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1974     int x_cb   = x0 >> s->ps.sps->log2_min_cb_size;
1975     int y_cb   = y0 >> s->ps.sps->log2_min_cb_size;
1976     int y;
1977
1978     for (y = 0; y < length; y++)
1979         memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1980                ct_depth, length);
1981 }
1982
1983 static const uint8_t tab_mode_idx[] = {
1984      0,  1,  2,  2,  2,  2,  3,  5,  7,  8, 10, 12, 13, 15, 17, 18, 19, 20,
1985     21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1986
1987 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1988                                   int log2_cb_size)
1989 {
1990     HEVCLocalContext *lc = s->HEVClc;
1991     static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1992     uint8_t prev_intra_luma_pred_flag[4];
1993     int split   = lc->cu.part_mode == PART_NxN;
1994     int pb_size = (1 << log2_cb_size) >> split;
1995     int side    = split + 1;
1996     int chroma_mode;
1997     int i, j;
1998
1999     for (i = 0; i < side; i++)
2000         for (j = 0; j < side; j++)
2001             prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2002
2003     for (i = 0; i < side; i++) {
2004         for (j = 0; j < side; j++) {
2005             if (prev_intra_luma_pred_flag[2 * i + j])
2006                 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2007             else
2008                 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2009
2010             lc->pu.intra_pred_mode[2 * i + j] =
2011                 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2012                                      prev_intra_luma_pred_flag[2 * i + j]);
2013         }
2014     }
2015
2016     if (s->ps.sps->chroma_format_idc == 3) {
2017         for (i = 0; i < side; i++) {
2018             for (j = 0; j < side; j++) {
2019                 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2020                 if (chroma_mode != 4) {
2021                     if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
2022                         lc->pu.intra_pred_mode_c[2 * i + j] = 34;
2023                     else
2024                         lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
2025                 } else {
2026                     lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
2027                 }
2028             }
2029         }
2030     } else if (s->ps.sps->chroma_format_idc == 2) {
2031         int mode_idx;
2032         lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2033         if (chroma_mode != 4) {
2034             if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2035                 mode_idx = 34;
2036             else
2037                 mode_idx = intra_chroma_table[chroma_mode];
2038         } else {
2039             mode_idx = lc->pu.intra_pred_mode[0];
2040         }
2041         lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2042     } else if (s->ps.sps->chroma_format_idc != 0) {
2043         chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2044         if (chroma_mode != 4) {
2045             if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2046                 lc->pu.intra_pred_mode_c[0] = 34;
2047             else
2048                 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2049         } else {
2050             lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2051         }
2052     }
2053 }
2054
2055 static void intra_prediction_unit_default_value(HEVCContext *s,
2056                                                 int x0, int y0,
2057                                                 int log2_cb_size)
2058 {
2059     HEVCLocalContext *lc = s->HEVClc;
2060     int pb_size          = 1 << log2_cb_size;
2061     int size_in_pus      = pb_size >> s->ps.sps->log2_min_pu_size;
2062     int min_pu_width     = s->ps.sps->min_pu_width;
2063     MvField *tab_mvf     = s->ref->tab_mvf;
2064     int x_pu             = x0 >> s->ps.sps->log2_min_pu_size;
2065     int y_pu             = y0 >> s->ps.sps->log2_min_pu_size;
2066     int j, k;
2067
2068     if (size_in_pus == 0)
2069         size_in_pus = 1;
2070     for (j = 0; j < size_in_pus; j++)
2071         memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2072     if (lc->cu.pred_mode == MODE_INTRA)
2073         for (j = 0; j < size_in_pus; j++)
2074             for (k = 0; k < size_in_pus; k++)
2075                 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2076 }
2077
2078 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2079 {
2080     int cb_size          = 1 << log2_cb_size;
2081     HEVCLocalContext *lc = s->HEVClc;
2082     int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2083     int length           = cb_size >> log2_min_cb_size;
2084     int min_cb_width     = s->ps.sps->min_cb_width;
2085     int x_cb             = x0 >> log2_min_cb_size;
2086     int y_cb             = y0 >> log2_min_cb_size;
2087     int idx              = log2_cb_size - 2;
2088     int qp_block_mask    = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2089     int x, y, ret;
2090
2091     lc->cu.x                = x0;
2092     lc->cu.y                = y0;
2093     lc->cu.pred_mode        = MODE_INTRA;
2094     lc->cu.part_mode        = PART_2Nx2N;
2095     lc->cu.intra_split_flag = 0;
2096
2097     SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2098     for (x = 0; x < 4; x++)
2099         lc->pu.intra_pred_mode[x] = 1;
2100     if (s->ps.pps->transquant_bypass_enable_flag) {
2101         lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2102         if (lc->cu.cu_transquant_bypass_flag)
2103             set_deblocking_bypass(s, x0, y0, log2_cb_size);
2104     } else
2105         lc->cu.cu_transquant_bypass_flag = 0;
2106
2107     if (s->sh.slice_type != HEVC_SLICE_I) {
2108         uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2109
2110         x = y_cb * min_cb_width + x_cb;
2111         for (y = 0; y < length; y++) {
2112             memset(&s->skip_flag[x], skip_flag, length);
2113             x += min_cb_width;
2114         }
2115         lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2116     } else {
2117         x = y_cb * min_cb_width + x_cb;
2118         for (y = 0; y < length; y++) {
2119             memset(&s->skip_flag[x], 0, length);
2120             x += min_cb_width;
2121         }
2122     }
2123
2124     if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2125         hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2126         intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2127
2128         if (!s->sh.disable_deblocking_filter_flag)
2129             ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2130     } else {
2131         int pcm_flag = 0;
2132
2133         if (s->sh.slice_type != HEVC_SLICE_I)
2134             lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2135         if (lc->cu.pred_mode != MODE_INTRA ||
2136             log2_cb_size == s->ps.sps->log2_min_cb_size) {
2137             lc->cu.part_mode        = ff_hevc_part_mode_decode(s, log2_cb_size);
2138             lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2139                                       lc->cu.pred_mode == MODE_INTRA;
2140         }
2141
2142         if (lc->cu.pred_mode == MODE_INTRA) {
2143             if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2144                 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2145                 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2146                 pcm_flag = ff_hevc_pcm_flag_decode(s);
2147             }
2148             if (pcm_flag) {
2149                 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2150                 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2151                 if (s->ps.sps->pcm.loop_filter_disable_flag)
2152                     set_deblocking_bypass(s, x0, y0, log2_cb_size);
2153
2154                 if (ret < 0)
2155                     return ret;
2156             } else {
2157                 intra_prediction_unit(s, x0, y0, log2_cb_size);
2158             }
2159         } else {
2160             intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2161             switch (lc->cu.part_mode) {
2162             case PART_2Nx2N:
2163                 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2164                 break;
2165             case PART_2NxN:
2166                 hls_prediction_unit(s, x0, y0,               cb_size, cb_size / 2, log2_cb_size, 0, idx);
2167                 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2168                 break;
2169             case PART_Nx2N:
2170                 hls_prediction_unit(s, x0,               y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2171                 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2172                 break;
2173             case PART_2NxnU:
2174                 hls_prediction_unit(s, x0, y0,               cb_size, cb_size     / 4, log2_cb_size, 0, idx);
2175                 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2176                 break;
2177             case PART_2NxnD:
2178                 hls_prediction_unit(s, x0, y0,                   cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2179                 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size     / 4, log2_cb_size, 1, idx);
2180                 break;
2181             case PART_nLx2N:
2182                 hls_prediction_unit(s, x0,               y0, cb_size     / 4, cb_size, log2_cb_size, 0, idx - 2);
2183                 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2184                 break;
2185             case PART_nRx2N:
2186                 hls_prediction_unit(s, x0,                   y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2187                 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size     / 4, cb_size, log2_cb_size, 1, idx - 2);
2188                 break;
2189             case PART_NxN:
2190                 hls_prediction_unit(s, x0,               y0,               cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2191                 hls_prediction_unit(s, x0 + cb_size / 2, y0,               cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2192                 hls_prediction_unit(s, x0,               y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2193                 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2194                 break;
2195             }
2196         }
2197
2198         if (!pcm_flag) {
2199             int rqt_root_cbf = 1;
2200
2201             if (lc->cu.pred_mode != MODE_INTRA &&
2202                 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2203                 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2204             }
2205             if (rqt_root_cbf) {
2206                 const static int cbf[2] = { 0 };
2207                 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2208                                          s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2209                                          s->ps.sps->max_transform_hierarchy_depth_inter;
2210                 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2211                                          log2_cb_size,
2212                                          log2_cb_size, 0, 0, cbf, cbf);
2213                 if (ret < 0)
2214                     return ret;
2215             } else {
2216                 if (!s->sh.disable_deblocking_filter_flag)
2217                     ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2218             }
2219         }
2220     }
2221
2222     if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2223         ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2224
2225     x = y_cb * min_cb_width + x_cb;
2226     for (y = 0; y < length; y++) {
2227         memset(&s->qp_y_tab[x], lc->qp_y, length);
2228         x += min_cb_width;
2229     }
2230
2231     if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2232        ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2233         lc->qPy_pred = lc->qp_y;
2234     }
2235
2236     set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2237
2238     return 0;
2239 }
2240
2241 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2242                                int log2_cb_size, int cb_depth)
2243 {
2244     HEVCLocalContext *lc = s->HEVClc;
2245     const int cb_size    = 1 << log2_cb_size;
2246     int ret;
2247     int split_cu;
2248
2249     lc->ct_depth = cb_depth;
2250     if (x0 + cb_size <= s->ps.sps->width  &&
2251         y0 + cb_size <= s->ps.sps->height &&
2252         log2_cb_size > s->ps.sps->log2_min_cb_size) {
2253         split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2254     } else {
2255         split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2256     }
2257     if (s->ps.pps->cu_qp_delta_enabled_flag &&
2258         log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2259         lc->tu.is_cu_qp_delta_coded = 0;
2260         lc->tu.cu_qp_delta          = 0;
2261     }
2262
2263     if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2264         log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2265         lc->tu.is_cu_chroma_qp_offset_coded = 0;
2266     }
2267
2268     if (split_cu) {
2269         int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2270         const int cb_size_split = cb_size >> 1;
2271         const int x1 = x0 + cb_size_split;
2272         const int y1 = y0 + cb_size_split;
2273
2274         int more_data = 0;
2275
2276         more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2277         if (more_data < 0)
2278             return more_data;
2279
2280         if (more_data && x1 < s->ps.sps->width) {
2281             more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2282             if (more_data < 0)
2283                 return more_data;
2284         }
2285         if (more_data && y1 < s->ps.sps->height) {
2286             more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2287             if (more_data < 0)
2288                 return more_data;
2289         }
2290         if (more_data && x1 < s->ps.sps->width &&
2291             y1 < s->ps.sps->height) {
2292             more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2293             if (more_data < 0)
2294                 return more_data;
2295         }
2296
2297         if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2298             ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2299             lc->qPy_pred = lc->qp_y;
2300
2301         if (more_data)
2302             return ((x1 + cb_size_split) < s->ps.sps->width ||
2303                     (y1 + cb_size_split) < s->ps.sps->height);
2304         else
2305             return 0;
2306     } else {
2307         ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2308         if (ret < 0)
2309             return ret;
2310         if ((!((x0 + cb_size) %
2311                (1 << (s->ps.sps->log2_ctb_size))) ||
2312              (x0 + cb_size >= s->ps.sps->width)) &&
2313             (!((y0 + cb_size) %
2314                (1 << (s->ps.sps->log2_ctb_size))) ||
2315              (y0 + cb_size >= s->ps.sps->height))) {
2316             int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2317             return !end_of_slice_flag;
2318         } else {
2319             return 1;
2320         }
2321     }
2322
2323     return 0;
2324 }
2325
2326 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2327                                  int ctb_addr_ts)
2328 {
2329     HEVCLocalContext *lc  = s->HEVClc;
2330     int ctb_size          = 1 << s->ps.sps->log2_ctb_size;
2331     int ctb_addr_rs       = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2332     int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2333
2334     s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2335
2336     if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2337         if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2338             lc->first_qp_group = 1;
2339         lc->end_of_tiles_x = s->ps.sps->width;
2340     } else if (s->ps.pps->tiles_enabled_flag) {
2341         if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2342             int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2343             lc->end_of_tiles_x   = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2344             lc->first_qp_group   = 1;
2345         }
2346     } else {
2347         lc->end_of_tiles_x = s->ps.sps->width;
2348     }
2349
2350     lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2351
2352     lc->boundary_flags = 0;
2353     if (s->ps.pps->tiles_enabled_flag) {
2354         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]])
2355             lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2356         if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2357             lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2358         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]])
2359             lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2360         if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2361             lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2362     } else {
2363         if (ctb_addr_in_slice <= 0)
2364             lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2365         if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2366             lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2367     }
2368
2369     lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2370     lc->ctb_up_flag   = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2371     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]]));
2372     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]]));
2373 }
2374
2375 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2376 {
2377     HEVCContext *s  = avctxt->priv_data;
2378     int ctb_size    = 1 << s->ps.sps->log2_ctb_size;
2379     int more_data   = 1;
2380     int x_ctb       = 0;
2381     int y_ctb       = 0;
2382     int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2383     int ret;
2384
2385     if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2386         av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2387         return AVERROR_INVALIDDATA;
2388     }
2389
2390     if (s->sh.dependent_slice_segment_flag) {
2391         int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2392         if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2393             av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2394             return AVERROR_INVALIDDATA;
2395         }
2396     }
2397
2398     while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2399         int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2400
2401         x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2402         y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2403         hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2404
2405         ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2406         if (ret < 0) {
2407             s->tab_slice_address[ctb_addr_rs] = -1;
2408             return ret;
2409         }
2410
2411         hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2412
2413         s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2414         s->deblock[ctb_addr_rs].tc_offset   = s->sh.tc_offset;
2415         s->filter_slice_edges[ctb_addr_rs]  = s->sh.slice_loop_filter_across_slices_enabled_flag;
2416
2417         more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2418         if (more_data < 0) {
2419             s->tab_slice_address[ctb_addr_rs] = -1;
2420             return more_data;
2421         }
2422
2423
2424         ctb_addr_ts++;
2425         ff_hevc_save_states(s, ctb_addr_ts);
2426         ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2427     }
2428
2429     if (x_ctb + ctb_size >= s->ps.sps->width &&
2430         y_ctb + ctb_size >= s->ps.sps->height)
2431         ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2432
2433     return ctb_addr_ts;
2434 }
2435
2436 static int hls_slice_data(HEVCContext *s)
2437 {
2438     int arg[2];
2439     int ret[2];
2440
2441     arg[0] = 0;
2442     arg[1] = 1;
2443
2444     s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2445     return ret[0];
2446 }
2447 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2448 {
2449     HEVCContext *s1  = avctxt->priv_data, *s;
2450     HEVCLocalContext *lc;
2451     int ctb_size    = 1<< s1->ps.sps->log2_ctb_size;
2452     int more_data   = 1;
2453     int *ctb_row_p    = input_ctb_row;
2454     int ctb_row = ctb_row_p[job];
2455     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);
2456     int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2457     int thread = ctb_row % s1->threads_number;
2458     int ret;
2459
2460     s = s1->sList[self_id];
2461     lc = s->HEVClc;
2462
2463     if(ctb_row) {
2464         ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2465         if (ret < 0)
2466             goto error;
2467         ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2468     }
2469
2470     while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2471         int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2472         int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2473
2474         hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2475
2476         ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2477
2478         if (atomic_load(&s1->wpp_err)) {
2479             ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2480             return 0;
2481         }
2482
2483         ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2484         if (ret < 0)
2485             goto error;
2486         hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2487         more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2488
2489         if (more_data < 0) {
2490             ret = more_data;
2491             goto error;
2492         }
2493
2494         ctb_addr_ts++;
2495
2496         ff_hevc_save_states(s, ctb_addr_ts);
2497         ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2498         ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2499
2500         if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2501             atomic_store(&s1->wpp_err, 1);
2502             ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2503             return 0;
2504         }
2505
2506         if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2507             ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2508             ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2509             return ctb_addr_ts;
2510         }
2511         ctb_addr_rs       = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2512         x_ctb+=ctb_size;
2513
2514         if(x_ctb >= s->ps.sps->width) {
2515             break;
2516         }
2517     }
2518     ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2519
2520     return 0;
2521 error:
2522     s->tab_slice_address[ctb_addr_rs] = -1;
2523     atomic_store(&s1->wpp_err, 1);
2524     ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2525     return ret;
2526 }
2527
2528 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2529 {
2530     const uint8_t *data = nal->data;
2531     int length          = nal->size;
2532     HEVCLocalContext *lc = s->HEVClc;
2533     int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2534     int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2535     int64_t offset;
2536     int64_t startheader, cmpt = 0;
2537     int i, j, res = 0;
2538
2539     if (!ret || !arg) {
2540         av_free(ret);
2541         av_free(arg);
2542         return AVERROR(ENOMEM);
2543     }
2544
2545     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) {
2546         av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2547             s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2548             s->ps.sps->ctb_width, s->ps.sps->ctb_height
2549         );
2550         res = AVERROR_INVALIDDATA;
2551         goto error;
2552     }
2553
2554     ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2555
2556     if (!s->sList[1]) {
2557         for (i = 1; i < s->threads_number; i++) {
2558             s->sList[i] = av_malloc(sizeof(HEVCContext));
2559             memcpy(s->sList[i], s, sizeof(HEVCContext));
2560             s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2561             s->sList[i]->HEVClc = s->HEVClcList[i];
2562         }
2563     }
2564
2565     offset = (lc->gb.index >> 3);
2566
2567     for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2568         if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2569             startheader--;
2570             cmpt++;
2571         }
2572     }
2573
2574     for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2575         offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2576         for (j = 0, cmpt = 0, startheader = offset
2577              + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2578             if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2579                 startheader--;
2580                 cmpt++;
2581             }
2582         }
2583         s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2584         s->sh.offset[i - 1] = offset;
2585
2586     }
2587     if (s->sh.num_entry_point_offsets != 0) {
2588         offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2589         if (length < offset) {
2590             av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2591             res = AVERROR_INVALIDDATA;
2592             goto error;
2593         }
2594         s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2595         s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2596
2597     }
2598     s->data = data;
2599
2600     for (i = 1; i < s->threads_number; i++) {
2601         s->sList[i]->HEVClc->first_qp_group = 1;
2602         s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2603         memcpy(s->sList[i], s, sizeof(HEVCContext));
2604         s->sList[i]->HEVClc = s->HEVClcList[i];
2605     }
2606
2607     atomic_store(&s->wpp_err, 0);
2608     ff_reset_entries(s->avctx);
2609
2610     for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2611         arg[i] = i;
2612         ret[i] = 0;
2613     }
2614
2615     if (s->ps.pps->entropy_coding_sync_enabled_flag)
2616         s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2617
2618     for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2619         res += ret[i];
2620 error:
2621     av_free(ret);
2622     av_free(arg);
2623     return res;
2624 }
2625
2626 static int set_side_data(HEVCContext *s)
2627 {
2628     AVFrame *out = s->ref->frame;
2629
2630     if (s->sei.frame_packing.present &&
2631         s->sei.frame_packing.arrangement_type >= 3 &&
2632         s->sei.frame_packing.arrangement_type <= 5 &&
2633         s->sei.frame_packing.content_interpretation_type > 0 &&
2634         s->sei.frame_packing.content_interpretation_type < 3) {
2635         AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2636         if (!stereo)
2637             return AVERROR(ENOMEM);
2638
2639         switch (s->sei.frame_packing.arrangement_type) {
2640         case 3:
2641             if (s->sei.frame_packing.quincunx_subsampling)
2642                 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2643             else
2644                 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2645             break;
2646         case 4:
2647             stereo->type = AV_STEREO3D_TOPBOTTOM;
2648             break;
2649         case 5:
2650             stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2651             break;
2652         }
2653
2654         if (s->sei.frame_packing.content_interpretation_type == 2)
2655             stereo->flags = AV_STEREO3D_FLAG_INVERT;
2656
2657         if (s->sei.frame_packing.arrangement_type == 5) {
2658             if (s->sei.frame_packing.current_frame_is_frame0_flag)
2659                 stereo->view = AV_STEREO3D_VIEW_LEFT;
2660             else
2661                 stereo->view = AV_STEREO3D_VIEW_RIGHT;
2662         }
2663     }
2664
2665     if (s->sei.display_orientation.present &&
2666         (s->sei.display_orientation.anticlockwise_rotation ||
2667          s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) {
2668         double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16);
2669         AVFrameSideData *rotation = av_frame_new_side_data(out,
2670                                                            AV_FRAME_DATA_DISPLAYMATRIX,
2671                                                            sizeof(int32_t) * 9);
2672         if (!rotation)
2673             return AVERROR(ENOMEM);
2674
2675         av_display_rotation_set((int32_t *)rotation->data, angle);
2676         av_display_matrix_flip((int32_t *)rotation->data,
2677                                s->sei.display_orientation.hflip,
2678                                s->sei.display_orientation.vflip);
2679     }
2680
2681     // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2682     // so the side data persists for the entire coded video sequence.
2683     if (s->sei.mastering_display.present > 0 &&
2684         IS_IRAP(s) && s->no_rasl_output_flag) {
2685         s->sei.mastering_display.present--;
2686     }
2687     if (s->sei.mastering_display.present) {
2688         // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2689         const int mapping[3] = {2, 0, 1};
2690         const int chroma_den = 50000;
2691         const int luma_den = 10000;
2692         int i;
2693         AVMasteringDisplayMetadata *metadata =
2694             av_mastering_display_metadata_create_side_data(out);
2695         if (!metadata)
2696             return AVERROR(ENOMEM);
2697
2698         for (i = 0; i < 3; i++) {
2699             const int j = mapping[i];
2700             metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0];
2701             metadata->display_primaries[i][0].den = chroma_den;
2702             metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1];
2703             metadata->display_primaries[i][1].den = chroma_den;
2704         }
2705         metadata->white_point[0].num = s->sei.mastering_display.white_point[0];
2706         metadata->white_point[0].den = chroma_den;
2707         metadata->white_point[1].num = s->sei.mastering_display.white_point[1];
2708         metadata->white_point[1].den = chroma_den;
2709
2710         metadata->max_luminance.num = s->sei.mastering_display.max_luminance;
2711         metadata->max_luminance.den = luma_den;
2712         metadata->min_luminance.num = s->sei.mastering_display.min_luminance;
2713         metadata->min_luminance.den = luma_den;
2714         metadata->has_luminance = 1;
2715         metadata->has_primaries = 1;
2716
2717         av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2718         av_log(s->avctx, AV_LOG_DEBUG,
2719                "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2720                av_q2d(metadata->display_primaries[0][0]),
2721                av_q2d(metadata->display_primaries[0][1]),
2722                av_q2d(metadata->display_primaries[1][0]),
2723                av_q2d(metadata->display_primaries[1][1]),
2724                av_q2d(metadata->display_primaries[2][0]),
2725                av_q2d(metadata->display_primaries[2][1]),
2726                av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2727         av_log(s->avctx, AV_LOG_DEBUG,
2728                "min_luminance=%f, max_luminance=%f\n",
2729                av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2730     }
2731     // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2732     // so the side data persists for the entire coded video sequence.
2733     if (s->sei.content_light.present > 0 &&
2734         IS_IRAP(s) && s->no_rasl_output_flag) {
2735         s->sei.content_light.present--;
2736     }
2737     if (s->sei.content_light.present) {
2738         AVContentLightMetadata *metadata =
2739             av_content_light_metadata_create_side_data(out);
2740         if (!metadata)
2741             return AVERROR(ENOMEM);
2742         metadata->MaxCLL  = s->sei.content_light.max_content_light_level;
2743         metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level;
2744
2745         av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
2746         av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
2747                metadata->MaxCLL, metadata->MaxFALL);
2748     }
2749
2750     if (s->sei.a53_caption.a53_caption) {
2751         AVFrameSideData* sd = av_frame_new_side_data(out,
2752                                                      AV_FRAME_DATA_A53_CC,
2753                                                      s->sei.a53_caption.a53_caption_size);
2754         if (sd)
2755             memcpy(sd->data, s->sei.a53_caption.a53_caption, s->sei.a53_caption.a53_caption_size);
2756         av_freep(&s->sei.a53_caption.a53_caption);
2757         s->sei.a53_caption.a53_caption_size = 0;
2758         s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2759     }
2760
2761     if (s->sei.alternative_transfer.present &&
2762         av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
2763         s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
2764         s->avctx->color_trc = out->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
2765     }
2766
2767     return 0;
2768 }
2769
2770 static int hevc_frame_start(HEVCContext *s)
2771 {
2772     HEVCLocalContext *lc = s->HEVClc;
2773     int pic_size_in_ctb  = ((s->ps.sps->width  >> s->ps.sps->log2_min_cb_size) + 1) *
2774                            ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2775     int ret;
2776
2777     memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2778     memset(s->vertical_bs,   0, s->bs_width * s->bs_height);
2779     memset(s->cbf_luma,      0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2780     memset(s->is_pcm,        0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2781     memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2782
2783     s->is_decoded        = 0;
2784     s->first_nal_type    = s->nal_unit_type;
2785
2786     s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2787
2788     if (s->ps.pps->tiles_enabled_flag)
2789         lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2790
2791     ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2792     if (ret < 0)
2793         goto fail;
2794
2795     ret = ff_hevc_frame_rps(s);
2796     if (ret < 0) {
2797         av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2798         goto fail;
2799     }
2800
2801     s->ref->frame->key_frame = IS_IRAP(s);
2802
2803     ret = set_side_data(s);
2804     if (ret < 0)
2805         goto fail;
2806
2807     s->frame->pict_type = 3 - s->sh.slice_type;
2808
2809     if (!IS_IRAP(s))
2810         ff_hevc_bump_frame(s);
2811
2812     av_frame_unref(s->output_frame);
2813     ret = ff_hevc_output_frame(s, s->output_frame, 0);
2814     if (ret < 0)
2815         goto fail;
2816
2817     if (!s->avctx->hwaccel)
2818         ff_thread_finish_setup(s->avctx);
2819
2820     return 0;
2821
2822 fail:
2823     if (s->ref)
2824         ff_hevc_unref_frame(s, s->ref, ~0);
2825     s->ref = NULL;
2826     return ret;
2827 }
2828
2829 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2830 {
2831     HEVCLocalContext *lc = s->HEVClc;
2832     GetBitContext *gb    = &lc->gb;
2833     int ctb_addr_ts, ret;
2834
2835     *gb              = nal->gb;
2836     s->nal_unit_type = nal->type;
2837     s->temporal_id   = nal->temporal_id;
2838
2839     switch (s->nal_unit_type) {
2840     case HEVC_NAL_VPS:
2841         if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2842             ret = s->avctx->hwaccel->decode_params(s->avctx,
2843                                                    nal->type,
2844                                                    nal->raw_data,
2845                                                    nal->raw_size);
2846             if (ret < 0)
2847                 goto fail;
2848         }
2849         ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2850         if (ret < 0)
2851             goto fail;
2852         break;
2853     case HEVC_NAL_SPS:
2854         if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2855             ret = s->avctx->hwaccel->decode_params(s->avctx,
2856                                                    nal->type,
2857                                                    nal->raw_data,
2858                                                    nal->raw_size);
2859             if (ret < 0)
2860                 goto fail;
2861         }
2862         ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2863                                      s->apply_defdispwin);
2864         if (ret < 0)
2865             goto fail;
2866         break;
2867     case HEVC_NAL_PPS:
2868         if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2869             ret = s->avctx->hwaccel->decode_params(s->avctx,
2870                                                    nal->type,
2871                                                    nal->raw_data,
2872                                                    nal->raw_size);
2873             if (ret < 0)
2874                 goto fail;
2875         }
2876         ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2877         if (ret < 0)
2878             goto fail;
2879         break;
2880     case HEVC_NAL_SEI_PREFIX:
2881     case HEVC_NAL_SEI_SUFFIX:
2882         if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2883             ret = s->avctx->hwaccel->decode_params(s->avctx,
2884                                                    nal->type,
2885                                                    nal->raw_data,
2886                                                    nal->raw_size);
2887             if (ret < 0)
2888                 goto fail;
2889         }
2890         ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
2891         if (ret < 0)
2892             goto fail;
2893         break;
2894     case HEVC_NAL_TRAIL_R:
2895     case HEVC_NAL_TRAIL_N:
2896     case HEVC_NAL_TSA_N:
2897     case HEVC_NAL_TSA_R:
2898     case HEVC_NAL_STSA_N:
2899     case HEVC_NAL_STSA_R:
2900     case HEVC_NAL_BLA_W_LP:
2901     case HEVC_NAL_BLA_W_RADL:
2902     case HEVC_NAL_BLA_N_LP:
2903     case HEVC_NAL_IDR_W_RADL:
2904     case HEVC_NAL_IDR_N_LP:
2905     case HEVC_NAL_CRA_NUT:
2906     case HEVC_NAL_RADL_N:
2907     case HEVC_NAL_RADL_R:
2908     case HEVC_NAL_RASL_N:
2909     case HEVC_NAL_RASL_R:
2910         ret = hls_slice_header(s);
2911         if (ret < 0)
2912             return ret;
2913
2914         if (
2915             (s->avctx->skip_frame >= AVDISCARD_BIDIR && s->sh.slice_type == HEVC_SLICE_B) ||
2916             (s->avctx->skip_frame >= AVDISCARD_NONINTRA && s->sh.slice_type != HEVC_SLICE_I) ||
2917             (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IDR(s))) {
2918             break;
2919         }
2920
2921         if (s->sh.first_slice_in_pic_flag) {
2922             if (s->max_ra == INT_MAX) {
2923                 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2924                     s->max_ra = s->poc;
2925                 } else {
2926                     if (IS_IDR(s))
2927                         s->max_ra = INT_MIN;
2928                 }
2929             }
2930
2931             if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2932                 s->poc <= s->max_ra) {
2933                 s->is_decoded = 0;
2934                 break;
2935             } else {
2936                 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2937                     s->max_ra = INT_MIN;
2938             }
2939
2940             ret = hevc_frame_start(s);
2941             if (ret < 0)
2942                 return ret;
2943         } else if (!s->ref) {
2944             av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2945             goto fail;
2946         }
2947
2948         if (s->nal_unit_type != s->first_nal_type) {
2949             av_log(s->avctx, AV_LOG_ERROR,
2950                    "Non-matching NAL types of the VCL NALUs: %d %d\n",
2951                    s->first_nal_type, s->nal_unit_type);
2952             return AVERROR_INVALIDDATA;
2953         }
2954
2955         if (!s->sh.dependent_slice_segment_flag &&
2956             s->sh.slice_type != HEVC_SLICE_I) {
2957             ret = ff_hevc_slice_rpl(s);
2958             if (ret < 0) {
2959                 av_log(s->avctx, AV_LOG_WARNING,
2960                        "Error constructing the reference lists for the current slice.\n");
2961                 goto fail;
2962             }
2963         }
2964
2965         if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2966             ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2967             if (ret < 0)
2968                 goto fail;
2969         }
2970
2971         if (s->avctx->hwaccel) {
2972             ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2973             if (ret < 0)
2974                 goto fail;
2975         } else {
2976             if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2977                 ctb_addr_ts = hls_slice_data_wpp(s, nal);
2978             else
2979                 ctb_addr_ts = hls_slice_data(s);
2980             if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2981                 s->is_decoded = 1;
2982             }
2983
2984             if (ctb_addr_ts < 0) {
2985                 ret = ctb_addr_ts;
2986                 goto fail;
2987             }
2988         }
2989         break;
2990     case HEVC_NAL_EOS_NUT:
2991     case HEVC_NAL_EOB_NUT:
2992         s->seq_decode = (s->seq_decode + 1) & 0xff;
2993         s->max_ra     = INT_MAX;
2994         break;
2995     case HEVC_NAL_AUD:
2996     case HEVC_NAL_FD_NUT:
2997         break;
2998     default:
2999         av_log(s->avctx, AV_LOG_INFO,
3000                "Skipping NAL unit %d\n", s->nal_unit_type);
3001     }
3002
3003     return 0;
3004 fail:
3005     if (s->avctx->err_recognition & AV_EF_EXPLODE)
3006         return ret;
3007     return 0;
3008 }
3009
3010 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
3011 {
3012     int i, ret = 0;
3013     int eos_at_start = 1;
3014
3015     s->ref = NULL;
3016     s->last_eos = s->eos;
3017     s->eos = 0;
3018
3019     /* split the input packet into NAL units, so we know the upper bound on the
3020      * number of slices in the frame */
3021     ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
3022                                 s->nal_length_size, s->avctx->codec_id, 1);
3023     if (ret < 0) {
3024         av_log(s->avctx, AV_LOG_ERROR,
3025                "Error splitting the input into NAL units.\n");
3026         return ret;
3027     }
3028
3029     for (i = 0; i < s->pkt.nb_nals; i++) {
3030         if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
3031             s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
3032             if (eos_at_start) {
3033                 s->last_eos = 1;
3034             } else {
3035                 s->eos = 1;
3036             }
3037         } else {
3038             eos_at_start = 0;
3039         }
3040     }
3041
3042     /* decode the NAL units */
3043     for (i = 0; i < s->pkt.nb_nals; i++) {
3044         H2645NAL *nal = &s->pkt.nals[i];
3045
3046         if (s->avctx->skip_frame >= AVDISCARD_ALL ||
3047             (s->avctx->skip_frame >= AVDISCARD_NONREF
3048             && ff_hevc_nal_is_nonref(nal->type)))
3049             continue;
3050
3051         ret = decode_nal_unit(s, nal);
3052         if (ret < 0) {
3053             av_log(s->avctx, AV_LOG_WARNING,
3054                    "Error parsing NAL unit #%d.\n", i);
3055             goto fail;
3056         }
3057     }
3058
3059 fail:
3060     if (s->ref && s->threads_type == FF_THREAD_FRAME)
3061         ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3062
3063     return ret;
3064 }
3065
3066 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3067 {
3068     int i;
3069     for (i = 0; i < 16; i++)
3070         av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3071 }
3072
3073 static int verify_md5(HEVCContext *s, AVFrame *frame)
3074 {
3075     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3076     int pixel_shift;
3077     int i, j;
3078
3079     if (!desc)
3080         return AVERROR(EINVAL);
3081
3082     pixel_shift = desc->comp[0].depth > 8;
3083
3084     av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3085            s->poc);
3086
3087     /* the checksums are LE, so we have to byteswap for >8bpp formats
3088      * on BE arches */
3089 #if HAVE_BIGENDIAN
3090     if (pixel_shift && !s->checksum_buf) {
3091         av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3092                        FFMAX3(frame->linesize[0], frame->linesize[1],
3093                               frame->linesize[2]));
3094         if (!s->checksum_buf)
3095             return AVERROR(ENOMEM);
3096     }
3097 #endif
3098
3099     for (i = 0; frame->data[i]; i++) {
3100         int width  = s->avctx->coded_width;
3101         int height = s->avctx->coded_height;
3102         int w = (i == 1 || i == 2) ? (width  >> desc->log2_chroma_w) : width;
3103         int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3104         uint8_t md5[16];
3105
3106         av_md5_init(s->md5_ctx);
3107         for (j = 0; j < h; j++) {
3108             const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3109 #if HAVE_BIGENDIAN
3110             if (pixel_shift) {
3111                 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3112                                     (const uint16_t *) src, w);
3113                 src = s->checksum_buf;
3114             }
3115 #endif
3116             av_md5_update(s->md5_ctx, src, w << pixel_shift);
3117         }
3118         av_md5_final(s->md5_ctx, md5);
3119
3120         if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3121             av_log   (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3122             print_md5(s->avctx, AV_LOG_DEBUG, md5);
3123             av_log   (s->avctx, AV_LOG_DEBUG, "; ");
3124         } else {
3125             av_log   (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3126             print_md5(s->avctx, AV_LOG_ERROR, md5);
3127             av_log   (s->avctx, AV_LOG_ERROR, " != ");
3128             print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
3129             av_log   (s->avctx, AV_LOG_ERROR, "\n");
3130             return AVERROR_INVALIDDATA;
3131         }
3132     }
3133
3134     av_log(s->avctx, AV_LOG_DEBUG, "\n");
3135
3136     return 0;
3137 }
3138
3139 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3140 {
3141     int ret, i;
3142
3143     ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
3144                                    &s->nal_length_size, s->avctx->err_recognition,
3145                                    s->apply_defdispwin, s->avctx);
3146     if (ret < 0)
3147         return ret;
3148
3149     /* export stream parameters from the first SPS */
3150     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3151         if (first && s->ps.sps_list[i]) {
3152             const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3153             export_stream_params(s->avctx, &s->ps, sps);
3154             break;
3155         }
3156     }
3157
3158     return 0;
3159 }
3160
3161 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3162                              AVPacket *avpkt)
3163 {
3164     int ret;
3165     int new_extradata_size;
3166     uint8_t *new_extradata;
3167     HEVCContext *s = avctx->priv_data;
3168
3169     if (!avpkt->size) {
3170         ret = ff_hevc_output_frame(s, data, 1);
3171         if (ret < 0)
3172             return ret;
3173
3174         *got_output = ret;
3175         return 0;
3176     }
3177
3178     new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3179                                             &new_extradata_size);
3180     if (new_extradata && new_extradata_size > 0) {
3181         ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
3182         if (ret < 0)
3183             return ret;
3184     }
3185
3186     s->ref = NULL;
3187     ret    = decode_nal_units(s, avpkt->data, avpkt->size);
3188     if (ret < 0)
3189         return ret;
3190
3191     if (avctx->hwaccel) {
3192         if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3193             av_log(avctx, AV_LOG_ERROR,
3194                    "hardware accelerator failed to decode picture\n");
3195             ff_hevc_unref_frame(s, s->ref, ~0);
3196             return ret;
3197         }
3198     } else {
3199         /* verify the SEI checksum */
3200         if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3201             s->sei.picture_hash.is_md5) {
3202             ret = verify_md5(s, s->ref->frame);
3203             if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3204                 ff_hevc_unref_frame(s, s->ref, ~0);
3205                 return ret;
3206             }
3207         }
3208     }
3209     s->sei.picture_hash.is_md5 = 0;
3210
3211     if (s->is_decoded) {
3212         av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3213         s->is_decoded = 0;
3214     }
3215
3216     if (s->output_frame->buf[0]) {
3217         av_frame_move_ref(data, s->output_frame);
3218         *got_output = 1;
3219     }
3220
3221     return avpkt->size;
3222 }
3223
3224 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3225 {
3226     int ret;
3227
3228     ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3229     if (ret < 0)
3230         return ret;
3231
3232     dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3233     if (!dst->tab_mvf_buf)
3234         goto fail;
3235     dst->tab_mvf = src->tab_mvf;
3236
3237     dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3238     if (!dst->rpl_tab_buf)
3239         goto fail;
3240     dst->rpl_tab = src->rpl_tab;
3241
3242     dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3243     if (!dst->rpl_buf)
3244         goto fail;
3245
3246     dst->poc        = src->poc;
3247     dst->ctb_count  = src->ctb_count;
3248     dst->flags      = src->flags;
3249     dst->sequence   = src->sequence;
3250
3251     if (src->hwaccel_picture_private) {
3252         dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3253         if (!dst->hwaccel_priv_buf)
3254             goto fail;
3255         dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3256     }
3257
3258     return 0;
3259 fail:
3260     ff_hevc_unref_frame(s, dst, ~0);
3261     return AVERROR(ENOMEM);
3262 }
3263
3264 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3265 {
3266     HEVCContext       *s = avctx->priv_data;
3267     int i;
3268
3269     pic_arrays_free(s);
3270
3271     av_freep(&s->md5_ctx);
3272
3273     av_freep(&s->cabac_state);
3274
3275     for (i = 0; i < 3; i++) {
3276         av_freep(&s->sao_pixel_buffer_h[i]);
3277         av_freep(&s->sao_pixel_buffer_v[i]);
3278     }
3279     av_frame_free(&s->output_frame);
3280
3281     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3282         ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3283         av_frame_free(&s->DPB[i].frame);
3284     }
3285
3286     ff_hevc_ps_uninit(&s->ps);
3287
3288     av_freep(&s->sh.entry_point_offset);
3289     av_freep(&s->sh.offset);
3290     av_freep(&s->sh.size);
3291
3292     for (i = 1; i < s->threads_number; i++) {
3293         HEVCLocalContext *lc = s->HEVClcList[i];
3294         if (lc) {
3295             av_freep(&s->HEVClcList[i]);
3296             av_freep(&s->sList[i]);
3297         }
3298     }
3299     if (s->HEVClc == s->HEVClcList[0])
3300         s->HEVClc = NULL;
3301     av_freep(&s->HEVClcList[0]);
3302
3303     ff_h2645_packet_uninit(&s->pkt);
3304
3305     return 0;
3306 }
3307
3308 static av_cold int hevc_init_context(AVCodecContext *avctx)
3309 {
3310     HEVCContext *s = avctx->priv_data;
3311     int i;
3312
3313     s->avctx = avctx;
3314
3315     s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3316     if (!s->HEVClc)
3317         goto fail;
3318     s->HEVClcList[0] = s->HEVClc;
3319     s->sList[0] = s;
3320
3321     s->cabac_state = av_malloc(HEVC_CONTEXTS);
3322     if (!s->cabac_state)
3323         goto fail;
3324
3325     s->output_frame = av_frame_alloc();
3326     if (!s->output_frame)
3327         goto fail;
3328
3329     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3330         s->DPB[i].frame = av_frame_alloc();
3331         if (!s->DPB[i].frame)
3332             goto fail;
3333         s->DPB[i].tf.f = s->DPB[i].frame;
3334     }
3335
3336     s->max_ra = INT_MAX;
3337
3338     s->md5_ctx = av_md5_alloc();
3339     if (!s->md5_ctx)
3340         goto fail;
3341
3342     ff_bswapdsp_init(&s->bdsp);
3343
3344     s->context_initialized = 1;
3345     s->eos = 0;
3346
3347     ff_hevc_reset_sei(&s->sei);
3348
3349     return 0;
3350
3351 fail:
3352     hevc_decode_free(avctx);
3353     return AVERROR(ENOMEM);
3354 }
3355
3356 static int hevc_update_thread_context(AVCodecContext *dst,
3357                                       const AVCodecContext *src)
3358 {
3359     HEVCContext *s  = dst->priv_data;
3360     HEVCContext *s0 = src->priv_data;
3361     int i, ret;
3362
3363     if (!s->context_initialized) {
3364         ret = hevc_init_context(dst);
3365         if (ret < 0)
3366             return ret;
3367     }
3368
3369     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3370         ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3371         if (s0->DPB[i].frame->buf[0]) {
3372             ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3373             if (ret < 0)
3374                 return ret;
3375         }
3376     }
3377
3378     if (s->ps.sps != s0->ps.sps)
3379         s->ps.sps = NULL;
3380     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3381         av_buffer_unref(&s->ps.vps_list[i]);
3382         if (s0->ps.vps_list[i]) {
3383             s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3384             if (!s->ps.vps_list[i])
3385                 return AVERROR(ENOMEM);
3386         }
3387     }
3388
3389     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3390         av_buffer_unref(&s->ps.sps_list[i]);
3391         if (s0->ps.sps_list[i]) {
3392             s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3393             if (!s->ps.sps_list[i])
3394                 return AVERROR(ENOMEM);
3395         }
3396     }
3397
3398     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3399         av_buffer_unref(&s->ps.pps_list[i]);
3400         if (s0->ps.pps_list[i]) {
3401             s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3402             if (!s->ps.pps_list[i])
3403                 return AVERROR(ENOMEM);
3404         }
3405     }
3406
3407     if (s->ps.sps != s0->ps.sps)
3408         if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3409             return ret;
3410
3411     s->seq_decode = s0->seq_decode;
3412     s->seq_output = s0->seq_output;
3413     s->pocTid0    = s0->pocTid0;
3414     s->max_ra     = s0->max_ra;
3415     s->eos        = s0->eos;
3416     s->no_rasl_output_flag = s0->no_rasl_output_flag;
3417
3418     s->is_nalff        = s0->is_nalff;
3419     s->nal_length_size = s0->nal_length_size;
3420
3421     s->threads_number      = s0->threads_number;
3422     s->threads_type        = s0->threads_type;
3423
3424     if (s0->eos) {
3425         s->seq_decode = (s->seq_decode + 1) & 0xff;
3426         s->max_ra = INT_MAX;
3427     }
3428
3429     s->sei.frame_packing        = s0->sei.frame_packing;
3430     s->sei.display_orientation  = s0->sei.display_orientation;
3431     s->sei.mastering_display    = s0->sei.mastering_display;
3432     s->sei.content_light        = s0->sei.content_light;
3433     s->sei.alternative_transfer = s0->sei.alternative_transfer;
3434
3435     return 0;
3436 }
3437
3438 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3439 {
3440     HEVCContext *s = avctx->priv_data;
3441     int ret;
3442
3443     avctx->internal->allocate_progress = 1;
3444
3445     ret = hevc_init_context(avctx);
3446     if (ret < 0)
3447         return ret;
3448
3449     s->enable_parallel_tiles = 0;
3450     s->sei.picture_timing.picture_struct = 0;
3451     s->eos = 1;
3452
3453     atomic_init(&s->wpp_err, 0);
3454
3455     if(avctx->active_thread_type & FF_THREAD_SLICE)
3456         s->threads_number = avctx->thread_count;
3457     else
3458         s->threads_number = 1;
3459
3460     if (avctx->extradata_size > 0 && avctx->extradata) {
3461         ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
3462         if (ret < 0) {
3463             hevc_decode_free(avctx);
3464             return ret;
3465         }
3466     }
3467
3468     if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3469             s->threads_type = FF_THREAD_FRAME;
3470         else
3471             s->threads_type = FF_THREAD_SLICE;
3472
3473     return 0;
3474 }
3475
3476 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3477 {
3478     HEVCContext *s = avctx->priv_data;
3479     int ret;
3480
3481     memset(s, 0, sizeof(*s));
3482
3483     ret = hevc_init_context(avctx);
3484     if (ret < 0)
3485         return ret;
3486
3487     return 0;
3488 }
3489
3490 static void hevc_decode_flush(AVCodecContext *avctx)
3491 {
3492     HEVCContext *s = avctx->priv_data;
3493     ff_hevc_flush_dpb(s);
3494     s->max_ra = INT_MAX;
3495     s->eos = 1;
3496 }
3497
3498 #define OFFSET(x) offsetof(HEVCContext, x)
3499 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3500
3501 static const AVOption options[] = {
3502     { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3503         AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3504     { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3505         AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3506     { NULL },
3507 };
3508
3509 static const AVClass hevc_decoder_class = {
3510     .class_name = "HEVC decoder",
3511     .item_name  = av_default_item_name,
3512     .option     = options,
3513     .version    = LIBAVUTIL_VERSION_INT,
3514 };
3515
3516 AVCodec ff_hevc_decoder = {
3517     .name                  = "hevc",
3518     .long_name             = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3519     .type                  = AVMEDIA_TYPE_VIDEO,
3520     .id                    = AV_CODEC_ID_HEVC,
3521     .priv_data_size        = sizeof(HEVCContext),
3522     .priv_class            = &hevc_decoder_class,
3523     .init                  = hevc_decode_init,
3524     .close                 = hevc_decode_free,
3525     .decode                = hevc_decode_frame,
3526     .flush                 = hevc_decode_flush,
3527     .update_thread_context = hevc_update_thread_context,
3528     .init_thread_copy      = hevc_init_thread_copy,
3529     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3530                              AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3531     .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING,
3532     .profiles              = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
3533     .hw_configs            = (const AVCodecHWConfigInternal*[]) {
3534 #if CONFIG_HEVC_DXVA2_HWACCEL
3535                                HWACCEL_DXVA2(hevc),
3536 #endif
3537 #if CONFIG_HEVC_D3D11VA_HWACCEL
3538                                HWACCEL_D3D11VA(hevc),
3539 #endif
3540 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3541                                HWACCEL_D3D11VA2(hevc),
3542 #endif
3543 #if CONFIG_HEVC_NVDEC_HWACCEL
3544                                HWACCEL_NVDEC(hevc),
3545 #endif
3546 #if CONFIG_HEVC_VAAPI_HWACCEL
3547                                HWACCEL_VAAPI(hevc),
3548 #endif
3549 #if CONFIG_HEVC_VDPAU_HWACCEL
3550                                HWACCEL_VDPAU(hevc),
3551 #endif
3552 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
3553                                HWACCEL_VIDEOTOOLBOX(hevc),
3554 #endif
3555                                NULL
3556                            },
3557 };