hevc_ps.c 65.9 KB
Newer Older
1
/*
Guillaume Martres's avatar
Guillaume Martres committed
2
 * HEVC Parameter Set decoding
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 *
 * Copyright (C) 2012 - 2103 Guillaume Martres
 * Copyright (C) 2012 - 2103 Mickael Raulet
 * Copyright (C) 2012 - 2013 Gildas Cocherel
 * Copyright (C) 2013 Vittorio Giovara
 *
 * 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/imgutils.h"
Guillaume Martres's avatar
Guillaume Martres committed
27
#include "golomb.h"
28
#include "hevc_data.h"
29
#include "hevc_ps.h"
30 31 32 33 34 35 36 37 38

static const uint8_t default_scaling_list_intra[] = {
    16, 16, 16, 16, 17, 18, 21, 24,
    16, 16, 16, 16, 17, 19, 22, 25,
    16, 16, 17, 18, 20, 22, 25, 29,
    16, 16, 18, 21, 24, 27, 31, 36,
    17, 17, 20, 24, 30, 35, 41, 47,
    18, 19, 22, 27, 35, 44, 54, 65,
    21, 22, 25, 31, 41, 54, 70, 88,
Guillaume Martres's avatar
Guillaume Martres committed
39
    24, 25, 29, 36, 47, 65, 88, 115
40 41 42 43 44 45 46 47 48 49 50 51 52 53
};

static const uint8_t default_scaling_list_inter[] = {
    16, 16, 16, 16, 17, 18, 20, 24,
    16, 16, 16, 17, 18, 20, 24, 25,
    16, 16, 17, 18, 20, 24, 25, 28,
    16, 17, 18, 20, 24, 25, 28, 33,
    17, 18, 20, 24, 25, 28, 33, 41,
    18, 20, 24, 25, 28, 33, 41, 54,
    20, 24, 25, 28, 33, 41, 54, 71,
    24, 25, 28, 33, 41, 54, 71, 91
};

static const AVRational vui_sar[] = {
Guillaume Martres's avatar
Guillaume Martres committed
54 55
    {  0,   1 },
    {  1,   1 },
56 57 58 59 60 61 62 63 64 65 66 67
    { 12,  11 },
    { 10,  11 },
    { 16,  11 },
    { 40,  33 },
    { 24,  11 },
    { 20,  11 },
    { 32,  11 },
    { 80,  33 },
    { 18,  11 },
    { 15,  11 },
    { 64,  33 },
    { 160, 99 },
Guillaume Martres's avatar
Guillaume Martres committed
68 69 70
    {  4,   3 },
    {  3,   2 },
    {  2,   1 },
71 72
};

73 74 75 76 77 78 79 80
static const uint8_t hevc_sub_width_c[] = {
    1, 2, 2, 1
};

static const uint8_t hevc_sub_height_c[] = {
    1, 2, 1, 1
};

81
static void remove_pps(HEVCParamSets *s, int id)
82 83 84 85 86 87
{
    if (s->pps_list[id] && s->pps == (const HEVCPPS*)s->pps_list[id]->data)
        s->pps = NULL;
    av_buffer_unref(&s->pps_list[id]);
}

88
static void remove_sps(HEVCParamSets *s, int id)
89 90 91 92 93 94 95 96 97 98
{
    int i;
    if (s->sps_list[id]) {
        if (s->sps == (const HEVCSPS*)s->sps_list[id]->data)
            s->sps = NULL;

        /* drop all PPS that depend on this SPS */
        for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
            if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == id)
                remove_pps(s, i);
99

100
        av_assert0(!(s->sps_list[id] && s->sps == (HEVCSPS*)s->sps_list[id]->data));
101 102 103 104
    }
    av_buffer_unref(&s->sps_list[id]);
}

105
static void remove_vps(HEVCParamSets *s, int id)
106 107 108 109 110 111 112 113 114 115 116 117 118
{
    int i;
    if (s->vps_list[id]) {
        if (s->vps == (const HEVCVPS*)s->vps_list[id]->data)
            s->vps = NULL;

        for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
            if (s->sps_list[i] && ((HEVCSPS*)s->sps_list[i]->data)->vps_id == id)
                remove_sps(s, i);
    }
    av_buffer_unref(&s->vps_list[id]);
}

119 120
int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
                                  ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
121 122 123 124 125 126 127 128 129
{
    uint8_t rps_predict = 0;
    int delta_poc;
    int k0 = 0;
    int k1 = 0;
    int k  = 0;
    int i;

    if (rps != sps->st_rps && sps->nb_st_rps)
Guillaume Martres's avatar
Guillaume Martres committed
130
        rps_predict = get_bits1(gb);
131 132 133

    if (rps_predict) {
        const ShortTermRPS *rps_ridx;
134 135
        int delta_rps;
        unsigned abs_delta_rps;
136 137 138 139
        uint8_t use_delta_flag = 0;
        uint8_t delta_rps_sign;

        if (is_slice_header) {
140
            unsigned int delta_idx = get_ue_golomb_long(gb) + 1;
141
            if (delta_idx > sps->nb_st_rps) {
142
                av_log(avctx, AV_LOG_ERROR,
Guillaume Martres's avatar
Guillaume Martres committed
143 144
                       "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
                       delta_idx, sps->nb_st_rps);
145 146 147
                return AVERROR_INVALIDDATA;
            }
            rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
148
            rps->rps_idx_num_delta_pocs = rps_ridx->num_delta_pocs;
149 150 151 152
        } else
            rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];

        delta_rps_sign = get_bits1(gb);
153
        abs_delta_rps  = get_ue_golomb_long(gb) + 1;
154
        if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
155
            av_log(avctx, AV_LOG_ERROR,
156 157 158 159
                   "Invalid value of abs_delta_rps: %d\n",
                   abs_delta_rps);
            return AVERROR_INVALIDDATA;
        }
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
        delta_rps      = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
        for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
            int used = rps->used[k] = get_bits1(gb);

            if (!used)
                use_delta_flag = get_bits1(gb);

            if (used || use_delta_flag) {
                if (i < rps_ridx->num_delta_pocs)
                    delta_poc = delta_rps + rps_ridx->delta_poc[i];
                else
                    delta_poc = delta_rps;
                rps->delta_poc[k] = delta_poc;
                if (delta_poc < 0)
                    k0++;
                else
                    k1++;
                k++;
            }
        }

181 182 183 184 185 186
        if (k >= FF_ARRAY_ELEMS(rps->used)) {
            av_log(avctx, AV_LOG_ERROR,
                   "Invalid num_delta_pocs: %d\n", k);
            return AVERROR_INVALIDDATA;
        }

187 188 189 190 191 192 193 194
        rps->num_delta_pocs    = k;
        rps->num_negative_pics = k0;
        // sort in increasing order (smallest first)
        if (rps->num_delta_pocs != 0) {
            int used, tmp;
            for (i = 1; i < rps->num_delta_pocs; i++) {
                delta_poc = rps->delta_poc[i];
                used      = rps->used[i];
Guillaume Martres's avatar
Guillaume Martres committed
195
                for (k = i - 1; k >= 0; k--) {
196
                    tmp = rps->delta_poc[k];
Guillaume Martres's avatar
Guillaume Martres committed
197 198 199 200 201
                    if (delta_poc < tmp) {
                        rps->delta_poc[k + 1] = tmp;
                        rps->used[k + 1]      = rps->used[k];
                        rps->delta_poc[k]     = delta_poc;
                        rps->used[k]          = used;
202 203 204 205 206 207 208 209
                    }
                }
            }
        }
        if ((rps->num_negative_pics >> 1) != 0) {
            int used;
            k = rps->num_negative_pics - 1;
            // flip the negative values to largest first
Guillaume Martres's avatar
Guillaume Martres committed
210 211 212 213 214 215 216
            for (i = 0; i < rps->num_negative_pics >> 1; i++) {
                delta_poc         = rps->delta_poc[i];
                used              = rps->used[i];
                rps->delta_poc[i] = rps->delta_poc[k];
                rps->used[i]      = rps->used[k];
                rps->delta_poc[k] = delta_poc;
                rps->used[k]      = used;
217 218 219 220 221
                k--;
            }
        }
    } else {
        unsigned int prev, nb_positive_pics;
222 223
        rps->num_negative_pics = get_ue_golomb_long(gb);
        nb_positive_pics       = get_ue_golomb_long(gb);
224

225 226
        if (rps->num_negative_pics >= HEVC_MAX_REFS ||
            nb_positive_pics >= HEVC_MAX_REFS) {
227
            av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
228 229 230 231 232 233 234
            return AVERROR_INVALIDDATA;
        }

        rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
        if (rps->num_delta_pocs) {
            prev = 0;
            for (i = 0; i < rps->num_negative_pics; i++) {
235
                delta_poc = get_ue_golomb_long(gb) + 1;
236 237 238 239 240 241
                if (delta_poc < 1 || delta_poc > 32768) {
                    av_log(avctx, AV_LOG_ERROR,
                        "Invalid value of delta_poc: %d\n",
                        delta_poc);
                    return AVERROR_INVALIDDATA;
                }
242 243
                prev -= delta_poc;
                rps->delta_poc[i] = prev;
Guillaume Martres's avatar
Guillaume Martres committed
244
                rps->used[i]      = get_bits1(gb);
245 246 247
            }
            prev = 0;
            for (i = 0; i < nb_positive_pics; i++) {
248
                delta_poc = get_ue_golomb_long(gb) + 1;
249 250 251 252 253 254
                if (delta_poc < 1 || delta_poc > 32768) {
                    av_log(avctx, AV_LOG_ERROR,
                        "Invalid value of delta_poc: %d\n",
                        delta_poc);
                    return AVERROR_INVALIDDATA;
                }
255 256
                prev += delta_poc;
                rps->delta_poc[rps->num_negative_pics + i] = prev;
Guillaume Martres's avatar
Guillaume Martres committed
257
                rps->used[rps->num_negative_pics + i]      = get_bits1(gb);
258 259 260 261 262 263
            }
        }
    }
    return 0;
}

gcocherel's avatar
gcocherel committed
264

265
static int decode_profile_tier_level(GetBitContext *gb, AVCodecContext *avctx,
266
                                      PTLCommon *ptl)
267
{
gcocherel's avatar
gcocherel committed
268
    int i;
269

270 271 272
    if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 16 + 16 + 12)
        return -1;

gcocherel's avatar
gcocherel committed
273 274 275
    ptl->profile_space = get_bits(gb, 2);
    ptl->tier_flag     = get_bits1(gb);
    ptl->profile_idc   = get_bits(gb, 5);
276
    if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN)
277
        av_log(avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
278
    else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_10)
279
        av_log(avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
280
    else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_STILL_PICTURE)
281
        av_log(avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
282
    else if (ptl->profile_idc == FF_PROFILE_HEVC_REXT)
283
        av_log(avctx, AV_LOG_DEBUG, "Range Extension profile bitstream\n");
284
    else
285
        av_log(avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
286

287
    for (i = 0; i < 32; i++) {
gcocherel's avatar
gcocherel committed
288
        ptl->profile_compatibility_flag[i] = get_bits1(gb);
289 290 291 292

        if (ptl->profile_idc == 0 && i > 0 && ptl->profile_compatibility_flag[i])
            ptl->profile_idc = i;
    }
gcocherel's avatar
gcocherel committed
293 294 295 296
    ptl->progressive_source_flag    = get_bits1(gb);
    ptl->interlaced_source_flag     = get_bits1(gb);
    ptl->non_packed_constraint_flag = get_bits1(gb);
    ptl->frame_only_constraint_flag = get_bits1(gb);
297 298 299 300

    skip_bits(gb, 16); // XXX_reserved_zero_44bits[0..15]
    skip_bits(gb, 16); // XXX_reserved_zero_44bits[16..31]
    skip_bits(gb, 12); // XXX_reserved_zero_44bits[32..43]
301 302

    return 0;
gcocherel's avatar
gcocherel committed
303 304
}

305
static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx,
306
                      PTL *ptl, int max_num_sub_layers)
gcocherel's avatar
gcocherel committed
307 308
{
    int i;
309
    if (decode_profile_tier_level(gb, avctx, &ptl->general_ptl) < 0 ||
310
        get_bits_left(gb) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
311
        av_log(avctx, AV_LOG_ERROR, "PTL information too short\n");
312 313 314
        return -1;
    }

315
    ptl->general_ptl.level_idc = get_bits(gb, 8);
316 317 318

    for (i = 0; i < max_num_sub_layers - 1; i++) {
        ptl->sub_layer_profile_present_flag[i] = get_bits1(gb);
Guillaume Martres's avatar
Guillaume Martres committed
319
        ptl->sub_layer_level_present_flag[i]   = get_bits1(gb);
320
    }
321

gcocherel's avatar
gcocherel committed
322
    if (max_num_sub_layers - 1> 0)
323
        for (i = max_num_sub_layers - 1; i < 8; i++)
gcocherel's avatar
gcocherel committed
324
            skip_bits(gb, 2); // reserved_zero_2bits[i]
325
    for (i = 0; i < max_num_sub_layers - 1; i++) {
326
        if (ptl->sub_layer_profile_present_flag[i] &&
327 328
            decode_profile_tier_level(gb, avctx, &ptl->sub_layer_ptl[i]) < 0) {
            av_log(avctx, AV_LOG_ERROR,
329 330 331 332 333
                   "PTL information for sublayer %i too short\n", i);
            return -1;
        }
        if (ptl->sub_layer_level_present_flag[i]) {
            if (get_bits_left(gb) < 8) {
334
                av_log(avctx, AV_LOG_ERROR,
335 336 337 338 339
                       "Not enough data for sublayer %i level_idc\n", i);
                return -1;
            } else
                ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
        }
340
    }
341 342

    return 0;
343 344
}

345
static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb,
Guillaume Martres's avatar
Guillaume Martres committed
346
                                int subpic_params_present)
347
{
Mickaël Raulet's avatar
Mickaël Raulet committed
348 349 350 351 352 353 354 355 356 357 358 359 360 361
    int i;

    for (i = 0; i < nb_cpb; i++) {
        get_ue_golomb_long(gb); // bit_rate_value_minus1
        get_ue_golomb_long(gb); // cpb_size_value_minus1

        if (subpic_params_present) {
            get_ue_golomb_long(gb); // cpb_size_du_value_minus1
            get_ue_golomb_long(gb); // bit_rate_du_value_minus1
        }
        skip_bits1(gb); // cbr_flag
    }
}

362
static int decode_hrd(GetBitContext *gb, int common_inf_present,
363
                       int max_sublayers)
Mickaël Raulet's avatar
Mickaël Raulet committed
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
{
    int nal_params_present = 0, vcl_params_present = 0;
    int subpic_params_present = 0;
    int i;

    if (common_inf_present) {
        nal_params_present = get_bits1(gb);
        vcl_params_present = get_bits1(gb);

        if (nal_params_present || vcl_params_present) {
            subpic_params_present = get_bits1(gb);

            if (subpic_params_present) {
                skip_bits(gb, 8); // tick_divisor_minus2
                skip_bits(gb, 5); // du_cpb_removal_delay_increment_length_minus1
                skip_bits(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
                skip_bits(gb, 5); // dpb_output_delay_du_length_minus1
            }

            skip_bits(gb, 4); // bit_rate_scale
            skip_bits(gb, 4); // cpb_size_scale

            if (subpic_params_present)
387
                skip_bits(gb, 4);  // cpb_size_du_scale
Mickaël Raulet's avatar
Mickaël Raulet committed
388 389 390 391 392 393 394 395 396

            skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
            skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
            skip_bits(gb, 5); // dpb_output_delay_length_minus1
        }
    }

    for (i = 0; i < max_sublayers; i++) {
        int low_delay = 0;
397
        unsigned int nb_cpb = 1;
Mickaël Raulet's avatar
Mickaël Raulet committed
398 399 400 401 402 403
        int fixed_rate = get_bits1(gb);

        if (!fixed_rate)
            fixed_rate = get_bits1(gb);

        if (fixed_rate)
404
            get_ue_golomb_long(gb);  // elemental_duration_in_tc_minus1
Mickaël Raulet's avatar
Mickaël Raulet committed
405 406 407
        else
            low_delay = get_bits1(gb);

408
        if (!low_delay) {
Mickaël Raulet's avatar
Mickaël Raulet committed
409
            nb_cpb = get_ue_golomb_long(gb) + 1;
410
            if (nb_cpb < 1 || nb_cpb > 32) {
411
                av_log(NULL, AV_LOG_ERROR, "nb_cpb %d invalid\n", nb_cpb);
412 413 414
                return AVERROR_INVALIDDATA;
            }
        }
Mickaël Raulet's avatar
Mickaël Raulet committed
415 416

        if (nal_params_present)
417
            decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
Mickaël Raulet's avatar
Mickaël Raulet committed
418
        if (vcl_params_present)
419
            decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
Mickaël Raulet's avatar
Mickaël Raulet committed
420
    }
421
    return 0;
422 423
}

424 425
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
                           HEVCParamSets *ps)
426 427 428
{
    int i,j;
    int vps_id = 0;
429
    ptrdiff_t nal_size;
Guillaume Martres's avatar
Guillaume Martres committed
430
    HEVCVPS *vps;
gcocherel's avatar
gcocherel committed
431 432 433 434 435
    AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));

    if (!vps_buf)
        return AVERROR(ENOMEM);
    vps = (HEVCVPS*)vps_buf->data;
436

437
    av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
438

439 440 441 442 443 444 445 446 447 448 449
    nal_size = gb->buffer_end - gb->buffer;
    if (nal_size > sizeof(vps->data)) {
        av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized VPS "
               "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
               nal_size, sizeof(vps->data));
        vps->data_size = sizeof(vps->data);
    } else {
        vps->data_size = nal_size;
    }
    memcpy(vps->data, gb->buffer, vps->data_size);

450
    vps_id = get_bits(gb, 4);
451
    if (vps_id >= HEVC_MAX_VPS_COUNT) {
452
        av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
453 454 455 456
        goto err;
    }

    if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
457
        av_log(avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
458 459 460 461 462 463 464 465
        goto err;
    }

    vps->vps_max_layers               = get_bits(gb, 6) + 1;
    vps->vps_max_sub_layers           = get_bits(gb, 3) + 1;
    vps->vps_temporal_id_nesting_flag = get_bits1(gb);

    if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
466
        av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
467 468 469
        goto err;
    }

470
    if (vps->vps_max_sub_layers > HEVC_MAX_SUB_LAYERS) {
471
        av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
472 473 474 475
               vps->vps_max_sub_layers);
        goto err;
    }

476
    if (parse_ptl(gb, avctx, &vps->ptl, vps->vps_max_sub_layers) < 0)
477
        goto err;
478

479 480 481 482
    vps->vps_sub_layer_ordering_info_present_flag = get_bits1(gb);

    i = vps->vps_sub_layer_ordering_info_present_flag ? 0 : vps->vps_max_sub_layers - 1;
    for (; i < vps->vps_max_sub_layers; i++) {
483 484 485
        vps->vps_max_dec_pic_buffering[i] = get_ue_golomb_long(gb) + 1;
        vps->vps_num_reorder_pics[i]      = get_ue_golomb_long(gb);
        vps->vps_max_latency_increase[i]  = get_ue_golomb_long(gb) - 1;
486

James Almer's avatar
James Almer committed
487
        if (vps->vps_max_dec_pic_buffering[i] > HEVC_MAX_DPB_SIZE || !vps->vps_max_dec_pic_buffering[i]) {
488
            av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
489 490 491
                   vps->vps_max_dec_pic_buffering[i] - 1);
            goto err;
        }
492
        if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
493
            av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
494
                   vps->vps_num_reorder_pics[i]);
495
            if (avctx->err_recognition & AV_EF_EXPLODE)
Kieran's avatar
Kieran committed
496
                goto err;
497 498 499 500
        }
    }

    vps->vps_max_layer_id   = get_bits(gb, 6);
501
    vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
502 503
    if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
        (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
504
        av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
505 506 507
        goto err;
    }

508 509
    for (i = 1; i < vps->vps_num_layer_sets; i++)
        for (j = 0; j <= vps->vps_max_layer_id; j++)
510
            skip_bits(gb, 1);  // layer_id_included_flag[i][j]
511 512 513 514 515 516 517

    vps->vps_timing_info_present_flag = get_bits1(gb);
    if (vps->vps_timing_info_present_flag) {
        vps->vps_num_units_in_tick               = get_bits_long(gb, 32);
        vps->vps_time_scale                      = get_bits_long(gb, 32);
        vps->vps_poc_proportional_to_timing_flag = get_bits1(gb);
        if (vps->vps_poc_proportional_to_timing_flag)
518 519
            vps->vps_num_ticks_poc_diff_one = get_ue_golomb_long(gb) + 1;
        vps->vps_num_hrd_parameters = get_ue_golomb_long(gb);
520
        if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
521
            av_log(avctx, AV_LOG_ERROR,
522 523 524
                   "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
            goto err;
        }
Mickaël Raulet's avatar
Mickaël Raulet committed
525 526 527 528 529 530
        for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
            int common_inf_present = 1;

            get_ue_golomb_long(gb); // hrd_layer_set_idx
            if (i)
                common_inf_present = get_bits1(gb);
531
            decode_hrd(gb, common_inf_present, vps->vps_max_sub_layers);
532 533
        }
    }
534
    get_bits1(gb); /* vps_extension_flag */
gcocherel's avatar
gcocherel committed
535

536
    if (get_bits_left(gb) < 0) {
537
        av_log(avctx, AV_LOG_ERROR,
538
               "Overread VPS by %d bits\n", -get_bits_left(gb));
539
        if (ps->vps_list[vps_id])
540
            goto err;
541 542
    }

543 544
    if (ps->vps_list[vps_id] &&
        !memcmp(ps->vps_list[vps_id]->data, vps_buf->data, vps_buf->size)) {
545 546
        av_buffer_unref(&vps_buf);
    } else {
547 548
        remove_vps(ps, vps_id);
        ps->vps_list[vps_id] = vps_buf;
549 550
    }

551 552 553
    return 0;

err:
gcocherel's avatar
gcocherel committed
554
    av_buffer_unref(&vps_buf);
555 556 557
    return AVERROR_INVALIDDATA;
}

558 559
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
                       int apply_defdispwin, HEVCSPS *sps)
560
{
561
    VUI backup_vui, *vui = &sps->vui;
562
    GetBitContext backup;
563
    int sar_present, alt = 0;
564

565
    av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n");
566 567 568 569 570 571 572 573 574 575

    sar_present = get_bits1(gb);
    if (sar_present) {
        uint8_t sar_idx = get_bits(gb, 8);
        if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
            vui->sar = vui_sar[sar_idx];
        else if (sar_idx == 255) {
            vui->sar.num = get_bits(gb, 16);
            vui->sar.den = get_bits(gb, 16);
        } else
576
            av_log(avctx, AV_LOG_WARNING,
Guillaume Martres's avatar
Guillaume Martres committed
577
                   "Unknown SAR index: %u.\n", sar_idx);
578 579 580 581 582 583 584 585 586 587 588
    }

    vui->overscan_info_present_flag = get_bits1(gb);
    if (vui->overscan_info_present_flag)
        vui->overscan_appropriate_flag = get_bits1(gb);

    vui->video_signal_type_present_flag = get_bits1(gb);
    if (vui->video_signal_type_present_flag) {
        vui->video_format                    = get_bits(gb, 3);
        vui->video_full_range_flag           = get_bits1(gb);
        vui->colour_description_present_flag = get_bits1(gb);
589 590
        if (vui->video_full_range_flag && sps->pix_fmt == AV_PIX_FMT_YUV420P)
            sps->pix_fmt = AV_PIX_FMT_YUVJ420P;
591 592 593 594
        if (vui->colour_description_present_flag) {
            vui->colour_primaries        = get_bits(gb, 8);
            vui->transfer_characteristic = get_bits(gb, 8);
            vui->matrix_coeffs           = get_bits(gb, 8);
595 596

            // Set invalid values to "unspecified"
597
            if (!av_color_primaries_name(vui->colour_primaries))
598
                vui->colour_primaries = AVCOL_PRI_UNSPECIFIED;
599
            if (!av_color_transfer_name(vui->transfer_characteristic))
600
                vui->transfer_characteristic = AVCOL_TRC_UNSPECIFIED;
601
            if (!av_color_space_name(vui->matrix_coeffs))
602
                vui->matrix_coeffs = AVCOL_SPC_UNSPECIFIED;
603 604 605 606 607 608 609 610 611 612 613 614 615
            if (vui->matrix_coeffs == AVCOL_SPC_RGB) {
                switch (sps->pix_fmt) {
                case AV_PIX_FMT_YUV444P:
                    sps->pix_fmt = AV_PIX_FMT_GBRP;
                    break;
                case AV_PIX_FMT_YUV444P10:
                    sps->pix_fmt = AV_PIX_FMT_GBRP10;
                    break;
                case AV_PIX_FMT_YUV444P12:
                    sps->pix_fmt = AV_PIX_FMT_GBRP12;
                    break;
                }
            }
616 617 618 619 620
        }
    }

    vui->chroma_loc_info_present_flag = get_bits1(gb);
    if (vui->chroma_loc_info_present_flag) {
621 622
        vui->chroma_sample_loc_type_top_field    = get_ue_golomb_long(gb);
        vui->chroma_sample_loc_type_bottom_field = get_ue_golomb_long(gb);
623 624 625 626 627 628
    }

    vui->neutra_chroma_indication_flag = get_bits1(gb);
    vui->field_seq_flag                = get_bits1(gb);
    vui->frame_field_info_present_flag = get_bits1(gb);

629 630 631
    // Backup context in case an alternate header is detected
    memcpy(&backup, gb, sizeof(backup));
    memcpy(&backup_vui, vui, sizeof(backup_vui));
632 633
    if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
        vui->default_display_window_flag = 0;
634
        av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
635 636
    } else
        vui->default_display_window_flag = get_bits1(gb);
637

638
    if (vui->default_display_window_flag) {
639 640
        int vert_mult  = hevc_sub_height_c[sps->chroma_format_idc];
        int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
641 642 643 644
        vui->def_disp_win.left_offset   = get_ue_golomb_long(gb) * horiz_mult;
        vui->def_disp_win.right_offset  = get_ue_golomb_long(gb) * horiz_mult;
        vui->def_disp_win.top_offset    = get_ue_golomb_long(gb) *  vert_mult;
        vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) *  vert_mult;
645

646
        if (apply_defdispwin &&
647
            avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
648
            av_log(avctx, AV_LOG_DEBUG,
649 650 651 652 653 654 655 656 657 658 659 660 661 662
                   "discarding vui default display window, "
                   "original values are l:%u r:%u t:%u b:%u\n",
                   vui->def_disp_win.left_offset,
                   vui->def_disp_win.right_offset,
                   vui->def_disp_win.top_offset,
                   vui->def_disp_win.bottom_offset);

            vui->def_disp_win.left_offset   =
            vui->def_disp_win.right_offset  =
            vui->def_disp_win.top_offset    =
            vui->def_disp_win.bottom_offset = 0;
        }
    }

663
timing_info:
664
    vui->vui_timing_info_present_flag = get_bits1(gb);
gcocherel's avatar
gcocherel committed
665

666
    if (vui->vui_timing_info_present_flag) {
667
        if( get_bits_left(gb) < 66 && !alt) {
668 669
            // The alternate syntax seem to have timing info located
            // at where def_disp_win is normally located
670
            av_log(avctx, AV_LOG_WARNING,
671
                   "Strange VUI timing information, retrying...\n");
672
            memcpy(vui, &backup_vui, sizeof(backup_vui));
673 674
            memcpy(gb, &backup, sizeof(backup));
            alt = 1;
675
            goto timing_info;
676
        }
677 678
        vui->vui_num_units_in_tick               = get_bits_long(gb, 32);
        vui->vui_time_scale                      = get_bits_long(gb, 32);
679
        if (alt) {
680
            av_log(avctx, AV_LOG_INFO, "Retry got %"PRIu32"/%"PRIu32" fps\n",
681 682
                   vui->vui_time_scale, vui->vui_num_units_in_tick);
        }
683 684
        vui->vui_poc_proportional_to_timing_flag = get_bits1(gb);
        if (vui->vui_poc_proportional_to_timing_flag)
685
            vui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb_long(gb);
686 687
        vui->vui_hrd_parameters_present_flag = get_bits1(gb);
        if (vui->vui_hrd_parameters_present_flag)
688
            decode_hrd(gb, 1, sps->max_sub_layers);
689 690 691 692
    }

    vui->bitstream_restriction_flag = get_bits1(gb);
    if (vui->bitstream_restriction_flag) {
693 694 695 696 697 698 699 700 701
        if (get_bits_left(gb) < 8 && !alt) {
            av_log(avctx, AV_LOG_WARNING,
                   "Strange VUI bitstream restriction information, retrying"
                   " from timing information...\n");
            memcpy(vui, &backup_vui, sizeof(backup_vui));
            memcpy(gb, &backup, sizeof(backup));
            alt = 1;
            goto timing_info;
        }
702 703 704
        vui->tiles_fixed_structure_flag              = get_bits1(gb);
        vui->motion_vectors_over_pic_boundaries_flag = get_bits1(gb);
        vui->restricted_ref_pic_lists_flag           = get_bits1(gb);
705 706 707 708 709
        vui->min_spatial_segmentation_idc            = get_ue_golomb_long(gb);
        vui->max_bytes_per_pic_denom                 = get_ue_golomb_long(gb);
        vui->max_bits_per_min_cu_denom               = get_ue_golomb_long(gb);
        vui->log2_max_mv_length_horizontal           = get_ue_golomb_long(gb);
        vui->log2_max_mv_length_vertical             = get_ue_golomb_long(gb);
710
    }
711 712 713 714 715 716 717 718 719 720

    if (get_bits_left(gb) < 1 && !alt) {
        // XXX: Alternate syntax when sps_range_extension_flag != 0?
        av_log(avctx, AV_LOG_WARNING,
               "Overread in VUI, retrying from timing information...\n");
        memcpy(vui, &backup_vui, sizeof(backup_vui));
        memcpy(gb, &backup, sizeof(backup));
        alt = 1;
        goto timing_info;
    }
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
}

static void set_default_scaling_list_data(ScalingList *sl)
{
    int matrixId;

    for (matrixId = 0; matrixId < 6; matrixId++) {
        // 4x4 default is 16
        memset(sl->sl[0][matrixId], 16, 16);
        sl->sl_dc[0][matrixId] = 16; // default for 16x16
        sl->sl_dc[1][matrixId] = 16; // default for 32x32
    }
    memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
    memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
    memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
    memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
    memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
    memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
    memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
    memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
    memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
    memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
    memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
    memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
    memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
746 747 748 749 750
    memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
    memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
    memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
    memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
    memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
751 752
}

753
static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingList *sl, HEVCSPS *sps)
754
{
755
    uint8_t scaling_list_pred_mode_flag;
756
    int32_t scaling_list_dc_coef[2][6];
757 758
    int size_id, matrix_id, pos;
    int i;
Guillaume Martres's avatar
Guillaume Martres committed
759

760
    for (size_id = 0; size_id < 4; size_id++)
761 762 763
        for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
            scaling_list_pred_mode_flag = get_bits1(gb);
            if (!scaling_list_pred_mode_flag) {
764
                unsigned int delta = get_ue_golomb_long(gb);
Guillaume Martres's avatar
Guillaume Martres committed
765 766
                /* Only need to handle non-zero delta. Zero means default,
                 * which should already be in the arrays. */
767 768
                if (delta) {
                    // Copy from previous array.
769
                    delta *= (size_id == 3) ? 3 : 1;
770
                    if (matrix_id < delta) {
771
                        av_log(avctx, AV_LOG_ERROR,
772 773 774 775 776 777 778 779 780 781 782
                               "Invalid delta in scaling list data: %d.\n", delta);
                        return AVERROR_INVALIDDATA;
                    }

                    memcpy(sl->sl[size_id][matrix_id],
                           sl->sl[size_id][matrix_id - delta],
                           size_id > 0 ? 64 : 16);
                    if (size_id > 1)
                        sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
                }
            } else {
Guillaume Martres's avatar
Guillaume Martres committed
783
                int next_coef, coef_num;
784 785 786
                int32_t scaling_list_delta_coef;

                next_coef = 8;
787
                coef_num  = FFMIN(64, 1 << (4 + (size_id << 1)));
788 789 790 791 792 793 794
                if (size_id > 1) {
                    scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
                    next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
                    sl->sl_dc[size_id - 2][matrix_id] = next_coef;
                }
                for (i = 0; i < coef_num; i++) {
                    if (size_id == 0)
Guillaume Martres's avatar
Guillaume Martres committed
795 796
                        pos = 4 * ff_hevc_diag_scan4x4_y[i] +
                                  ff_hevc_diag_scan4x4_x[i];
797
                    else
Guillaume Martres's avatar
Guillaume Martres committed
798 799
                        pos = 8 * ff_hevc_diag_scan8x8_y[i] +
                                  ff_hevc_diag_scan8x8_x[i];
800 801

                    scaling_list_delta_coef = get_se_golomb(gb);
802
                    next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
803 804 805 806 807
                    sl->sl[size_id][matrix_id][pos] = next_coef;
                }
            }
        }

808 809 810 811 812 813 814 815 816 817 818 819 820 821
    if (sps->chroma_format_idc == 3) {
        for (i = 0; i < 64; i++) {
            sl->sl[3][1][i] = sl->sl[2][1][i];
            sl->sl[3][2][i] = sl->sl[2][2][i];
            sl->sl[3][4][i] = sl->sl[2][4][i];
            sl->sl[3][5][i] = sl->sl[2][5][i];
        }
        sl->sl_dc[1][1] = sl->sl_dc[0][1];
        sl->sl_dc[1][2] = sl->sl_dc[0][2];
        sl->sl_dc[1][4] = sl->sl_dc[0][4];
        sl->sl_dc[1][5] = sl->sl_dc[0][5];
    }


822 823 824
    return 0;
}

825 826 827
static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
{
    const AVPixFmtDescriptor *desc;
828 829 830 831 832 833 834 835
    switch (sps->bit_depth) {
    case 8:
        if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
        if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
        if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
        if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
       break;
    case 9:
836
        if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY9;
837 838 839 840 841
        if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
        if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
        if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
        break;
    case 10:
842
        if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY10;
843 844 845 846 847
        if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
        if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
        if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
        break;
    case 12:
848
        if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY12;
849 850 851 852 853
        if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
        if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
        if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
        break;
    default:
854
        av_log(avctx, AV_LOG_ERROR,
855 856
               "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
               "chroma_format_idc is %d, depth is %d\n",
857
               sps->chroma_format_idc, sps->bit_depth);
858
        return AVERROR_INVALIDDATA;
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873
    }

    desc = av_pix_fmt_desc_get(sps->pix_fmt);
    if (!desc)
        return AVERROR(EINVAL);

    sps->hshift[0] = sps->vshift[0] = 0;
    sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
    sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;

    sps->pixel_shift = sps->bit_depth > 8;

    return 0;
}

874 875
int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
                      int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
876
{
877
    HEVCWindow *ow;
878
    int ret = 0;
879 880 881 882 883 884 885
    int log2_diff_max_min_transform_block_size;
    int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
    int i;

    // Coded parameters

    sps->vps_id = get_bits(gb, 4);
886
    if (sps->vps_id >= HEVC_MAX_VPS_COUNT) {
887
        av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
888
        return AVERROR_INVALIDDATA;
889 890
    }

891 892
    if (vps_list && !vps_list[sps->vps_id]) {
        av_log(avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
893
               sps->vps_id);
894
        return AVERROR_INVALIDDATA;
895 896
    }

897
    sps->max_sub_layers = get_bits(gb, 3) + 1;
898
    if (sps->max_sub_layers > HEVC_MAX_SUB_LAYERS) {
899
        av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
900
               sps->max_sub_layers);
901
        return AVERROR_INVALIDDATA;
902 903
    }

904
    sps->temporal_id_nesting_flag = get_bits(gb, 1);
gcocherel's avatar
gcocherel committed
905

906
    if ((ret = parse_ptl(gb, avctx, &sps->ptl, sps->max_sub_layers)) < 0)
907
        return ret;
908

909
    *sps_id = get_ue_golomb_long(gb);
910
    if (*sps_id >= HEVC_MAX_SPS_COUNT) {
911
        av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
912
        return AVERROR_INVALIDDATA;
913 914
    }

915
    sps->chroma_format_idc = get_ue_golomb_long(gb);
916 917 918 919
    if (sps->chroma_format_idc > 3U) {
        av_log(avctx, AV_LOG_ERROR, "chroma_format_idc %d is invalid\n", sps->chroma_format_idc);
        return AVERROR_INVALIDDATA;
    }
920 921 922 923

    if (sps->chroma_format_idc == 3)
        sps->separate_colour_plane_flag = get_bits1(gb);

924 925 926
    if (sps->separate_colour_plane_flag)
        sps->chroma_format_idc = 0;

927 928
    sps->width  = get_ue_golomb_long(gb);
    sps->height = get_ue_golomb_long(gb);
929
    if ((ret = av_image_check_size(sps->width,
930
                                   sps->height, 0, avctx)) < 0)
931
        return ret;
932 933

    if (get_bits1(gb)) { // pic_conformance_flag
934 935
        int vert_mult  = hevc_sub_height_c[sps->chroma_format_idc];
        int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
936 937 938 939
        sps->pic_conf_win.left_offset   = get_ue_golomb_long(gb) * horiz_mult;
        sps->pic_conf_win.right_offset  = get_ue_golomb_long(gb) * horiz_mult;
        sps->pic_conf_win.top_offset    = get_ue_golomb_long(gb) *  vert_mult;
        sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) *  vert_mult;
940

941
        if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
942
            av_log(avctx, AV_LOG_DEBUG,
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957
                   "discarding sps conformance window, "
                   "original values are l:%u r:%u t:%u b:%u\n",
                   sps->pic_conf_win.left_offset,
                   sps->pic_conf_win.right_offset,
                   sps->pic_conf_win.top_offset,
                   sps->pic_conf_win.bottom_offset);

            sps->pic_conf_win.left_offset   =
            sps->pic_conf_win.right_offset  =
            sps->pic_conf_win.top_offset    =
            sps->pic_conf_win.bottom_offset = 0;
        }
        sps->output_window = sps->pic_conf_win;
    }

958 959
    sps->bit_depth   = get_ue_golomb_long(gb) + 8;
    bit_depth_chroma = get_ue_golomb_long(gb) + 8;
960
    if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
961
        av_log(avctx, AV_LOG_ERROR,
Guillaume Martres's avatar
Guillaume Martres committed
962 963
               "Luma bit depth (%d) is different from chroma bit depth (%d), "
               "this is unsupported.\n",
964
               sps->bit_depth, bit_depth_chroma);
965
        return AVERROR_INVALIDDATA;
966
    }
967
    sps->bit_depth_chroma = bit_depth_chroma;
968

969 970
    ret = map_pixel_format(avctx, sps);
    if (ret < 0)
971
        return ret;
972

973
    sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
974
    if (sps->log2_max_poc_lsb > 16) {
975
        av_log(avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
976
               sps->log2_max_poc_lsb - 4);
977
        return AVERROR_INVALIDDATA;
978 979 980 981 982
    }

    sublayer_ordering_info = get_bits1(gb);
    start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
    for (i = start; i < sps->max_sub_layers; i++) {
983 984 985
        sps->temporal_layer[i].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
        sps->temporal_layer[i].num_reorder_pics      = get_ue_golomb_long(gb);
        sps->temporal_layer[i].max_latency_increase  = get_ue_golomb_long(gb) - 1;
986
        if (sps->temporal_layer[i].max_dec_pic_buffering > (unsigned)HEVC_MAX_DPB_SIZE) {
987
            av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
988
                   sps->temporal_layer[i].max_dec_pic_buffering - 1U);
989
            return AVERROR_INVALIDDATA;
990
        }
991
        if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering - 1) {
992
            av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
993
                   sps->temporal_layer[i].num_reorder_pics);
994
            if (avctx->err_recognition & AV_EF_EXPLODE ||
995
                sps->temporal_layer[i].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) {
996
                return AVERROR_INVALIDDATA;
997 998
            }
            sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[i].num_reorder_pics + 1;
999 1000 1001 1002
        }
    }

    if (!sublayer_ordering_info) {
Guillaume Martres's avatar
Guillaume Martres committed
1003
        for (i = 0; i < start; i++) {
1004 1005 1006 1007 1008 1009
            sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[start].max_dec_pic_buffering;
            sps->temporal_layer[i].num_reorder_pics      = sps->temporal_layer[start].num_reorder_pics;
            sps->temporal_layer[i].max_latency_increase  = sps->temporal_layer[start].max_latency_increase;
        }
    }

Guillaume Martres's avatar
Guillaume Martres committed
1010 1011 1012 1013 1014 1015
    sps->log2_min_cb_size                    = get_ue_golomb_long(gb) + 3;
    sps->log2_diff_max_min_coding_block_size = get_ue_golomb_long(gb);
    sps->log2_min_tb_size                    = get_ue_golomb_long(gb) + 2;
    log2_diff_max_min_transform_block_size   = get_ue_golomb_long(gb);
    sps->log2_max_trafo_size                 = log2_diff_max_min_transform_block_size +
                                               sps->log2_min_tb_size;
1016

1017
    if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
1018
        av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
1019
        return AVERROR_INVALIDDATA;
1020 1021 1022
    }

    if (sps->log2_diff_max_min_coding_block_size > 30) {
1023
        av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_coding_block_size", sps->log2_diff_max_min_coding_block_size);
1024
        return AVERROR_INVALIDDATA;
1025 1026 1027
    }

    if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
1028
        av_log(avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
1029
        return AVERROR_INVALIDDATA;
1030
    }
1031 1032

    if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
1033
        av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size);
1034
        return AVERROR_INVALIDDATA;
1035 1036
    }

1037 1038
    sps->max_transform_hierarchy_depth_inter = get_ue_golomb_long(gb);
    sps->max_transform_hierarchy_depth_intra = get_ue_golomb_long(gb);
1039 1040 1041 1042 1043 1044

    sps->scaling_list_enable_flag = get_bits1(gb);
    if (sps->scaling_list_enable_flag) {
        set_default_scaling_list_data(&sps->scaling_list);

        if (get_bits1(gb)) {
1045
            ret = scaling_list_data(gb, avctx, &sps->scaling_list, sps);
1046
            if (ret < 0)
1047
                return ret;
1048 1049 1050 1051 1052 1053 1054 1055 1056
        }
    }

    sps->amp_enabled_flag = get_bits1(gb);
    sps->sao_enabled      = get_bits1(gb);

    sps->pcm_enabled_flag = get_bits1(gb);
    if (sps->pcm_enabled_flag) {
        sps->pcm.bit_depth   = get_bits(gb, 4) + 1;
1057
        sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
1058
        sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;
1059
        sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size +
1060
                                        get_ue_golomb_long(gb);
1061
        if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
1062
            av_log(avctx, AV_LOG_ERROR,
1063 1064
                   "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
                   sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth);
1065
            return AVERROR_INVALIDDATA;
1066 1067 1068 1069 1070
        }

        sps->pcm.loop_filter_disable_flag = get_bits1(gb);
    }

1071
    sps->nb_st_rps = get_ue_golomb_long(gb);
1072
    if (sps->nb_st_rps > HEVC_MAX_SHORT_TERM_REF_PIC_SETS) {
1073
        av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
1074
               sps->nb_st_rps);
1075
        return AVERROR_INVALIDDATA;
1076
    }
1077
    for (i = 0; i < sps->nb_st_rps; i++) {
1078
        if ((ret = ff_hevc_decode_short_term_rps(gb, avctx, &sps->st_rps[i],
1079
                                                 sps, 0)) < 0)
1080
            return ret;
1081 1082 1083 1084
    }

    sps->long_term_ref_pics_present_flag = get_bits1(gb);
    if (sps->long_term_ref_pics_present_flag) {
1085
        sps->num_long_term_ref_pics_sps = get_ue_golomb_long(gb);
1086 1087
        if (sps->num_long_term_ref_pics_sps > HEVC_MAX_LONG_TERM_REF_PICS) {
            av_log(avctx, AV_LOG_ERROR, "Too many long term ref pics: %d.\n",
1088
                   sps->num_long_term_ref_pics_sps);
1089
            return AVERROR_INVALIDDATA;
1090
        }
1091 1092 1093 1094 1095 1096 1097 1098
        for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
            sps->lt_ref_pic_poc_lsb_sps[i]       = get_bits(gb, sps->log2_max_poc_lsb);
            sps->used_by_curr_pic_lt_sps_flag[i] = get_bits1(gb);
        }
    }

    sps->sps_temporal_mvp_enabled_flag          = get_bits1(gb);
    sps->sps_strong_intra_smoothing_enable_flag = get_bits1(gb);
Mickaël Raulet's avatar
Mickaël Raulet committed
1099
    sps->vui.sar = (AVRational){0, 1};
1100 1101
    vui_present = get_bits1(gb);
    if (vui_present)
1102
        decode_vui(gb, avctx, apply_defdispwin, sps);
1103

1104
    if (get_bits1(gb)) { // sps_extension_flag
1105
        int sps_range_extension_flag = get_bits1(gb);
1106
        skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1107
        if (sps_range_extension_flag) {
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
            int extended_precision_processing_flag;
            int cabac_bypass_alignment_enabled_flag;

            sps->transform_skip_rotation_enabled_flag = get_bits1(gb);
            sps->transform_skip_context_enabled_flag  = get_bits1(gb);
            sps->implicit_rdpcm_enabled_flag = get_bits1(gb);

            sps->explicit_rdpcm_enabled_flag = get_bits1(gb);

            extended_precision_processing_flag = get_bits1(gb);
            if (extended_precision_processing_flag)
1119
                av_log(avctx, AV_LOG_WARNING,
1120 1121 1122
                   "extended_precision_processing_flag not yet implemented\n");

            sps->intra_smoothing_disabled_flag       = get_bits1(gb);
1123 1124
            sps->high_precision_offsets_enabled_flag = get_bits1(gb);
            if (sps->high_precision_offsets_enabled_flag)
1125
                av_log(avctx, AV_LOG_WARNING,
1126 1127 1128 1129 1130 1131
                   "high_precision_offsets_enabled_flag not yet implemented\n");

            sps->persistent_rice_adaptation_enabled_flag = get_bits1(gb);

            cabac_bypass_alignment_enabled_flag  = get_bits1(gb);
            if (cabac_bypass_alignment_enabled_flag)
1132
                av_log(avctx, AV_LOG_WARNING,
1133 1134 1135
                   "cabac_bypass_alignment_enabled_flag not yet implemented\n");
        }
    }
1136
    if (apply_defdispwin) {
1137 1138 1139 1140 1141
        sps->output_window.left_offset   += sps->vui.def_disp_win.left_offset;
        sps->output_window.right_offset  += sps->vui.def_disp_win.right_offset;
        sps->output_window.top_offset    += sps->vui.def_disp_win.top_offset;
        sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;
    }
1142 1143 1144 1145 1146 1147 1148 1149

    ow = &sps->output_window;
    if (ow->left_offset >= INT_MAX - ow->right_offset     ||
        ow->top_offset  >= INT_MAX - ow->bottom_offset    ||
        ow->left_offset + ow->right_offset  >= sps->width ||
        ow->top_offset  + ow->bottom_offset >= sps->height) {
        av_log(avctx, AV_LOG_WARNING, "Invalid cropping offsets: %u/%u/%u/%u\n",
               ow->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset);
1150
        if (avctx->err_recognition & AV_EF_EXPLODE) {
1151
            return AVERROR_INVALIDDATA;
1152
        }
1153
        av_log(avctx, AV_LOG_WARNING,
1154
               "Displaying the whole video surface.\n");
1155
        memset(ow, 0, sizeof(*ow));
1156
        memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1157 1158 1159
    }

    // Inferred parameters
Guillaume Martres's avatar
Guillaume Martres committed
1160 1161 1162
    sps->log2_ctb_size = sps->log2_min_cb_size +
                         sps->log2_diff_max_min_coding_block_size;
    sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1163

James Almer's avatar
James Almer committed
1164
    if (sps->log2_ctb_size > HEVC_MAX_LOG2_CTB_SIZE) {
1165
        av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1166
        return AVERROR_INVALIDDATA;
1167 1168
    }
    if (sps->log2_ctb_size < 4) {
1169
        av_log(avctx,
1170 1171 1172
               AV_LOG_ERROR,
               "log2_ctb_size %d differs from the bounds of any known profile\n",
               sps->log2_ctb_size);
1173
        avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1174
        return AVERROR_INVALIDDATA;
1175 1176
    }

Guillaume Martres's avatar
Guillaume Martres committed
1177 1178 1179
    sps->ctb_width  = (sps->width  + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
    sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
    sps->ctb_size   = sps->ctb_width * sps->ctb_height;
1180

Guillaume Martres's avatar
Guillaume Martres committed
1181 1182 1183 1184 1185 1186
    sps->min_cb_width  = sps->width  >> sps->log2_min_cb_size;
    sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
    sps->min_tb_width  = sps->width  >> sps->log2_min_tb_size;
    sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
    sps->min_pu_width  = sps->width  >> sps->log2_min_pu_size;
    sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1187
    sps->tb_mask       = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1188

Guillaume Martres's avatar
Guillaume Martres committed
1189
    sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1190

1191 1192
    if (av_mod_uintp2(sps->width, sps->log2_min_cb_size) ||
        av_mod_uintp2(sps->height, sps->log2_min_cb_size)) {
1193
        av_log(avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1194
        return AVERROR_INVALIDDATA;
1195 1196
    }

1197
    if (sps->max_transform_hierarchy_depth_inter > sps->log2_ctb_size - sps->log2_min_tb_size) {
1198
        av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1199
               sps->max_transform_hierarchy_depth_inter);
1200
        return AVERROR_INVALIDDATA;
1201
    }
1202
    if (sps->max_transform_hierarchy_depth_intra > sps->log2_ctb_size - sps->log2_min_tb_size) {
1203
        av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1204
               sps->max_transform_hierarchy_depth_intra);
1205
        return AVERROR_INVALIDDATA;
1206 1207
    }
    if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1208
        av_log(avctx, AV_LOG_ERROR,
Guillaume Martres's avatar
Guillaume Martres committed
1209
               "max transform block size out of range: %d\n",
1210
               sps->log2_max_trafo_size);
1211
        return AVERROR_INVALIDDATA;
1212 1213
    }

1214
    if (get_bits_left(gb) < 0) {
1215
        av_log(avctx, AV_LOG_ERROR,
1216
               "Overread SPS by %d bits\n", -get_bits_left(gb));
1217
        return AVERROR_INVALIDDATA;
1218 1219
    }

1220 1221 1222
    return 0;
}

1223 1224
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
                           HEVCParamSets *ps, int apply_defdispwin)
1225 1226 1227 1228 1229
{
    HEVCSPS *sps;
    AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
    unsigned int sps_id;
    int ret;
1230
    ptrdiff_t nal_size;
1231 1232 1233 1234 1235

    if (!sps_buf)
        return AVERROR(ENOMEM);
    sps = (HEVCSPS*)sps_buf->data;

1236
    av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
1237

1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
    nal_size = gb->buffer_end - gb->buffer;
    if (nal_size > sizeof(sps->data)) {
        av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized SPS "
               "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
               nal_size, sizeof(sps->data));
        sps->data_size = sizeof(sps->data);
    } else {
        sps->data_size = nal_size;
    }
    memcpy(sps->data, gb->buffer, sps->data_size);

1249 1250 1251
    ret = ff_hevc_parse_sps(sps, gb, &sps_id,
                            apply_defdispwin,
                            ps->vps_list, avctx);
1252 1253 1254 1255 1256
    if (ret < 0) {
        av_buffer_unref(&sps_buf);
        return ret;
    }

1257 1258
    if (avctx->debug & FF_DEBUG_BITSTREAM) {
        av_log(avctx, AV_LOG_DEBUG,
Guillaume Martres's avatar
Guillaume Martres committed
1259
               "Parsed SPS: id %d; coded wxh: %dx%d; "
1260 1261
               "cropped wxh: %dx%d; pix_fmt: %s.\n",
               sps_id, sps->width, sps->height,
1262 1263
               sps->width - (sps->output_window.left_offset + sps->output_window.right_offset),
               sps->height - (sps->output_window.top_offset + sps->output_window.bottom_offset),
1264 1265 1266
               av_get_pix_fmt_name(sps->pix_fmt));
    }

1267 1268 1269
    /* check if this is a repeat of an already parsed SPS, then keep the
     * original one.
     * otherwise drop all PPSes that depend on it */
1270 1271
    if (ps->sps_list[sps_id] &&
        !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1272 1273
        av_buffer_unref(&sps_buf);
    } else {
1274 1275
        remove_sps(ps, sps_id);
        ps->sps_list[sps_id] = sps_buf;
1276 1277
    }

1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
    return 0;
}

static void hevc_pps_free(void *opaque, uint8_t *data)
{
    HEVCPPS *pps = (HEVCPPS*)data;

    av_freep(&pps->column_width);
    av_freep(&pps->row_height);
    av_freep(&pps->col_bd);
    av_freep(&pps->row_bd);
    av_freep(&pps->col_idxX);
    av_freep(&pps->ctb_addr_rs_to_ts);
    av_freep(&pps->ctb_addr_ts_to_rs);
    av_freep(&pps->tile_pos_rs);
    av_freep(&pps->tile_id);
1294
    av_freep(&pps->min_tb_addr_zs_tab);
1295 1296 1297 1298

    av_freep(&pps);
}

1299 1300
static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx,
                                HEVCPPS *pps, HEVCSPS *sps) {
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
    int i;

    if (pps->transform_skip_enabled_flag) {
        pps->log2_max_transform_skip_block_size = get_ue_golomb_long(gb) + 2;
    }
    pps->cross_component_prediction_enabled_flag = get_bits1(gb);
    pps->chroma_qp_offset_list_enabled_flag = get_bits1(gb);
    if (pps->chroma_qp_offset_list_enabled_flag) {
        pps->diff_cu_chroma_qp_offset_depth = get_ue_golomb_long(gb);
        pps->chroma_qp_offset_list_len_minus1 = get_ue_golomb_long(gb);
1311
        if (pps->chroma_qp_offset_list_len_minus1 > 5) {
1312
            av_log(avctx, AV_LOG_ERROR,
1313 1314 1315 1316 1317 1318
                   "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
            return AVERROR_INVALIDDATA;
        }
        for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
            pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
            if (pps->cb_qp_offset_list[i]) {
1319
                av_log(avctx, AV_LOG_WARNING,
1320 1321 1322 1323
                       "cb_qp_offset_list not tested yet.\n");
            }
            pps->cr_qp_offset_list[i] = get_se_golomb_long(gb);
            if (pps->cr_qp_offset_list[i]) {
1324
                av_log(avctx, AV_LOG_WARNING,
1325 1326 1327 1328 1329 1330 1331
                       "cb_qp_offset_list not tested yet.\n");
            }
        }
    }
    pps->log2_sao_offset_scale_luma = get_ue_golomb_long(gb);
    pps->log2_sao_offset_scale_chroma = get_ue_golomb_long(gb);

1332 1333 1334 1335 1336
    if (   pps->log2_sao_offset_scale_luma   > FFMAX(sps->bit_depth        - 10, 0)
        || pps->log2_sao_offset_scale_chroma > FFMAX(sps->bit_depth_chroma - 10, 0)
    )
        return AVERROR_INVALIDDATA;

1337 1338 1339
    return(0);
}

1340 1341 1342 1343
static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
                            HEVCPPS *pps, HEVCSPS *sps)
{
    int log2_diff;
1344
    int pic_area_in_ctbs;
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
    int i, j, x, y, ctb_addr_rs, tile_id;

    // Inferred parameters
    pps->col_bd   = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
    pps->row_bd   = av_malloc_array(pps->num_tile_rows + 1,    sizeof(*pps->row_bd));
    pps->col_idxX = av_malloc_array(sps->ctb_width,    sizeof(*pps->col_idxX));
    if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
        return AVERROR(ENOMEM);

    if (pps->uniform_spacing_flag) {
        if (!pps->column_width) {
            pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
            pps->row_height   = av_malloc_array(pps->num_tile_rows,    sizeof(*pps->row_height));
        }
        if (!pps->column_width || !pps->row_height)
            return AVERROR(ENOMEM);

        for (i = 0; i < pps->num_tile_columns; i++) {
            pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
                                   (i * sps->ctb_width) / pps->num_tile_columns;
        }

        for (i = 0; i < pps->num_tile_rows; i++) {
            pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
                                 (i * sps->ctb_height) / pps->num_tile_rows;
        }
    }

    pps->col_bd[0] = 0;
    for (i = 0; i < pps->num_tile_columns; i++)
        pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];

    pps->row_bd[0] = 0;
    for (i = 0; i < pps->num_tile_rows; i++)
        pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];

    for (i = 0, j = 0; i < sps->ctb_width; i++) {
        if (i > pps->col_bd[j])
            j++;
        pps->col_idxX[i] = j;
    }

    /**
     * 6.5
     */
    pic_area_in_ctbs     = sps->ctb_width    * sps->ctb_height;

    pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs,    sizeof(*pps->ctb_addr_rs_to_ts));
    pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs,    sizeof(*pps->ctb_addr_ts_to_rs));
    pps->tile_id           = av_malloc_array(pic_area_in_ctbs,    sizeof(*pps->tile_id));
1395
    pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1396
    if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1397
        !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
        return AVERROR(ENOMEM);
    }

    for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
        int tb_x   = ctb_addr_rs % sps->ctb_width;
        int tb_y   = ctb_addr_rs / sps->ctb_width;
        int tile_x = 0;
        int tile_y = 0;
        int val    = 0;

        for (i = 0; i < pps->num_tile_columns; i++) {
            if (tb_x < pps->col_bd[i + 1]) {
                tile_x = i;
                break;
            }
        }

        for (i = 0; i < pps->num_tile_rows; i++) {
            if (tb_y < pps->row_bd[i + 1]) {
                tile_y = i;
                break;
            }
        }

        for (i = 0; i < tile_x; i++)
            val += pps->row_height[tile_y] * pps->column_width[i];
        for (i = 0; i < tile_y; i++)
            val += sps->ctb_width * pps->row_height[i];

        val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
               tb_x - pps->col_bd[tile_x];

        pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
        pps->ctb_addr_ts_to_rs[val]         = ctb_addr_rs;
    }

    for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
        for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
            for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
                for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
                    pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;

    pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
    if (!pps->tile_pos_rs)
        return AVERROR(ENOMEM);

    for (j = 0; j < pps->num_tile_rows; j++)
        for (i = 0; i < pps->num_tile_columns; i++)
            pps->tile_pos_rs[j * pps->num_tile_columns + i] =
                pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];

    log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
1450 1451 1452 1453 1454 1455 1456
    pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
    for (y = 0; y < sps->tb_mask+2; y++) {
        pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
        pps->min_tb_addr_zs_tab[y]    = -1;
    }
    for (y = 0; y < sps->tb_mask+1; y++) {
        for (x = 0; x < sps->tb_mask+1; x++) {
1457 1458 1459 1460 1461 1462 1463 1464
            int tb_x = x >> log2_diff;
            int tb_y = y >> log2_diff;
            int rs   = sps->ctb_width * tb_y + tb_x;
            int val  = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
            for (i = 0; i < log2_diff; i++) {
                int m = 1 << i;
                val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
            }
1465
            pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1466 1467 1468 1469 1470 1471
        }
    }

    return 0;
}

1472 1473
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
                           HEVCParamSets *ps)
1474 1475
{
    HEVCSPS      *sps = NULL;
1476
    int i, ret = 0;
1477
    unsigned int pps_id = 0;
1478
    ptrdiff_t nal_size;
1479
    unsigned log2_parallel_merge_level_minus2;
1480 1481 1482 1483 1484 1485 1486

    AVBufferRef *pps_buf;
    HEVCPPS *pps = av_mallocz(sizeof(*pps));

    if (!pps)
        return AVERROR(ENOMEM);

Guillaume Martres's avatar
Guillaume Martres committed
1487 1488
    pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
                               hevc_pps_free, NULL, 0);
1489 1490 1491 1492 1493
    if (!pps_buf) {
        av_freep(&pps);
        return AVERROR(ENOMEM);
    }

1494
    av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1495

1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
    nal_size = gb->buffer_end - gb->buffer;
    if (nal_size > sizeof(pps->data)) {
        av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized PPS "
               "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
               nal_size, sizeof(pps->data));
        pps->data_size = sizeof(pps->data);
    } else {
        pps->data_size = nal_size;
    }
    memcpy(pps->data, gb->buffer, pps->data_size);

1507 1508 1509 1510 1511
    // Default values
    pps->loop_filter_across_tiles_enabled_flag = 1;
    pps->num_tile_columns                      = 1;
    pps->num_tile_rows                         = 1;
    pps->uniform_spacing_flag                  = 1;
1512
    pps->disable_dbf                           = 0;
1513 1514
    pps->beta_offset                           = 0;
    pps->tc_offset                             = 0;
1515
    pps->log2_max_transform_skip_block_size    = 2;
1516 1517

    // Coded parameters
1518
    pps_id = get_ue_golomb_long(gb);
1519
    if (pps_id >= HEVC_MAX_PPS_COUNT) {
1520
        av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1521
        ret = AVERROR_INVALIDDATA;
1522 1523
        goto err;
    }
1524
    pps->sps_id = get_ue_golomb_long(gb);
1525
    if (pps->sps_id >= HEVC_MAX_SPS_COUNT) {
1526
        av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1527 1528 1529
        ret = AVERROR_INVALIDDATA;
        goto err;
    }
1530 1531
    if (!ps->sps_list[pps->sps_id]) {
        av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1532 1533 1534
        ret = AVERROR_INVALIDDATA;
        goto err;
    }
1535
    sps = (HEVCSPS *)ps->sps_list[pps->sps_id]->data;
1536 1537 1538 1539 1540 1541 1542 1543 1544

    pps->dependent_slice_segments_enabled_flag = get_bits1(gb);
    pps->output_flag_present_flag              = get_bits1(gb);
    pps->num_extra_slice_header_bits           = get_bits(gb, 3);

    pps->sign_data_hiding_flag = get_bits1(gb);

    pps->cabac_init_present_flag = get_bits1(gb);

1545 1546
    pps->num_ref_idx_l0_default_active = get_ue_golomb_long(gb) + 1;
    pps->num_ref_idx_l1_default_active = get_ue_golomb_long(gb) + 1;
1547 1548 1549 1550 1551 1552 1553 1554 1555

    pps->pic_init_qp_minus26 = get_se_golomb(gb);

    pps->constrained_intra_pred_flag = get_bits1(gb);
    pps->transform_skip_enabled_flag = get_bits1(gb);

    pps->cu_qp_delta_enabled_flag = get_bits1(gb);
    pps->diff_cu_qp_delta_depth   = 0;
    if (pps->cu_qp_delta_enabled_flag)
1556
        pps->diff_cu_qp_delta_depth = get_ue_golomb_long(gb);
1557

1558 1559
    if (pps->diff_cu_qp_delta_depth < 0 ||
        pps->diff_cu_qp_delta_depth > sps->log2_diff_max_min_coding_block_size) {
1560
        av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1561 1562 1563 1564 1565
               pps->diff_cu_qp_delta_depth);
        ret = AVERROR_INVALIDDATA;
        goto err;
    }

1566 1567
    pps->cb_qp_offset = get_se_golomb(gb);
    if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1568
        av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1569 1570 1571 1572 1573 1574
               pps->cb_qp_offset);
        ret = AVERROR_INVALIDDATA;
        goto err;
    }
    pps->cr_qp_offset = get_se_golomb(gb);
    if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1575
        av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
               pps->cr_qp_offset);
        ret = AVERROR_INVALIDDATA;
        goto err;
    }
    pps->pic_slice_level_chroma_qp_offsets_present_flag = get_bits1(gb);

    pps->weighted_pred_flag   = get_bits1(gb);
    pps->weighted_bipred_flag = get_bits1(gb);

    pps->transquant_bypass_enable_flag    = get_bits1(gb);
    pps->tiles_enabled_flag               = get_bits1(gb);
    pps->entropy_coding_sync_enabled_flag = get_bits1(gb);

    if (pps->tiles_enabled_flag) {
Guillaume Martres's avatar
Guillaume Martres committed
1590 1591
        pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
        pps->num_tile_rows    = get_ue_golomb_long(gb) + 1;
1592
        if (pps->num_tile_columns <= 0 ||
1593
            pps->num_tile_columns >= sps->width) {
1594
            av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1595 1596
                   pps->num_tile_columns - 1);
            ret = AVERROR_INVALIDDATA;
1597 1598
            goto err;
        }
1599
        if (pps->num_tile_rows <= 0 ||
1600
            pps->num_tile_rows >= sps->height) {
1601
            av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
                   pps->num_tile_rows - 1);
            ret = AVERROR_INVALIDDATA;
            goto err;
        }

        pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
        pps->row_height   = av_malloc_array(pps->num_tile_rows,    sizeof(*pps->row_height));
        if (!pps->column_width || !pps->row_height) {
            ret = AVERROR(ENOMEM);
            goto err;
        }

        pps->uniform_spacing_flag = get_bits1(gb);
        if (!pps->uniform_spacing_flag) {
1616
            uint64_t sum = 0;
1617
            for (i = 0; i < pps->num_tile_columns - 1; i++) {
1618
                pps->column_width[i] = get_ue_golomb_long(gb) + 1;
Guillaume Martres's avatar
Guillaume Martres committed
1619
                sum                 += pps->column_width[i];
1620 1621
            }
            if (sum >= sps->ctb_width) {
1622
                av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1623
                ret = AVERROR_INVALIDDATA;
1624 1625
                goto err;
            }
1626 1627 1628 1629
            pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;

            sum = 0;
            for (i = 0; i < pps->num_tile_rows - 1; i++) {
1630
                pps->row_height[i] = get_ue_golomb_long(gb) + 1;
Guillaume Martres's avatar
Guillaume Martres committed
1631
                sum               += pps->row_height[i];
1632 1633
            }
            if (sum >= sps->ctb_height) {
1634
                av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647
                ret = AVERROR_INVALIDDATA;
                goto err;
            }
            pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
        }
        pps->loop_filter_across_tiles_enabled_flag = get_bits1(gb);
    }

    pps->seq_loop_filter_across_slices_enabled_flag = get_bits1(gb);

    pps->deblocking_filter_control_present_flag = get_bits1(gb);
    if (pps->deblocking_filter_control_present_flag) {
        pps->deblocking_filter_override_enabled_flag = get_bits1(gb);
Guillaume Martres's avatar
Guillaume Martres committed
1648
        pps->disable_dbf                             = get_bits1(gb);
1649
        if (!pps->disable_dbf) {
1650 1651 1652
            int beta_offset_div2 = get_se_golomb(gb);
            int tc_offset_div2   = get_se_golomb(gb) ;
            if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1653
                av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1654
                       beta_offset_div2);
1655 1656 1657
                ret = AVERROR_INVALIDDATA;
                goto err;
            }
1658
            if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1659
                av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1660
                       tc_offset_div2);
1661 1662 1663
                ret = AVERROR_INVALIDDATA;
                goto err;
            }
1664 1665
            pps->beta_offset = 2 * beta_offset_div2;
            pps->tc_offset   = 2 *   tc_offset_div2;
1666 1667 1668
        }
    }

Guillaume Martres's avatar
Guillaume Martres committed
1669 1670
    pps->scaling_list_data_present_flag = get_bits1(gb);
    if (pps->scaling_list_data_present_flag) {
1671
        set_default_scaling_list_data(&pps->scaling_list);
1672
        ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
1673 1674 1675 1676
        if (ret < 0)
            goto err;
    }
    pps->lists_modification_present_flag = get_bits1(gb);
1677 1678
    log2_parallel_merge_level_minus2     = get_ue_golomb_long(gb);
    if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
1679
        av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1680
               log2_parallel_merge_level_minus2);
1681
        ret = AVERROR_INVALIDDATA;
1682 1683
        goto err;
    }
1684
    pps->log2_parallel_merge_level       = log2_parallel_merge_level_minus2 + 2;
1685 1686

    pps->slice_header_extension_present_flag = get_bits1(gb);
1687 1688 1689

    if (get_bits1(gb)) { // pps_extension_present_flag
        int pps_range_extensions_flag = get_bits1(gb);
1690
        skip_bits(gb, 7); // pps_extension_7bits
1691
        if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1692
            if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
1693
                goto err;
1694 1695
        }
    }
1696

1697 1698
    ret = setup_pps(avctx, gb, pps, sps);
    if (ret < 0)
1699 1700
        goto err;

1701
    if (get_bits_left(gb) < 0) {
1702
        av_log(avctx, AV_LOG_ERROR,
1703 1704 1705 1706
               "Overread PPS by %d bits\n", -get_bits_left(gb));
        goto err;
    }

1707 1708
    remove_pps(ps, pps_id);
    ps->pps_list[pps_id] = pps_buf;
1709 1710 1711 1712 1713 1714 1715

    return 0;

err:
    av_buffer_unref(&pps_buf);
    return ret;
}
1716

1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732
void ff_hevc_ps_uninit(HEVCParamSets *ps)
{
    int i;

    for (i = 0; i < FF_ARRAY_ELEMS(ps->vps_list); i++)
        av_buffer_unref(&ps->vps_list[i]);
    for (i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
        av_buffer_unref(&ps->sps_list[i]);
    for (i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
        av_buffer_unref(&ps->pps_list[i]);

    ps->sps = NULL;
    ps->pps = NULL;
    ps->vps = NULL;
}

1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
{
    int max_poc_lsb  = 1 << sps->log2_max_poc_lsb;
    int prev_poc_lsb = pocTid0 % max_poc_lsb;
    int prev_poc_msb = pocTid0 - prev_poc_lsb;
    int poc_msb;

    if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
        poc_msb = prev_poc_msb + max_poc_lsb;
    else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
        poc_msb = prev_poc_msb - max_poc_lsb;
    else
        poc_msb = prev_poc_msb;

    // For BLA picture types, POCmsb is set to 0.
    if (nal_unit_type == HEVC_NAL_BLA_W_LP   ||
        nal_unit_type == HEVC_NAL_BLA_W_RADL ||
        nal_unit_type == HEVC_NAL_BLA_N_LP)
        poc_msb = 0;

    return poc_msb + poc_lsb;
}