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

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