/*

 * HEVC video Decoder

 *

 * Copyright (C) 2012 - 2013 Guillaume Martres

 * Copyright (C) 2012 - 2013 Mickael Raulet

 * Copyright (C) 2012 - 2013 Gildas Cocherel

 * Copyright (C) 2012 - 2013 Wassim Hamidouche

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#include "libavutil/atomic.h"

#include "libavutil/attributes.h"

#include "libavutil/common.h"

#include "libavutil/display.h"

#include "libavutil/internal.h"

#include "libavutil/md5.h"

#include "libavutil/opt.h"

#include "libavutil/pixdesc.h"

#include "libavutil/stereo3d.h"

#include "bswapdsp.h"

#include "bytestream.h"

#include "cabac_functions.h"

#include "golomb.h"

#include "hevc.h"

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 };

/**

 * NOTE: Each function hls_foo correspond to the function foo in the

 * specification (HLS stands for High Level Syntax).

 */

/**

 * Section 5.7

 */

/* free everything allocated  by pic_arrays_init() */

static void pic_arrays_free(HEVCContext *s)

{

    av_freep(&s->sao);

    av_freep(&s->deblock);

    av_freep(&s->skip_flag);

    av_freep(&s->tab_ct_depth);

    av_freep(&s->tab_ipm);

    av_freep(&s->cbf_luma);

    av_freep(&s->is_pcm);

    av_freep(&s->qp_y_tab);

    av_freep(&s->tab_slice_address);

    av_freep(&s->filter_slice_edges);

    av_freep(&s->horizontal_bs);

    av_freep(&s->vertical_bs);

    av_freep(&s->sh.entry_point_offset);

    av_freep(&s->sh.size);

    av_freep(&s->sh.offset);

#ifdef USE_PRED

    av_buffer_pool_uninit(&s->tab_mvf_pool);

    av_buffer_pool_uninit(&s->rpl_tab_pool);

#endif

}

/* allocate arrays that depend on frame dimensions */

static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)

{

    int log2_min_cb_size = sps->log2_min_cb_size;

    int width            = sps->width;

    int height           = sps->height;

    int pic_size_in_ctb  = ((width  >> log2_min_cb_size) + 1) *

                           ((height >> log2_min_cb_size) + 1);

    int ctb_count        = sps->ctb_width * sps->ctb_height;

    int min_pu_size      = sps->min_pu_width * sps->min_pu_height;

    s->bs_width  = (width  >> 2) + 1;

    s->bs_height = (height >> 2) + 1;

    s->sao           = av_mallocz_array(ctb_count, sizeof(*s->sao));

    s->deblock       = av_mallocz_array(ctb_count, sizeof(*s->deblock));

    if (!s->sao || !s->deblock)

        goto fail;

    s->skip_flag    = av_malloc(sps->min_cb_height * sps->min_cb_width);

    s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);

    if (!s->skip_flag || !s->tab_ct_depth)

        goto fail;

    s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);

    s->tab_ipm  = av_mallocz(min_pu_size);

    s->is_pcm   = av_malloc((sps->min_pu_width + 1) * (sps->min_pu_height + 1));

    if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)

        goto fail;

    s->filter_slice_edges = av_malloc(ctb_count);

    s->tab_slice_address  = av_malloc_array(pic_size_in_ctb,

                                      sizeof(*s->tab_slice_address));

    s->qp_y_tab           = av_malloc_array(pic_size_in_ctb,

                                      sizeof(*s->qp_y_tab));

    if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)

        goto fail;

    s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);

    s->vertical_bs   = av_mallocz_array(s->bs_width, s->bs_height);

    if (!s->horizontal_bs || !s->vertical_bs)

        goto fail;

#ifdef USE_PRED

    s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),

                                          av_buffer_allocz);

    s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),

                                          av_buffer_allocz);

    if (!s->tab_mvf_pool || !s->rpl_tab_pool)

        goto fail;

#endif

    return 0;

fail:

    pic_arrays_free(s);

    return AVERROR(ENOMEM);

}

#ifdef USE_PRED

static void pred_weight_table(HEVCContext *s, GetBitContext *gb)

{

    int i = 0;

    int j = 0;

    uint8_t luma_weight_l0_flag[16];

    uint8_t chroma_weight_l0_flag[16];

    uint8_t luma_weight_l1_flag[16];

    uint8_t chroma_weight_l1_flag[16];

    s->sh.luma_log2_weight_denom = get_ue_golomb_long(gb);

    if (s->sps->chroma_format_idc != 0) {

        int delta = get_se_golomb(gb);

        s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);

    }

    for (i = 0; i < s->sh.nb_refs[L0]; i++) {

        luma_weight_l0_flag[i] = get_bits1(gb);

        if (!luma_weight_l0_flag[i]) {

            s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;

            s->sh.luma_offset_l0[i] = 0;

        }

    }

    if (s->sps->chroma_format_idc != 0) {

        for (i = 0; i < s->sh.nb_refs[L0]; i++)

            chroma_weight_l0_flag[i] = get_bits1(gb);

    } else {

        for (i = 0; i < s->sh.nb_refs[L0]; i++)

            chroma_weight_l0_flag[i] = 0;

    }

    for (i = 0; i < s->sh.nb_refs[L0]; i++) {

        if (luma_weight_l0_flag[i]) {

            int delta_luma_weight_l0 = get_se_golomb(gb);

            s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;

            s->sh.luma_offset_l0[i] = get_se_golomb(gb);

        }

        if (chroma_weight_l0_flag[i]) {

            for (j = 0; j < 2; j++) {

                int delta_chroma_weight_l0 = get_se_golomb(gb);

                int delta_chroma_offset_l0 = get_se_golomb(gb);

                s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;

                s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])

                                                                                    >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);

            }

        } else {

            s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;

            s->sh.chroma_offset_l0[i][0] = 0;

            s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;

            s->sh.chroma_offset_l0[i][1] = 0;

        }

    }

#ifdef USE_BIPRED

    if (s->sh.slice_type == B_SLICE) {

        for (i = 0; i < s->sh.nb_refs[L1]; i++) {

            luma_weight_l1_flag[i] = get_bits1(gb);

            if (!luma_weight_l1_flag[i]) {

                s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;

                s->sh.luma_offset_l1[i] = 0;

            }

        }

        if (s->sps->chroma_format_idc != 0) {

            for (i = 0; i < s->sh.nb_refs[L1]; i++)

                chroma_weight_l1_flag[i] = get_bits1(gb);

        } else {

            for (i = 0; i < s->sh.nb_refs[L1]; i++)

                chroma_weight_l1_flag[i] = 0;

        }

        for (i = 0; i < s->sh.nb_refs[L1]; i++) {

            if (luma_weight_l1_flag[i]) {

                int delta_luma_weight_l1 = get_se_golomb(gb);

                s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;

                s->sh.luma_offset_l1[i] = get_se_golomb(gb);

            }

            if (chroma_weight_l1_flag[i]) {

                for (j = 0; j < 2; j++) {

                    int delta_chroma_weight_l1 = get_se_golomb(gb);

                    int delta_chroma_offset_l1 = get_se_golomb(gb);

                    s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;

                    s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])

                                                                                        >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);

                }

            } else {

                s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;

                s->sh.chroma_offset_l1[i][0] = 0;

                s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;

                s->sh.chroma_offset_l1[i][1] = 0;

            }

        }

    }

#endif

}

static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)

{

    const HEVCSPS *sps = s->sps;

    int max_poc_lsb    = 1 << sps->log2_max_poc_lsb;

    int prev_delta_msb = 0;

    unsigned int nb_sps = 0, nb_sh;

    int i;

    rps->nb_refs = 0;

    if (!sps->long_term_ref_pics_present_flag)

        return 0;

    if (sps->num_long_term_ref_pics_sps > 0)

        nb_sps = get_ue_golomb_long(gb);

    nb_sh = get_ue_golomb_long(gb);

    if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))

        return AVERROR_INVALIDDATA;

    rps->nb_refs = nb_sh + nb_sps;

    for (i = 0; i < rps->nb_refs; i++) {

        uint8_t delta_poc_msb_present;

        if (i < nb_sps) {

            uint8_t lt_idx_sps = 0;

            if (sps->num_long_term_ref_pics_sps > 1)

                lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));

            rps->poc[i]  = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];

            rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];

        } else {

            rps->poc[i]  = get_bits(gb, sps->log2_max_poc_lsb);

            rps->used[i] = get_bits1(gb);

        }

        delta_poc_msb_present = get_bits1(gb);

        if (delta_poc_msb_present) {

            int delta = get_ue_golomb_long(gb);

            if (i && i != nb_sps)

                delta += prev_delta_msb;

            rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;

            prev_delta_msb = delta;

        }

    }

    return 0;

}

#endif

static int get_buffer_sao(HEVCContext *s, AVFrame *frame, const HEVCSPS *sps)

{

    int ret, i;

    frame->width  = s->avctx->coded_width  + 2;

    frame->height = s->avctx->coded_height + 2;

    if ((ret = ff_get_buffer(s->avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)

        return ret;

    for (i = 0; frame->data[i]; i++) {

        int offset = frame->linesize[i] + (1 << sps->pixel_shift);

        frame->data[i] += offset;

    }

    frame->width  = s->avctx->coded_width;

    frame->height = s->avctx->coded_height;

    return 0;

}

static int set_sps(HEVCContext *s, const HEVCSPS *sps)

{

    int ret;

    pic_arrays_free(s);

    ret = pic_arrays_init(s, sps);

    if (ret < 0)

        goto fail;

    s->avctx->coded_width         = sps->width;

    s->avctx->coded_height        = sps->height;

    s->avctx->width               = sps->output_width;

    s->avctx->height              = sps->output_height;

    s->avctx->pix_fmt             = sps->pix_fmt;

    s->avctx->has_b_frames        = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;

    ff_set_sar(s->avctx, sps->vui.sar);

    if (sps->vui.video_signal_type_present_flag)

        s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG

                                                               : AVCOL_RANGE_MPEG;

    else

        s->avctx->color_range = AVCOL_RANGE_MPEG;

    if (sps->vui.colour_description_present_flag) {

        s->avctx->color_primaries = sps->vui.colour_primaries;

        s->avctx->color_trc       = sps->vui.transfer_characteristic;

        s->avctx->colorspace      = sps->vui.matrix_coeffs;

    } else {

        s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;

        s->avctx->color_trc       = AVCOL_TRC_UNSPECIFIED;

        s->avctx->colorspace      = AVCOL_SPC_UNSPECIFIED;

    }

#ifdef USE_FUNC_PTR

    ff_hevc_pred_init(&s->hpc,     sps->bit_depth);

#endif

    ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);

#ifdef USE_PRED

    ff_videodsp_init (&s->vdsp,    sps->bit_depth);

#endif

    if (sps->sao_enabled) {

#ifdef USE_SAO_SMALL_BUFFER

        {

            int ctb_size = 1 << s->sps->log2_ctb_size;

            int c_count = (s->sps->chroma_format_idc != 0) ? 3 : 1;

            int c_idx;

            s->sao_pixel_buffer = 

                av_malloc(((ctb_size + 2) * (ctb_size + 2)) << 

                          s->sps->pixel_shift);

            for(c_idx = 0; c_idx < c_count; c_idx++) {

                int w = s->sps->width >> s->sps->hshift[c_idx];

                int h = s->sps->height >> s->sps->vshift[c_idx];

                s->sao_pixel_buffer_h[c_idx] = 

                    av_malloc((w * 2 * s->sps->ctb_height) <<

                              s->sps->pixel_shift);

                s->sao_pixel_buffer_v[c_idx] = 

                    av_malloc((h * 2 * s->sps->ctb_width) << 

                              s->sps->pixel_shift);

            }

        }

#else

        av_frame_unref(s->tmp_frame);

        ret = get_buffer_sao(s, s->tmp_frame, sps);

        s->sao_frame = s->tmp_frame;

#endif

    }

    s->sps = sps;

    s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;

#ifdef USE_FULL

    {

        unsigned int num = 0, den = 0;

        if (s->vps->vps_timing_info_present_flag) {

            num = s->vps->vps_num_units_in_tick;

            den = s->vps->vps_time_scale;

        } else if (sps->vui.vui_timing_info_present_flag) {

            num = sps->vui.vui_num_units_in_tick;

            den = sps->vui.vui_time_scale;

        }

        if (num != 0 && den != 0)

            av_reduce(&s->avctx->framerate.den, &s->avctx->framerate.num,

                      num, den, 1 << 30);

    }

#endif

    return 0;

fail:

    pic_arrays_free(s);

    s->sps = NULL;

    return ret;

}

static int hls_slice_header(HEVCContext *s)

{

    GetBitContext *gb = &s->HEVClc->gb;

    SliceHeader *sh   = &s->sh;

    int i, j, ret;

    // Coded parameters

    sh->first_slice_in_pic_flag = get_bits1(gb);

    if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {

        s->seq_decode = (s->seq_decode + 1) & 0xff;

        s->max_ra     = INT_MAX;

        if (IS_IDR(s))

            ff_hevc_clear_refs(s);

    }

    sh->no_output_of_prior_pics_flag = 0;

    if (IS_IRAP(s))

        sh->no_output_of_prior_pics_flag = get_bits1(gb);

    sh->pps_id = get_ue_golomb_long(gb);

    if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {

        av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);

        return AVERROR_INVALIDDATA;

    }

    if (!sh->first_slice_in_pic_flag &&

        s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {

        av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");

        return AVERROR_INVALIDDATA;

    }

    s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;

    if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)

        sh->no_output_of_prior_pics_flag = 1;

    if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {

        const HEVCSPS* last_sps = s->sps;

        s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;

        if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {

            if (s->sps->width !=  last_sps->width || s->sps->height != last_sps->height ||

                s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering !=

                last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)

                sh->no_output_of_prior_pics_flag = 0;

        }

        ff_hevc_clear_refs(s);

        ret = set_sps(s, s->sps);

        if (ret < 0)

            return ret;

        s->seq_decode = (s->seq_decode + 1) & 0xff;

        s->max_ra     = INT_MAX;

    }

    s->avctx->profile = s->sps->ptl.general_ptl.profile_idc;

    s->avctx->level   = s->sps->ptl.general_ptl.level_idc;

    sh->dependent_slice_segment_flag = 0;

    if (!sh->first_slice_in_pic_flag) {

        int slice_address_length;

        if (s->pps->dependent_slice_segments_enabled_flag)

            sh->dependent_slice_segment_flag = get_bits1(gb);

        slice_address_length = av_ceil_log2(s->sps->ctb_width *

                                            s->sps->ctb_height);

        sh->slice_segment_addr = get_bits(gb, slice_address_length);

        if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {

            av_log(s->avctx, AV_LOG_ERROR,

                   "Invalid slice segment address: %u.\n",

                   sh->slice_segment_addr);

            return AVERROR_INVALIDDATA;

        }

        if (!sh->dependent_slice_segment_flag) {

            sh->slice_addr = sh->slice_segment_addr;

            s->slice_idx++;

        }

    } else {

        sh->slice_segment_addr = sh->slice_addr = 0;

        s->slice_idx           = 0;

        s->slice_initialized   = 0;

    }

    if (!sh->dependent_slice_segment_flag) {

        s->slice_initialized = 0;

        for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)

            skip_bits(gb, 1);  // slice_reserved_undetermined_flag[]

        sh->slice_type = get_ue_golomb_long(gb);

        if (!(sh->slice_type == I_SLICE ||

              sh->slice_type == P_SLICE ||

              sh->slice_type == B_SLICE)) {

            av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",

                   sh->slice_type);

            return AVERROR_INVALIDDATA;

        }

        if (IS_IRAP(s) && sh->slice_type != I_SLICE) {

            av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");

            return AVERROR_INVALIDDATA;

        }

        // when flag is not present, picture is inferred to be output

        sh->pic_output_flag = 1;

        if (s->pps->output_flag_present_flag)

            sh->pic_output_flag = get_bits1(gb);

        if (s->sps->separate_colour_plane_flag)

            sh->colour_plane_id = get_bits(gb, 2);

        if (!IS_IDR(s)) {

#ifdef USE_PRED

            int short_term_ref_pic_set_sps_flag, poc;

            sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);

            poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);

            if (!sh->first_slice_in_pic_flag && poc != s->poc) {

                av_log(s->avctx, AV_LOG_WARNING,

                       "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);

                if (s->avctx->err_recognition & AV_EF_EXPLODE)

                    return AVERROR_INVALIDDATA;

                poc = s->poc;

            }

            s->poc = poc;

            short_term_ref_pic_set_sps_flag = get_bits1(gb);

            if (!short_term_ref_pic_set_sps_flag) {

                ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);

                if (ret < 0)

                    return ret;

                sh->short_term_rps = &sh->slice_rps;

            } else {

                int numbits, rps_idx;

                if (!s->sps->nb_st_rps) {

                    av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");

                    return AVERROR_INVALIDDATA;

                }

                numbits = av_ceil_log2(s->sps->nb_st_rps);

                rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;

                sh->short_term_rps = &s->sps->st_rps[rps_idx];

            }

            ret = decode_lt_rps(s, &sh->long_term_rps, gb);

            if (ret < 0) {

                av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");

                if (s->avctx->err_recognition & AV_EF_EXPLODE)

                    return AVERROR_INVALIDDATA;

            }

            if (s->sps->sps_temporal_mvp_enabled_flag)

                sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);

            else

                sh->slice_temporal_mvp_enabled_flag = 0;

#else

            abort();

#endif

        } else {

            s->sh.short_term_rps = NULL;

            s->poc               = 0;

        }

        /* 8.3.1 */

        if (s->temporal_id == 0 &&

            s->nal_unit_type != NAL_TRAIL_N &&

            s->nal_unit_type != NAL_TSA_N   &&

            s->nal_unit_type != NAL_STSA_N  &&

            s->nal_unit_type != NAL_RADL_N  &&

            s->nal_unit_type != NAL_RADL_R  &&

            s->nal_unit_type != NAL_RASL_N  &&

            s->nal_unit_type != NAL_RASL_R)

            s->pocTid0 = s->poc;

        if (s->sps->sao_enabled) {

            sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);

            if (s->sps->chroma_format_idc != 0) {

                sh->slice_sample_adaptive_offset_flag[1] =

                    sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);

            } else {

                sh->slice_sample_adaptive_offset_flag[1] = 0;

                sh->slice_sample_adaptive_offset_flag[2] = 0;

            }

        } else {

            sh->slice_sample_adaptive_offset_flag[0] = 0;

            sh->slice_sample_adaptive_offset_flag[1] = 0;

            sh->slice_sample_adaptive_offset_flag[2] = 0;

        }

        sh->nb_refs[L0] = sh->nb_refs[L1] = 0;

#ifdef USE_PRED

        if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {

            int nb_refs;

            sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;

            if (sh->slice_type == B_SLICE)

                sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;

            if (get_bits1(gb)) { // num_ref_idx_active_override_flag

                sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;

                if (sh->slice_type == B_SLICE)

                    sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;

            }

            if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {

                av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",

                       sh->nb_refs[L0], sh->nb_refs[L1]);

                return AVERROR_INVALIDDATA;

            }

            sh->rpl_modification_flag[0] = 0;

            sh->rpl_modification_flag[1] = 0;

            nb_refs = ff_hevc_frame_nb_refs(s);

            if (!nb_refs) {

                av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");

                return AVERROR_INVALIDDATA;

            }

            if (s->pps->lists_modification_present_flag && nb_refs > 1) {

                sh->rpl_modification_flag[0] = get_bits1(gb);

                if (sh->rpl_modification_flag[0]) {

                    for (i = 0; i < sh->nb_refs[L0]; i++)

                        sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));

                }

                if (sh->slice_type == B_SLICE) {

                    sh->rpl_modification_flag[1] = get_bits1(gb);

                    if (sh->rpl_modification_flag[1] == 1)

                        for (i = 0; i < sh->nb_refs[L1]; i++)

                            sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));

                }

            }

            if (sh->slice_type == B_SLICE)

                sh->mvd_l1_zero_flag = get_bits1(gb);

            if (s->pps->cabac_init_present_flag)

                sh->cabac_init_flag = get_bits1(gb);

            else

                sh->cabac_init_flag = 0;

            sh->collocated_ref_idx = 0;

            if (sh->slice_temporal_mvp_enabled_flag) {

                sh->collocated_list = L0;

                if (sh->slice_type == B_SLICE)

                    sh->collocated_list = !get_bits1(gb);

                if (sh->nb_refs[sh->collocated_list] > 1) {

                    sh->collocated_ref_idx = get_ue_golomb_long(gb);

                    if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {

                        av_log(s->avctx, AV_LOG_ERROR,

                               "Invalid collocated_ref_idx: %d.\n",

                               sh->collocated_ref_idx);

                        return AVERROR_INVALIDDATA;

                    }

                }

            }

            if ((s->pps->weighted_pred_flag   && sh->slice_type == P_SLICE) ||

                (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {

                pred_weight_table(s, gb);

            }

            sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);

            if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {

                av_log(s->avctx, AV_LOG_ERROR,

                       "Invalid number of merging MVP candidates: %d.\n",

                       sh->max_num_merge_cand);

                return AVERROR_INVALIDDATA;

            }

        }

#endif

        sh->slice_qp_delta = get_se_golomb(gb);

        if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {

            sh->slice_cb_qp_offset = get_se_golomb(gb);

            sh->slice_cr_qp_offset = get_se_golomb(gb);

        } else {

            sh->slice_cb_qp_offset = 0;

            sh->slice_cr_qp_offset = 0;

        }

        if (s->pps->chroma_qp_offset_list_enabled_flag)

            sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);

        else

            sh->cu_chroma_qp_offset_enabled_flag = 0;

        if (s->pps->deblocking_filter_control_present_flag) {

            int deblocking_filter_override_flag = 0;

            if (s->pps->deblocking_filter_override_enabled_flag)

                deblocking_filter_override_flag = get_bits1(gb);

            if (deblocking_filter_override_flag) {

                sh->disable_deblocking_filter_flag = get_bits1(gb);

                if (!sh->disable_deblocking_filter_flag) {

                    sh->beta_offset = get_se_golomb(gb) * 2;

                    sh->tc_offset   = get_se_golomb(gb) * 2;

                }

            } else {

                sh->disable_deblocking_filter_flag = s->pps->disable_dbf;

                sh->beta_offset                    = s->pps->beta_offset;

                sh->tc_offset                      = s->pps->tc_offset;

            }

        } else {

            sh->disable_deblocking_filter_flag = 0;

            sh->beta_offset                    = 0;

            sh->tc_offset                      = 0;

        }

        if (s->pps->seq_loop_filter_across_slices_enabled_flag &&

            (sh->slice_sample_adaptive_offset_flag[0] ||

             sh->slice_sample_adaptive_offset_flag[1] ||

             !sh->disable_deblocking_filter_flag)) {

            sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);

        } else {

            sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;

        }

    } else if (!s->slice_initialized) {

        av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");

        return AVERROR_INVALIDDATA;

    }

    sh->num_entry_point_offsets = 0;

    if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {

        sh->num_entry_point_offsets = get_ue_golomb_long(gb);

        if (sh->num_entry_point_offsets > 0) {

            int offset_len = get_ue_golomb_long(gb) + 1;

            int segments = offset_len >> 4;

            int rest = (offset_len & 15);

            av_freep(&sh->entry_point_offset);

            av_freep(&sh->offset);

            av_freep(&sh->size);

            sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));

            sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));

            sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));

            if (!sh->entry_point_offset || !sh->offset || !sh->size) {

                sh->num_entry_point_offsets = 0;

                av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");

                return AVERROR(ENOMEM);

            }

            for (i = 0; i < sh->num_entry_point_offsets; i++) {

                int val = 0;

                for (j = 0; j < segments; j++) {

                    val <<= 16;

                    val += get_bits(gb, 16);

                }

                if (rest) {

                    val <<= rest;

                    val += get_bits(gb, rest);

                }

                sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size

            }

            if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {

                s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here

                s->threads_number = 1;

            } else

                s->enable_parallel_tiles = 0;

        } else

            s->enable_parallel_tiles = 0;

    }

    if (s->pps->slice_header_extension_present_flag) {

        unsigned int length = get_ue_golomb_long(gb);

        if (length*8LL > get_bits_left(gb)) {

            av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");

            return AVERROR_INVALIDDATA;

        }

        for (i = 0; i < length; i++)

            skip_bits(gb, 8);  // slice_header_extension_data_byte

    }

    // Inferred parameters

    sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;

    if (sh->slice_qp > 51 ||

        sh->slice_qp < -s->sps->qp_bd_offset) {

        av_log(s->avctx, AV_LOG_ERROR,

               "The slice_qp %d is outside the valid range "

               "[%d, 51].\n",

               sh->slice_qp,

               -s->sps->qp_bd_offset);

        return AVERROR_INVALIDDATA;

    }

    sh->slice_ctb_addr_rs = sh->slice_segment_addr;

    if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {

        av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");

        return AVERROR_INVALIDDATA;

    }

    if (get_bits_left(gb) < 0) {

        av_log(s->avctx, AV_LOG_ERROR,

               "Overread slice header by %d bits\n", -get_bits_left(gb));

        return AVERROR_INVALIDDATA;

    }

    s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;

    if (!s->pps->cu_qp_delta_enabled_flag)

        s->HEVClc->qp_y = s->sh.slice_qp;

    s->slice_initialized = 1;

    s->HEVClc->tu.cu_qp_offset_cb = 0;

    s->HEVClc->tu.cu_qp_offset_cr = 0;

    return 0;

}

#define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])

#define SET_SAO(elem, value)                            \

do {                                                    \

    if (!sao_merge_up_flag && !sao_merge_left_flag)     \

        sao->elem = value;                              \

    else if (sao_merge_left_flag)                       \

        sao->elem = CTB(s->sao, rx-1, ry).elem;         \

    else if (sao_merge_up_flag)                         \

        sao->elem = CTB(s->sao, rx, ry-1).elem;         \

    else                                                \

        sao->elem = 0;                                  \

} while (0)

static void hls_sao_param(HEVCContext *s, int rx, int ry)

{

    HEVCLocalContext *lc    = s->HEVClc;

    int sao_merge_left_flag = 0;

    int sao_merge_up_flag   = 0;

    SAOParams *sao          = &CTB(s->sao, rx, ry);

    int c_idx, i, c_count;

    if (s->sh.slice_sample_adaptive_offset_flag[0] ||

        s->sh.slice_sample_adaptive_offset_flag[1]) {

        if (rx > 0) {

            if (lc->ctb_left_flag)

                sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);

        }

        if (ry > 0 && !sao_merge_left_flag) {

            if (lc->ctb_up_flag)

                sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);

        }

    }

    c_count = (s->sps->chroma_format_idc != 0) ? 3 : 1;

    for (c_idx = 0; c_idx < c_count; c_idx++) {

        int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :

                                                 s->pps->log2_sao_offset_scale_chroma;

        if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {

            sao->type_idx[c_idx] = SAO_NOT_APPLIED;

            continue;

        }

        if (c_idx == 2) {