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

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