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