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