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