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