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

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