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

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