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