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

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