FFmpeg
hevc_refs.c
Go to the documentation of this file.
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/avassert.h"
25 
26 #include "decode.h"
27 #include "thread.h"
28 #include "hevc.h"
29 #include "hevcdec.h"
30 #include "refstruct.h"
31 #include "threadframe.h"
32 
34 {
35  /* frame->frame can be NULL if context init failed */
36  if (!frame->frame || !frame->frame->buf[0])
37  return;
38 
39  frame->flags &= ~flags;
40  if (!frame->flags) {
42  av_frame_unref(frame->frame_grain);
43  frame->needs_fg = 0;
44 
45  ff_refstruct_unref(&frame->tab_mvf);
46 
48  frame->nb_rpl_elems = 0;
49  ff_refstruct_unref(&frame->rpl_tab);
50  frame->refPicList = NULL;
51 
52  ff_refstruct_unref(&frame->hwaccel_picture_private);
53  }
54 }
55 
57  const HEVCFrame *ref, int x0, int y0)
58 {
59  int x_cb = x0 >> s->ps.sps->log2_ctb_size;
60  int y_cb = y0 >> s->ps.sps->log2_ctb_size;
61  int pic_width_cb = s->ps.sps->ctb_width;
62  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[y_cb * pic_width_cb + x_cb];
63  return &ref->rpl_tab[ctb_addr_ts]->refPicList[0];
64 }
65 
67 {
68  int i;
69  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
70  ff_hevc_unref_frame(&s->DPB[i],
73 }
74 
76 {
77  int i;
78  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
79  ff_hevc_unref_frame(&s->DPB[i], ~0);
80 }
81 
83 {
84  int i, j, ret;
85  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
86  HEVCFrame *frame = &s->DPB[i];
87  if (frame->frame->buf[0])
88  continue;
89 
90  ret = ff_thread_get_ext_buffer(s->avctx, &frame->tf,
92  if (ret < 0)
93  return NULL;
94 
95  frame->rpl = ff_refstruct_allocz(s->pkt.nb_nals * sizeof(*frame->rpl));
96  if (!frame->rpl)
97  goto fail;
98  frame->nb_rpl_elems = s->pkt.nb_nals;
99 
100  frame->tab_mvf = ff_refstruct_pool_get(s->tab_mvf_pool);
101  if (!frame->tab_mvf)
102  goto fail;
103 
104  frame->rpl_tab = ff_refstruct_pool_get(s->rpl_tab_pool);
105  if (!frame->rpl_tab)
106  goto fail;
107  frame->ctb_count = s->ps.sps->ctb_width * s->ps.sps->ctb_height;
108  for (j = 0; j < frame->ctb_count; j++)
109  frame->rpl_tab[j] = frame->rpl;
110 
111  if (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD)
113  if ((s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) ||
114  (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD))
116 
117  ret = ff_hwaccel_frame_priv_alloc(s->avctx, &frame->hwaccel_picture_private);
118  if (ret < 0)
119  goto fail;
120 
121  return frame;
122 fail:
124  return NULL;
125  }
126  av_log(s->avctx, AV_LOG_ERROR, "Error allocating frame, DPB full.\n");
127  return NULL;
128 }
129 
131 {
132  HEVCFrame *ref;
133  int i;
134 
135  /* check that this POC doesn't already exist */
136  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
137  HEVCFrame *frame = &s->DPB[i];
138 
139  if (frame->frame->buf[0] && frame->sequence == s->seq_decode &&
140  frame->poc == poc) {
141  av_log(s->avctx, AV_LOG_ERROR, "Duplicate POC in a sequence: %d.\n",
142  poc);
143  return AVERROR_INVALIDDATA;
144  }
145  }
146 
147  ref = alloc_frame(s);
148  if (!ref)
149  return AVERROR(ENOMEM);
150 
151  *frame = ref->frame;
152  s->ref = ref;
153  s->collocated_ref = NULL;
154 
155  if (s->sh.pic_output_flag)
157  else
159 
160  ref->poc = poc;
161  ref->sequence = s->seq_decode;
162  ref->frame->crop_left = s->ps.sps->output_window.left_offset;
163  ref->frame->crop_right = s->ps.sps->output_window.right_offset;
164  ref->frame->crop_top = s->ps.sps->output_window.top_offset;
165  ref->frame->crop_bottom = s->ps.sps->output_window.bottom_offset;
166 
167  return 0;
168 }
169 
171 {
172  for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
173  HEVCFrame *frame = &s->DPB[i];
174  if (frame->sequence == HEVC_SEQUENCE_COUNTER_INVALID) {
176  }
177  }
178 }
179 
181 {
182  if (IS_IRAP(s) && s->no_rasl_output_flag == 1) {
184  for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
185  HEVCFrame *frame = &s->DPB[i];
186  if ((frame->flags & mask) == HEVC_FRAME_FLAG_OUTPUT &&
187  frame->sequence != s->seq_decode) {
188  if (s->sh.no_output_of_prior_pics_flag == 1)
190  else
192  }
193  }
194  }
195  do {
196  int nb_output = 0;
197  int min_poc = INT_MAX;
198  int i, min_idx, ret;
199 
200  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
201  HEVCFrame *frame = &s->DPB[i];
203  frame->sequence == s->seq_output) {
204  nb_output++;
205  if (frame->poc < min_poc || nb_output == 1) {
206  min_poc = frame->poc;
207  min_idx = i;
208  }
209  }
210  }
211 
212  /* wait for more frames before output */
213  if (!flush && s->seq_output == s->seq_decode && s->ps.sps &&
214  nb_output <= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].num_reorder_pics)
215  return 0;
216 
217  if (nb_output) {
218  HEVCFrame *frame = &s->DPB[min_idx];
219 
220  ret = av_frame_ref(out, frame->needs_fg ? frame->frame_grain : frame->frame);
223  else
225  if (ret < 0)
226  return ret;
227 
228  if (frame->needs_fg && (ret = av_frame_copy_props(out, frame->frame)) < 0)
229  return ret;
230 
231  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN))
233 
234  av_log(s->avctx, AV_LOG_DEBUG,
235  "Output frame with POC %d.\n", frame->poc);
236  return 1;
237  }
238 
239  if (s->seq_output != s->seq_decode)
240  s->seq_output = (s->seq_output + 1) & HEVC_SEQUENCE_COUNTER_MASK;
241  else
242  break;
243  } while (1);
244 
245  return 0;
246 }
247 
249 {
250  int dpb = 0;
251  int min_poc = INT_MAX;
252  int i;
253 
254  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
255  HEVCFrame *frame = &s->DPB[i];
256  if ((frame->flags) &&
257  frame->sequence == s->seq_output &&
258  frame->poc != s->poc) {
259  dpb++;
260  }
261  }
262 
263  if (s->ps.sps && dpb >= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering) {
264  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
265  HEVCFrame *frame = &s->DPB[i];
266  if ((frame->flags) &&
267  frame->sequence == s->seq_output &&
268  frame->poc != s->poc) {
269  if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) {
270  min_poc = frame->poc;
271  }
272  }
273  }
274 
275  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
276  HEVCFrame *frame = &s->DPB[i];
278  frame->sequence == s->seq_output &&
279  frame->poc <= min_poc) {
281  }
282  }
283 
284  dpb--;
285  }
286 }
287 
289 {
290  HEVCFrame *frame = s->ref;
291  int ctb_count = frame->ctb_count;
292  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
293  int i;
294 
295  if (s->slice_idx >= frame->nb_rpl_elems)
296  return AVERROR_INVALIDDATA;
297 
298  for (i = ctb_addr_ts; i < ctb_count; i++)
299  frame->rpl_tab[i] = frame->rpl + s->slice_idx;
300 
301  frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];
302 
303  return 0;
304 }
305 
307 {
308  SliceHeader *sh = &s->sh;
309 
310  uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;
311  uint8_t list_idx;
312  int i, j, ret;
313 
314  ret = init_slice_rpl(s);
315  if (ret < 0)
316  return ret;
317 
318  if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs +
319  s->rps[LT_CURR].nb_refs) && !s->ps.pps->pps_curr_pic_ref_enabled_flag) {
320  av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n");
321  return AVERROR_INVALIDDATA;
322  }
323 
324  for (list_idx = 0; list_idx < nb_list; list_idx++) {
325  RefPicList rpl_tmp = { { 0 } };
326  RefPicList *rpl = &s->ref->refPicList[list_idx];
327 
328  /* The order of the elements is
329  * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and
330  * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */
331  int cand_lists[3] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,
332  list_idx ? ST_CURR_BEF : ST_CURR_AFT,
333  LT_CURR };
334 
335  /* concatenate the candidate lists for the current frame */
336  while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {
337  for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
338  RefPicList *rps = &s->rps[cand_lists[i]];
339  for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {
340  rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];
341  rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j];
342  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2;
343  rpl_tmp.nb_refs++;
344  }
345  }
346  // Construct RefPicList0, RefPicList1 (8-8, 8-10)
347  if (s->ps.pps->pps_curr_pic_ref_enabled_flag && rpl_tmp.nb_refs < HEVC_MAX_REFS) {
348  rpl_tmp.list[rpl_tmp.nb_refs] = s->ref->poc;
349  rpl_tmp.ref[rpl_tmp.nb_refs] = s->ref;
350  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = 1;
351  rpl_tmp.nb_refs++;
352  }
353  }
354 
355  /* reorder the references if necessary */
356  if (sh->rpl_modification_flag[list_idx]) {
357  for (i = 0; i < sh->nb_refs[list_idx]; i++) {
358  int idx = sh->list_entry_lx[list_idx][i];
359 
360  if (idx >= rpl_tmp.nb_refs) {
361  av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n");
362  return AVERROR_INVALIDDATA;
363  }
364 
365  rpl->list[i] = rpl_tmp.list[idx];
366  rpl->ref[i] = rpl_tmp.ref[idx];
367  rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx];
368  rpl->nb_refs++;
369  }
370  } else {
371  memcpy(rpl, &rpl_tmp, sizeof(*rpl));
372  rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]);
373  }
374 
375  // 8-9
376  if (s->ps.pps->pps_curr_pic_ref_enabled_flag &&
377  !sh->rpl_modification_flag[list_idx] &&
378  rpl_tmp.nb_refs > sh->nb_refs[L0]) {
379  rpl->list[sh->nb_refs[L0] - 1] = s->ref->poc;
380  rpl->ref[sh->nb_refs[L0] - 1] = s->ref;
381  }
382 
383  if (sh->collocated_list == list_idx &&
384  sh->collocated_ref_idx < rpl->nb_refs)
385  s->collocated_ref = rpl->ref[sh->collocated_ref_idx];
386  }
387 
388  return 0;
389 }
390 
391 static HEVCFrame *find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
392 {
393  int mask = use_msb ? ~0 : (1 << s->ps.sps->log2_max_poc_lsb) - 1;
394  int i;
395 
396  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
397  HEVCFrame *ref = &s->DPB[i];
398  if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
399  if ((ref->poc & mask) == poc && (use_msb || ref->poc != s->poc))
400  return ref;
401  }
402  }
403 
404  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
405  av_log(s->avctx, AV_LOG_ERROR,
406  "Could not find ref with POC %d\n", poc);
407  return NULL;
408 }
409 
410 static void mark_ref(HEVCFrame *frame, int flag)
411 {
413  frame->flags |= flag;
414 }
415 
417 {
418  HEVCFrame *frame;
419  int i, y;
420 
421  frame = alloc_frame(s);
422  if (!frame)
423  return NULL;
424 
425  if (!s->avctx->hwaccel) {
426  if (!s->ps.sps->pixel_shift) {
427  for (i = 0; frame->frame->data[i]; i++)
428  memset(frame->frame->data[i], 1 << (s->ps.sps->bit_depth - 1),
429  frame->frame->linesize[i] * AV_CEIL_RSHIFT(s->ps.sps->height, s->ps.sps->vshift[i]));
430  } else {
431  for (i = 0; frame->frame->data[i]; i++)
432  for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++) {
433  uint8_t *dst = frame->frame->data[i] + y * frame->frame->linesize[i];
434  AV_WN16(dst, 1 << (s->ps.sps->bit_depth - 1));
435  av_memcpy_backptr(dst + 2, 2, 2*(s->ps.sps->width >> s->ps.sps->hshift[i]) - 2);
436  }
437  }
438  }
439 
440  frame->poc = poc;
442  frame->flags = 0;
443 
444  if (s->threads_type == FF_THREAD_FRAME)
445  ff_thread_report_progress(&frame->tf, INT_MAX, 0);
446 
447  return frame;
448 }
449 
450 /* add a reference with the given poc to the list and mark it as used in DPB */
452  int poc, int ref_flag, uint8_t use_msb)
453 {
454  HEVCFrame *ref = find_ref_idx(s, poc, use_msb);
455 
456  if (ref == s->ref || list->nb_refs >= HEVC_MAX_REFS)
457  return AVERROR_INVALIDDATA;
458 
459  if (!ref) {
460  ref = generate_missing_ref(s, poc);
461  if (!ref)
462  return AVERROR(ENOMEM);
463  }
464 
465  list->list[list->nb_refs] = ref->poc;
466  list->ref[list->nb_refs] = ref;
467  list->nb_refs++;
468 
469  mark_ref(ref, ref_flag);
470  return 0;
471 }
472 
474 {
475  const ShortTermRPS *short_rps = s->sh.short_term_rps;
476  const LongTermRPS *long_rps = &s->sh.long_term_rps;
477  RefPicList *rps = s->rps;
478  int i, ret = 0;
479 
480  if (!short_rps) {
481  rps[0].nb_refs = rps[1].nb_refs = 0;
482  return 0;
483  }
484 
486 
487  /* clear the reference flags on all frames except the current one */
488  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
489  HEVCFrame *frame = &s->DPB[i];
490 
491  if (frame == s->ref)
492  continue;
493 
494  mark_ref(frame, 0);
495  }
496 
497  for (i = 0; i < NB_RPS_TYPE; i++)
498  rps[i].nb_refs = 0;
499 
500  /* add the short refs */
501  for (i = 0; i < short_rps->num_delta_pocs; i++) {
502  int poc = s->poc + short_rps->delta_poc[i];
503  int list;
504 
505  if (!short_rps->used[i])
506  list = ST_FOLL;
507  else if (i < short_rps->num_negative_pics)
508  list = ST_CURR_BEF;
509  else
510  list = ST_CURR_AFT;
511 
513  if (ret < 0)
514  goto fail;
515  }
516 
517  /* add the long refs */
518  for (i = 0; i < long_rps->nb_refs; i++) {
519  int poc = long_rps->poc[i];
520  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
521 
523  if (ret < 0)
524  goto fail;
525  }
526 
527 fail:
528  /* release any frames that are now unused */
529  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
530  ff_hevc_unref_frame(&s->DPB[i], 0);
531 
532  return ret;
533 }
534 
536 {
537  int ret = 0;
538  int i;
539  const ShortTermRPS *rps = s->sh.short_term_rps;
540  const LongTermRPS *long_rps = &s->sh.long_term_rps;
541 
542  if (rps) {
543  for (i = 0; i < rps->num_negative_pics; i++)
544  ret += !!rps->used[i];
545  for (; i < rps->num_delta_pocs; i++)
546  ret += !!rps->used[i];
547  }
548 
549  if (long_rps) {
550  for (i = 0; i < long_rps->nb_refs; i++)
551  ret += !!long_rps->used[i];
552  }
553 
554  if (s->ps.pps->pps_curr_pic_ref_enabled_flag)
555  ret++;
556 
557  return ret;
558 }
ShortTermRPS::used
uint8_t used[32]
Definition: hevc_ps.h:83
LT_FOLL
@ LT_FOLL
Definition: hevcdec.h:85
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_hevc_get_ref_list
const RefPicList * ff_hevc_get_ref_list(const HEVCContext *s, const HEVCFrame *ref, int x0, int y0)
Definition: hevc_refs.c:56
out
FILE * out
Definition: movenc.c:54
find_ref_idx
static HEVCFrame * find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
Definition: hevc_refs.c:391
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:184
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:590
RefPicList
Definition: hevcdec.h:241
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
add_candidate_ref
static int add_candidate_ref(HEVCContext *s, RefPicList *list, int poc, int ref_flag, uint8_t use_msb)
Definition: hevc_refs.c:451
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:641
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:400
ff_hevc_clear_refs
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
Definition: hevc_refs.c:66
fail
#define fail()
Definition: checkasm.h:179
mark_ref
static void mark_ref(HEVCFrame *frame, int flag)
Definition: hevc_refs.c:410
ff_hevc_output_frame
int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush)
Find next frame in output order and put a reference to it in frame.
Definition: hevc_refs.c:180
RefPicList::nb_refs
int nb_refs
Definition: hevcdec.h:245
ShortTermRPS::num_delta_pocs
int num_delta_pocs
Definition: hevc_ps.h:78
refstruct.h
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
HEVC_SEQUENCE_COUNTER_INVALID
#define HEVC_SEQUENCE_COUNTER_INVALID
Definition: hevcdec.h:404
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:589
HEVC_FRAME_FLAG_BUMPING
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:401
mask
static const uint16_t mask[17]
Definition: lzw.c:38
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:445
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:1839
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:119
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:425
init_slice_rpl
static int init_slice_rpl(HEVCContext *s)
Definition: hevc_refs.c:288
ff_hevc_set_new_ref
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
Definition: hevc_refs.c:130
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
decode.h
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:399
ff_hevc_slice_rpl
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: hevc_refs.c:306
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:242
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:290
generate_missing_ref
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:416
frame
static AVFrame * frame
Definition: demux_decode.c:54
if
if(ret)
Definition: filter_design.txt:179
AV_PICTURE_STRUCTURE_BOTTOM_FIELD
@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD
coded as bottom field
Definition: avcodec.h:2777
threadframe.h
IS_BLA
#define IS_BLA(s)
Definition: hevcdec.h:76
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
NULL
#define NULL
Definition: coverity.c:32
HEVC_SEQUENCE_COUNTER_MASK
#define HEVC_SEQUENCE_COUNTER_MASK
Definition: hevcdec.h:403
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:736
LongTermRPS::poc
int poc[32]
Definition: hevcdec.h:235
AV_PICTURE_STRUCTURE_TOP_FIELD
@ AV_PICTURE_STRUCTURE_TOP_FIELD
coded as top field
Definition: avcodec.h:2776
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1012
L0
#define L0
Definition: hevcdec.h:57
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:367
LongTermRPS::poc_msb_present
uint8_t poc_msb_present[32]
Definition: hevcdec.h:236
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
HEVC_NAL_CRA_NUT
@ HEVC_NAL_CRA_NUT
Definition: hevc.h:50
SliceHeader::nb_refs
unsigned int nb_refs[2]
Definition: hevcdec.h:282
ff_hevc_frame_rps
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:473
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:78
LongTermRPS::used
uint8_t used[32]
Definition: hevcdec.h:237
ST_FOLL
@ ST_FOLL
Definition: hevcdec.h:83
hevcdec.h
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:361
RefPicList::isLongTerm
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:244
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
SliceHeader::collocated_ref_idx
unsigned int collocated_ref_idx
Definition: hevcdec.h:292
HEVC_FRAME_FLAG_OUTPUT
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:398
alloc_frame
static HEVCFrame * alloc_frame(HEVCContext *s)
Definition: hevc_refs.c:82
av_frame_remove_side_data
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type.
Definition: frame.c:919
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1547
ShortTermRPS::num_negative_pics
unsigned int num_negative_pics
Definition: hevc_ps.h:77
flag
#define flag(name)
Definition: cbs_av1.c:466
SliceHeader
Definition: hevcdec.h:252
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
HEVCFrame
Definition: hevcdec.h:406
unref_missing_refs
static void unref_missing_refs(HEVCContext *s)
Definition: hevc_refs.c:170
ff_hevc_bump_frame
void ff_hevc_bump_frame(HEVCContext *s)
Definition: hevc_refs.c:248
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
SliceHeader::list_entry_lx
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:276
ff_thread_get_ext_buffer
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around ff_get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:984
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:636
hevc.h
ff_hevc_unref_frame
void ff_hevc_unref_frame(HEVCFrame *frame, int flags)
Definition: hevc_refs.c:33
ret
ret
Definition: filter_design.txt:187
ST_CURR_BEF
@ ST_CURR_BEF
Definition: hevcdec.h:81
ff_hevc_frame_nb_refs
int ff_hevc_frame_nb_refs(const HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:535
LongTermRPS
Definition: hevcdec.h:234
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:260
ff_hevc_flush_dpb
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:75
LT_CURR
@ LT_CURR
Definition: hevcdec.h:84
NB_RPS_TYPE
@ NB_RPS_TYPE
Definition: hevcdec.h:86
HEVCContext
Definition: hevcdec.h:492
SliceHeader::rpl_modification_flag
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:278
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ShortTermRPS
Definition: hevc_ps.h:71
RefPicList::list
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:243
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:82
LongTermRPS::nb_refs
uint8_t nb_refs
Definition: hevcdec.h:238
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ShortTermRPS::delta_poc
int32_t delta_poc[32]
Definition: hevc_ps.h:82
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:420
ff_refstruct_pool_get
void * ff_refstruct_pool_get(FFRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:370