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