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

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