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