| 1 | /* |
| 2 | * HEVC video decoder |
| 3 | * |
| 4 | * Copyright (C) 2012 - 2013 Guillaume Martres |
| 5 | * Copyright (C) 2012 - 2013 Gildas Cocherel |
| 6 | * |
| 7 | * This file is part of FFmpeg. |
| 8 | * |
| 9 | * FFmpeg is free software; you can redistribute it and/or |
| 10 | * modify it under the terms of the GNU Lesser General Public |
| 11 | * License as published by the Free Software Foundation; either |
| 12 | * version 2.1 of the License, or (at your option) any later version. |
| 13 | * |
| 14 | * FFmpeg is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 17 | * Lesser General Public License for more details. |
| 18 | * |
| 19 | * You should have received a copy of the GNU Lesser General Public |
| 20 | * License along with FFmpeg; if not, write to the Free Software |
| 21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| 22 | */ |
| 23 | |
| 24 | #include "libavutil/pixdesc.h" |
| 25 | |
| 26 | #include "internal.h" |
| 27 | #include "thread.h" |
| 28 | #include "hevc.h" |
| 29 | |
| 30 | void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags) |
| 31 | { |
| 32 | /* frame->frame can be NULL if context init failed */ |
| 33 | if (!frame->frame || !frame->frame->buf[0]) |
| 34 | return; |
| 35 | |
| 36 | frame->flags &= ~flags; |
| 37 | if (!frame->flags) { |
| 38 | ff_thread_release_buffer(s->avctx, &frame->tf); |
| 39 | |
| 40 | av_buffer_unref(&frame->tab_mvf_buf); |
| 41 | frame->tab_mvf = NULL; |
| 42 | |
| 43 | av_buffer_unref(&frame->rpl_buf); |
| 44 | av_buffer_unref(&frame->rpl_tab_buf); |
| 45 | frame->rpl_tab = NULL; |
| 46 | frame->refPicList = NULL; |
| 47 | |
| 48 | frame->collocated_ref = NULL; |
| 49 | } |
| 50 | } |
| 51 | |
| 52 | RefPicList *ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *ref, int x0, int y0) |
| 53 | { |
| 54 | int x_cb = x0 >> s->sps->log2_ctb_size; |
| 55 | int y_cb = y0 >> s->sps->log2_ctb_size; |
| 56 | int pic_width_cb = s->sps->ctb_width; |
| 57 | int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[y_cb * pic_width_cb + x_cb]; |
| 58 | return (RefPicList *)ref->rpl_tab[ctb_addr_ts]; |
| 59 | } |
| 60 | |
| 61 | void ff_hevc_clear_refs(HEVCContext *s) |
| 62 | { |
| 63 | int i; |
| 64 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) |
| 65 | ff_hevc_unref_frame(s, &s->DPB[i], |
| 66 | HEVC_FRAME_FLAG_SHORT_REF | |
| 67 | HEVC_FRAME_FLAG_LONG_REF); |
| 68 | } |
| 69 | |
| 70 | void ff_hevc_flush_dpb(HEVCContext *s) |
| 71 | { |
| 72 | int i; |
| 73 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) |
| 74 | ff_hevc_unref_frame(s, &s->DPB[i], ~0); |
| 75 | } |
| 76 | |
| 77 | static HEVCFrame *alloc_frame(HEVCContext *s) |
| 78 | { |
| 79 | int i, j, ret; |
| 80 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 81 | HEVCFrame *frame = &s->DPB[i]; |
| 82 | if (frame->frame->buf[0]) |
| 83 | continue; |
| 84 | |
| 85 | ret = ff_thread_get_buffer(s->avctx, &frame->tf, |
| 86 | AV_GET_BUFFER_FLAG_REF); |
| 87 | if (ret < 0) |
| 88 | return NULL; |
| 89 | |
| 90 | frame->rpl_buf = av_buffer_allocz(s->nb_nals * sizeof(RefPicListTab)); |
| 91 | if (!frame->rpl_buf) |
| 92 | goto fail; |
| 93 | |
| 94 | frame->tab_mvf_buf = av_buffer_pool_get(s->tab_mvf_pool); |
| 95 | if (!frame->tab_mvf_buf) |
| 96 | goto fail; |
| 97 | frame->tab_mvf = (MvField *)frame->tab_mvf_buf->data; |
| 98 | |
| 99 | frame->rpl_tab_buf = av_buffer_pool_get(s->rpl_tab_pool); |
| 100 | if (!frame->rpl_tab_buf) |
| 101 | goto fail; |
| 102 | frame->rpl_tab = (RefPicListTab **)frame->rpl_tab_buf->data; |
| 103 | frame->ctb_count = s->sps->ctb_width * s->sps->ctb_height; |
| 104 | for (j = 0; j < frame->ctb_count; j++) |
| 105 | frame->rpl_tab[j] = (RefPicListTab *)frame->rpl_buf->data; |
| 106 | |
| 107 | frame->frame->top_field_first = s->picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD; |
| 108 | frame->frame->interlaced_frame = (s->picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) || (s->picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD); |
| 109 | return frame; |
| 110 | fail: |
| 111 | ff_hevc_unref_frame(s, frame, ~0); |
| 112 | return NULL; |
| 113 | } |
| 114 | av_log(s->avctx, AV_LOG_ERROR, "Error allocating frame, DPB full.\n"); |
| 115 | return NULL; |
| 116 | } |
| 117 | |
| 118 | int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc) |
| 119 | { |
| 120 | HEVCFrame *ref; |
| 121 | int i; |
| 122 | |
| 123 | /* check that this POC doesn't already exist */ |
| 124 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 125 | HEVCFrame *frame = &s->DPB[i]; |
| 126 | |
| 127 | if (frame->frame->buf[0] && frame->sequence == s->seq_decode && |
| 128 | frame->poc == poc) { |
| 129 | av_log(s->avctx, AV_LOG_ERROR, "Duplicate POC in a sequence: %d.\n", |
| 130 | poc); |
| 131 | return AVERROR_INVALIDDATA; |
| 132 | } |
| 133 | } |
| 134 | |
| 135 | ref = alloc_frame(s); |
| 136 | if (!ref) |
| 137 | return AVERROR(ENOMEM); |
| 138 | |
| 139 | *frame = ref->frame; |
| 140 | s->ref = ref; |
| 141 | |
| 142 | if (s->sh.pic_output_flag) |
| 143 | ref->flags = HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_SHORT_REF; |
| 144 | else |
| 145 | ref->flags = HEVC_FRAME_FLAG_SHORT_REF; |
| 146 | |
| 147 | ref->poc = poc; |
| 148 | ref->sequence = s->seq_decode; |
| 149 | ref->window = s->sps->output_window; |
| 150 | |
| 151 | return 0; |
| 152 | } |
| 153 | |
| 154 | int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush) |
| 155 | { |
| 156 | do { |
| 157 | int nb_output = 0; |
| 158 | int min_poc = INT_MAX; |
| 159 | int i, min_idx, ret; |
| 160 | |
| 161 | if (s->sh.no_output_of_prior_pics_flag == 1) { |
| 162 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 163 | HEVCFrame *frame = &s->DPB[i]; |
| 164 | if (!(frame->flags & HEVC_FRAME_FLAG_BUMPING) && frame->poc != s->poc && |
| 165 | frame->sequence == s->seq_output) { |
| 166 | ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT); |
| 167 | } |
| 168 | } |
| 169 | } |
| 170 | |
| 171 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 172 | HEVCFrame *frame = &s->DPB[i]; |
| 173 | if ((frame->flags & HEVC_FRAME_FLAG_OUTPUT) && |
| 174 | frame->sequence == s->seq_output) { |
| 175 | nb_output++; |
| 176 | if (frame->poc < min_poc) { |
| 177 | min_poc = frame->poc; |
| 178 | min_idx = i; |
| 179 | } |
| 180 | } |
| 181 | } |
| 182 | |
| 183 | /* wait for more frames before output */ |
| 184 | if (!flush && s->seq_output == s->seq_decode && s->sps && |
| 185 | nb_output <= s->sps->temporal_layer[s->sps->max_sub_layers - 1].num_reorder_pics) |
| 186 | return 0; |
| 187 | |
| 188 | if (nb_output) { |
| 189 | HEVCFrame *frame = &s->DPB[min_idx]; |
| 190 | AVFrame *dst = out; |
| 191 | AVFrame *src = frame->frame; |
| 192 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src->format); |
| 193 | int pixel_shift = !!(desc->comp[0].depth_minus1 > 7); |
| 194 | |
| 195 | ret = av_frame_ref(out, src); |
| 196 | if (frame->flags & HEVC_FRAME_FLAG_BUMPING) |
| 197 | ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_BUMPING); |
| 198 | else |
| 199 | ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT); |
| 200 | if (ret < 0) |
| 201 | return ret; |
| 202 | |
| 203 | for (i = 0; i < 3; i++) { |
| 204 | int hshift = (i > 0) ? desc->log2_chroma_w : 0; |
| 205 | int vshift = (i > 0) ? desc->log2_chroma_h : 0; |
| 206 | int off = ((frame->window.left_offset >> hshift) << pixel_shift) + |
| 207 | (frame->window.top_offset >> vshift) * dst->linesize[i]; |
| 208 | dst->data[i] += off; |
| 209 | } |
| 210 | av_log(s->avctx, AV_LOG_DEBUG, |
| 211 | "Output frame with POC %d.\n", frame->poc); |
| 212 | return 1; |
| 213 | } |
| 214 | |
| 215 | if (s->seq_output != s->seq_decode) |
| 216 | s->seq_output = (s->seq_output + 1) & 0xff; |
| 217 | else |
| 218 | break; |
| 219 | } while (1); |
| 220 | |
| 221 | return 0; |
| 222 | } |
| 223 | |
| 224 | void ff_hevc_bump_frame(HEVCContext *s) |
| 225 | { |
| 226 | int dpb = 0; |
| 227 | int min_poc = INT_MAX; |
| 228 | int i; |
| 229 | |
| 230 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 231 | HEVCFrame *frame = &s->DPB[i]; |
| 232 | if ((frame->flags) && |
| 233 | frame->sequence == s->seq_output && |
| 234 | frame->poc != s->poc) { |
| 235 | dpb++; |
| 236 | } |
| 237 | } |
| 238 | |
| 239 | if (s->sps && dpb >= s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering) { |
| 240 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 241 | HEVCFrame *frame = &s->DPB[i]; |
| 242 | if ((frame->flags) && |
| 243 | frame->sequence == s->seq_output && |
| 244 | frame->poc != s->poc) { |
| 245 | if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) { |
| 246 | min_poc = frame->poc; |
| 247 | } |
| 248 | } |
| 249 | } |
| 250 | |
| 251 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 252 | HEVCFrame *frame = &s->DPB[i]; |
| 253 | if (frame->flags & HEVC_FRAME_FLAG_OUTPUT && |
| 254 | frame->sequence == s->seq_output && |
| 255 | frame->poc <= min_poc) { |
| 256 | frame->flags |= HEVC_FRAME_FLAG_BUMPING; |
| 257 | } |
| 258 | } |
| 259 | |
| 260 | dpb--; |
| 261 | } |
| 262 | } |
| 263 | |
| 264 | static int init_slice_rpl(HEVCContext *s) |
| 265 | { |
| 266 | HEVCFrame *frame = s->ref; |
| 267 | int ctb_count = frame->ctb_count; |
| 268 | int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr]; |
| 269 | int i; |
| 270 | |
| 271 | if (s->slice_idx >= frame->rpl_buf->size / sizeof(RefPicListTab)) |
| 272 | return AVERROR_INVALIDDATA; |
| 273 | |
| 274 | for (i = ctb_addr_ts; i < ctb_count; i++) |
| 275 | frame->rpl_tab[i] = (RefPicListTab *)frame->rpl_buf->data + s->slice_idx; |
| 276 | |
| 277 | frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts]; |
| 278 | |
| 279 | return 0; |
| 280 | } |
| 281 | |
| 282 | int ff_hevc_slice_rpl(HEVCContext *s) |
| 283 | { |
| 284 | SliceHeader *sh = &s->sh; |
| 285 | |
| 286 | uint8_t nb_list = sh->slice_type == B_SLICE ? 2 : 1; |
| 287 | uint8_t list_idx; |
| 288 | int i, j, ret; |
| 289 | |
| 290 | ret = init_slice_rpl(s); |
| 291 | if (ret < 0) |
| 292 | return ret; |
| 293 | |
| 294 | if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs + |
| 295 | s->rps[LT_CURR].nb_refs)) { |
| 296 | av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n"); |
| 297 | return AVERROR_INVALIDDATA; |
| 298 | } |
| 299 | |
| 300 | for (list_idx = 0; list_idx < nb_list; list_idx++) { |
| 301 | RefPicList rpl_tmp = { { 0 } }; |
| 302 | RefPicList *rpl = &s->ref->refPicList[list_idx]; |
| 303 | |
| 304 | /* The order of the elements is |
| 305 | * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and |
| 306 | * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */ |
| 307 | int cand_lists[3] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF, |
| 308 | list_idx ? ST_CURR_BEF : ST_CURR_AFT, |
| 309 | LT_CURR }; |
| 310 | |
| 311 | /* concatenate the candidate lists for the current frame */ |
| 312 | while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) { |
| 313 | for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) { |
| 314 | RefPicList *rps = &s->rps[cand_lists[i]]; |
| 315 | for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < MAX_REFS; j++) { |
| 316 | rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j]; |
| 317 | rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j]; |
| 318 | rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2; |
| 319 | rpl_tmp.nb_refs++; |
| 320 | } |
| 321 | } |
| 322 | } |
| 323 | |
| 324 | /* reorder the references if necessary */ |
| 325 | if (sh->rpl_modification_flag[list_idx]) { |
| 326 | for (i = 0; i < sh->nb_refs[list_idx]; i++) { |
| 327 | int idx = sh->list_entry_lx[list_idx][i]; |
| 328 | |
| 329 | if (idx >= rpl_tmp.nb_refs) { |
| 330 | av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n"); |
| 331 | return AVERROR_INVALIDDATA; |
| 332 | } |
| 333 | |
| 334 | rpl->list[i] = rpl_tmp.list[idx]; |
| 335 | rpl->ref[i] = rpl_tmp.ref[idx]; |
| 336 | rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx]; |
| 337 | rpl->nb_refs++; |
| 338 | } |
| 339 | } else { |
| 340 | memcpy(rpl, &rpl_tmp, sizeof(*rpl)); |
| 341 | rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]); |
| 342 | } |
| 343 | |
| 344 | if (sh->collocated_list == list_idx && |
| 345 | sh->collocated_ref_idx < rpl->nb_refs) |
| 346 | s->ref->collocated_ref = rpl->ref[sh->collocated_ref_idx]; |
| 347 | } |
| 348 | |
| 349 | return 0; |
| 350 | } |
| 351 | |
| 352 | static HEVCFrame *find_ref_idx(HEVCContext *s, int poc) |
| 353 | { |
| 354 | int i; |
| 355 | int LtMask = (1 << s->sps->log2_max_poc_lsb) - 1; |
| 356 | |
| 357 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 358 | HEVCFrame *ref = &s->DPB[i]; |
| 359 | if (ref->frame->buf[0] && (ref->sequence == s->seq_decode)) { |
| 360 | if ((ref->poc & LtMask) == poc) |
| 361 | return ref; |
| 362 | } |
| 363 | } |
| 364 | |
| 365 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 366 | HEVCFrame *ref = &s->DPB[i]; |
| 367 | if (ref->frame->buf[0] && ref->sequence == s->seq_decode) { |
| 368 | if (ref->poc == poc || (ref->poc & LtMask) == poc) |
| 369 | return ref; |
| 370 | } |
| 371 | } |
| 372 | |
| 373 | av_log(s->avctx, AV_LOG_ERROR, |
| 374 | "Could not find ref with POC %d\n", poc); |
| 375 | return NULL; |
| 376 | } |
| 377 | |
| 378 | static void mark_ref(HEVCFrame *frame, int flag) |
| 379 | { |
| 380 | frame->flags &= ~(HEVC_FRAME_FLAG_LONG_REF | HEVC_FRAME_FLAG_SHORT_REF); |
| 381 | frame->flags |= flag; |
| 382 | } |
| 383 | |
| 384 | static HEVCFrame *generate_missing_ref(HEVCContext *s, int poc) |
| 385 | { |
| 386 | HEVCFrame *frame; |
| 387 | int i, x, y; |
| 388 | |
| 389 | frame = alloc_frame(s); |
| 390 | if (!frame) |
| 391 | return NULL; |
| 392 | |
| 393 | if (!s->sps->pixel_shift) { |
| 394 | for (i = 0; frame->frame->buf[i]; i++) |
| 395 | memset(frame->frame->buf[i]->data, 1 << (s->sps->bit_depth - 1), |
| 396 | frame->frame->buf[i]->size); |
| 397 | } else { |
| 398 | for (i = 0; frame->frame->data[i]; i++) |
| 399 | for (y = 0; y < (s->sps->height >> s->sps->vshift[i]); y++) |
| 400 | for (x = 0; x < (s->sps->width >> s->sps->hshift[i]); x++) { |
| 401 | AV_WN16(frame->frame->data[i] + y * frame->frame->linesize[i] + 2 * x, |
| 402 | 1 << (s->sps->bit_depth - 1)); |
| 403 | } |
| 404 | } |
| 405 | |
| 406 | frame->poc = poc; |
| 407 | frame->sequence = s->seq_decode; |
| 408 | frame->flags = 0; |
| 409 | |
| 410 | if (s->threads_type == FF_THREAD_FRAME) |
| 411 | ff_thread_report_progress(&frame->tf, INT_MAX, 0); |
| 412 | |
| 413 | return frame; |
| 414 | } |
| 415 | |
| 416 | /* add a reference with the given poc to the list and mark it as used in DPB */ |
| 417 | static int add_candidate_ref(HEVCContext *s, RefPicList *list, |
| 418 | int poc, int ref_flag) |
| 419 | { |
| 420 | HEVCFrame *ref = find_ref_idx(s, poc); |
| 421 | |
| 422 | if (ref == s->ref) |
| 423 | return AVERROR_INVALIDDATA; |
| 424 | |
| 425 | if (!ref) { |
| 426 | ref = generate_missing_ref(s, poc); |
| 427 | if (!ref) |
| 428 | return AVERROR(ENOMEM); |
| 429 | } |
| 430 | |
| 431 | list->list[list->nb_refs] = ref->poc; |
| 432 | list->ref[list->nb_refs] = ref; |
| 433 | list->nb_refs++; |
| 434 | |
| 435 | mark_ref(ref, ref_flag); |
| 436 | return 0; |
| 437 | } |
| 438 | |
| 439 | int ff_hevc_frame_rps(HEVCContext *s) |
| 440 | { |
| 441 | const ShortTermRPS *short_rps = s->sh.short_term_rps; |
| 442 | const LongTermRPS *long_rps = &s->sh.long_term_rps; |
| 443 | RefPicList *rps = s->rps; |
| 444 | int i, ret; |
| 445 | |
| 446 | if (!short_rps) { |
| 447 | rps[0].nb_refs = rps[1].nb_refs = 0; |
| 448 | return 0; |
| 449 | } |
| 450 | |
| 451 | /* clear the reference flags on all frames except the current one */ |
| 452 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { |
| 453 | HEVCFrame *frame = &s->DPB[i]; |
| 454 | |
| 455 | if (frame == s->ref) |
| 456 | continue; |
| 457 | |
| 458 | mark_ref(frame, 0); |
| 459 | } |
| 460 | |
| 461 | for (i = 0; i < NB_RPS_TYPE; i++) |
| 462 | rps[i].nb_refs = 0; |
| 463 | |
| 464 | /* add the short refs */ |
| 465 | for (i = 0; i < short_rps->num_delta_pocs; i++) { |
| 466 | int poc = s->poc + short_rps->delta_poc[i]; |
| 467 | int list; |
| 468 | |
| 469 | if (!short_rps->used[i]) |
| 470 | list = ST_FOLL; |
| 471 | else if (i < short_rps->num_negative_pics) |
| 472 | list = ST_CURR_BEF; |
| 473 | else |
| 474 | list = ST_CURR_AFT; |
| 475 | |
| 476 | ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_SHORT_REF); |
| 477 | if (ret < 0) |
| 478 | return ret; |
| 479 | } |
| 480 | |
| 481 | /* add the long refs */ |
| 482 | for (i = 0; i < long_rps->nb_refs; i++) { |
| 483 | int poc = long_rps->poc[i]; |
| 484 | int list = long_rps->used[i] ? LT_CURR : LT_FOLL; |
| 485 | |
| 486 | ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_LONG_REF); |
| 487 | if (ret < 0) |
| 488 | return ret; |
| 489 | } |
| 490 | |
| 491 | /* release any frames that are now unused */ |
| 492 | for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) |
| 493 | ff_hevc_unref_frame(s, &s->DPB[i], 0); |
| 494 | |
| 495 | return 0; |
| 496 | } |
| 497 | |
| 498 | int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb) |
| 499 | { |
| 500 | int max_poc_lsb = 1 << s->sps->log2_max_poc_lsb; |
| 501 | int prev_poc_lsb = s->pocTid0 % max_poc_lsb; |
| 502 | int prev_poc_msb = s->pocTid0 - prev_poc_lsb; |
| 503 | int poc_msb; |
| 504 | |
| 505 | if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2) |
| 506 | poc_msb = prev_poc_msb + max_poc_lsb; |
| 507 | else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2) |
| 508 | poc_msb = prev_poc_msb - max_poc_lsb; |
| 509 | else |
| 510 | poc_msb = prev_poc_msb; |
| 511 | |
| 512 | // For BLA picture types, POCmsb is set to 0. |
| 513 | if (s->nal_unit_type == NAL_BLA_W_LP || |
| 514 | s->nal_unit_type == NAL_BLA_W_RADL || |
| 515 | s->nal_unit_type == NAL_BLA_N_LP) |
| 516 | poc_msb = 0; |
| 517 | |
| 518 | return poc_msb + poc_lsb; |
| 519 | } |
| 520 | |
| 521 | int ff_hevc_frame_nb_refs(HEVCContext *s) |
| 522 | { |
| 523 | int ret = 0; |
| 524 | int i; |
| 525 | const ShortTermRPS *rps = s->sh.short_term_rps; |
| 526 | LongTermRPS *long_rps = &s->sh.long_term_rps; |
| 527 | |
| 528 | if (rps) { |
| 529 | for (i = 0; i < rps->num_negative_pics; i++) |
| 530 | ret += !!rps->used[i]; |
| 531 | for (; i < rps->num_delta_pocs; i++) |
| 532 | ret += !!rps->used[i]; |
| 533 | } |
| 534 | |
| 535 | if (long_rps) { |
| 536 | for (i = 0; i < long_rps->nb_refs; i++) |
| 537 | ret += !!long_rps->used[i]; |
| 538 | } |
| 539 | return ret; |
| 540 | } |