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