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

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