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

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