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/mem.h"
25 
26 #include "decode.h"
27 #include "hevc.h"
28 #include "hevcdec.h"
29 #include "progressframe.h"
30 #include "refstruct.h"
31 
33 {
34  frame->flags &= ~flags;
35  if (!frame->flags) {
37  av_frame_unref(frame->frame_grain);
38  frame->needs_fg = 0;
39 
40  ff_refstruct_unref(&frame->tab_mvf);
41 
43  frame->nb_rpl_elems = 0;
44  ff_refstruct_unref(&frame->rpl_tab);
45  frame->refPicList = NULL;
46 
47  ff_refstruct_unref(&frame->hwaccel_picture_private);
48  }
49 }
50 
52  const HEVCFrame *ref, int x0, int y0)
53 {
54  int x_cb = x0 >> s->ps.sps->log2_ctb_size;
55  int y_cb = y0 >> s->ps.sps->log2_ctb_size;
56  int pic_width_cb = s->ps.sps->ctb_width;
57  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[y_cb * pic_width_cb + x_cb];
58  return &ref->rpl_tab[ctb_addr_ts]->refPicList[0];
59 }
60 
62 {
63  int i;
64  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
65  ff_hevc_unref_frame(&s->DPB[i],
68 }
69 
71 {
72  int i;
73  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
74  ff_hevc_unref_frame(&s->DPB[i], ~0);
75 }
76 
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)
83  continue;
84 
85  ret = ff_progress_frame_get_buffer(s->avctx, &frame->tf,
87  if (ret < 0)
88  return NULL;
89 
90  frame->rpl = ff_refstruct_allocz(s->pkt.nb_nals * sizeof(*frame->rpl));
91  if (!frame->rpl)
92  goto fail;
93  frame->nb_rpl_elems = s->pkt.nb_nals;
94 
95  frame->tab_mvf = ff_refstruct_pool_get(s->tab_mvf_pool);
96  if (!frame->tab_mvf)
97  goto fail;
98 
99  frame->rpl_tab = ff_refstruct_pool_get(s->rpl_tab_pool);
100  if (!frame->rpl_tab)
101  goto fail;
102  frame->ctb_count = s->ps.sps->ctb_width * s->ps.sps->ctb_height;
103  for (j = 0; j < frame->ctb_count; j++)
104  frame->rpl_tab[j] = frame->rpl;
105 
106  if (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD)
107  frame->frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
108  if ((s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) ||
109  (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD))
110  frame->frame->flags |= AV_FRAME_FLAG_INTERLACED;
111 
112  ret = ff_hwaccel_frame_priv_alloc(s->avctx, &frame->hwaccel_picture_private);
113  if (ret < 0)
114  goto fail;
115 
116  return frame;
117 fail:
119  return NULL;
120  }
121  av_log(s->avctx, AV_LOG_ERROR, "Error allocating frame, DPB full.\n");
122  return NULL;
123 }
124 
126 {
127  HEVCFrame *ref;
128  int i;
129 
130  /* check that this POC doesn't already exist */
131  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
132  HEVCFrame *frame = &s->DPB[i];
133 
134  if (frame->frame && frame->sequence == s->seq_decode &&
135  frame->poc == poc) {
136  av_log(s->avctx, AV_LOG_ERROR, "Duplicate POC in a sequence: %d.\n",
137  poc);
138  return AVERROR_INVALIDDATA;
139  }
140  }
141 
142  ref = alloc_frame(s);
143  if (!ref)
144  return AVERROR(ENOMEM);
145 
146  *frame = ref->frame;
147  s->ref = ref;
148  s->collocated_ref = NULL;
149 
150  if (s->sh.pic_output_flag)
152  else
154 
155  ref->poc = poc;
156  ref->sequence = s->seq_decode;
157  ref->frame->crop_left = s->ps.sps->output_window.left_offset;
158  ref->frame->crop_right = s->ps.sps->output_window.right_offset;
159  ref->frame->crop_top = s->ps.sps->output_window.top_offset;
160  ref->frame->crop_bottom = s->ps.sps->output_window.bottom_offset;
161 
162  return 0;
163 }
164 
166 {
167  for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
168  HEVCFrame *frame = &s->DPB[i];
169  if (frame->sequence == HEVC_SEQUENCE_COUNTER_INVALID) {
171  }
172  }
173 }
174 
176 {
177  if (IS_IRAP(s) && s->no_rasl_output_flag == 1) {
179  for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
180  HEVCFrame *frame = &s->DPB[i];
181  if ((frame->flags & mask) == HEVC_FRAME_FLAG_OUTPUT &&
182  frame->sequence != s->seq_decode) {
183  if (s->sh.no_output_of_prior_pics_flag == 1)
185  else
186  frame->flags |= HEVC_FRAME_FLAG_BUMPING;
187  }
188  }
189  }
190  do {
191  int nb_output = 0;
192  int min_poc = INT_MAX;
193  int i, min_idx, ret;
194 
195  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
196  HEVCFrame *frame = &s->DPB[i];
197  if ((frame->flags & HEVC_FRAME_FLAG_OUTPUT) &&
198  frame->sequence == s->seq_output) {
199  nb_output++;
200  if (frame->poc < min_poc || nb_output == 1) {
201  min_poc = frame->poc;
202  min_idx = i;
203  }
204  }
205  }
206 
207  /* wait for more frames before output */
208  if (!flush && s->seq_output == s->seq_decode && s->ps.sps &&
209  nb_output <= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].num_reorder_pics)
210  return 0;
211 
212  if (nb_output) {
213  HEVCFrame *frame = &s->DPB[min_idx];
214 
215  ret = av_frame_ref(out, frame->needs_fg ? frame->frame_grain : frame->frame);
216  if (frame->flags & HEVC_FRAME_FLAG_BUMPING)
218  else
220  if (ret < 0)
221  return ret;
222 
223  if (frame->needs_fg && (ret = av_frame_copy_props(out, frame->frame)) < 0)
224  return ret;
225 
226  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN))
228 
229  av_log(s->avctx, AV_LOG_DEBUG,
230  "Output frame with POC %d.\n", frame->poc);
231  return 1;
232  }
233 
234  if (s->seq_output != s->seq_decode)
235  s->seq_output = (s->seq_output + 1) & HEVC_SEQUENCE_COUNTER_MASK;
236  else
237  break;
238  } while (1);
239 
240  return 0;
241 }
242 
244 {
245  int dpb = 0;
246  int min_poc = INT_MAX;
247  int i;
248 
249  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
250  HEVCFrame *frame = &s->DPB[i];
251  if ((frame->flags) &&
252  frame->sequence == s->seq_output &&
253  frame->poc != s->poc) {
254  dpb++;
255  }
256  }
257 
258  if (s->ps.sps && dpb >= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering) {
259  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
260  HEVCFrame *frame = &s->DPB[i];
261  if ((frame->flags) &&
262  frame->sequence == s->seq_output &&
263  frame->poc != s->poc) {
264  if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) {
265  min_poc = frame->poc;
266  }
267  }
268  }
269 
270  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
271  HEVCFrame *frame = &s->DPB[i];
272  if (frame->flags & HEVC_FRAME_FLAG_OUTPUT &&
273  frame->sequence == s->seq_output &&
274  frame->poc <= min_poc) {
275  frame->flags |= HEVC_FRAME_FLAG_BUMPING;
276  }
277  }
278 
279  dpb--;
280  }
281 }
282 
284 {
285  HEVCFrame *frame = s->ref;
286  int ctb_count = frame->ctb_count;
287  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
288  int i;
289 
290  if (s->slice_idx >= frame->nb_rpl_elems)
291  return AVERROR_INVALIDDATA;
292 
293  for (i = ctb_addr_ts; i < ctb_count; i++)
294  frame->rpl_tab[i] = frame->rpl + s->slice_idx;
295 
296  frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];
297 
298  return 0;
299 }
300 
302 {
303  SliceHeader *sh = &s->sh;
304 
305  uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;
306  uint8_t list_idx;
307  int i, j, ret;
308 
309  ret = init_slice_rpl(s);
310  if (ret < 0)
311  return ret;
312 
313  if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs +
314  s->rps[LT_CURR].nb_refs) && !s->ps.pps->pps_curr_pic_ref_enabled_flag) {
315  av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n");
316  return AVERROR_INVALIDDATA;
317  }
318 
319  for (list_idx = 0; list_idx < nb_list; list_idx++) {
320  RefPicList rpl_tmp = { { 0 } };
321  RefPicList *rpl = &s->ref->refPicList[list_idx];
322 
323  /* The order of the elements is
324  * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and
325  * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */
326  int cand_lists[3] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,
327  list_idx ? ST_CURR_BEF : ST_CURR_AFT,
328  LT_CURR };
329 
330  /* concatenate the candidate lists for the current frame */
331  while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {
332  for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
333  RefPicList *rps = &s->rps[cand_lists[i]];
334  for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {
335  rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];
336  rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j];
337  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2;
338  rpl_tmp.nb_refs++;
339  }
340  }
341  // Construct RefPicList0, RefPicList1 (8-8, 8-10)
342  if (s->ps.pps->pps_curr_pic_ref_enabled_flag && rpl_tmp.nb_refs < HEVC_MAX_REFS) {
343  rpl_tmp.list[rpl_tmp.nb_refs] = s->ref->poc;
344  rpl_tmp.ref[rpl_tmp.nb_refs] = s->ref;
345  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = 1;
346  rpl_tmp.nb_refs++;
347  }
348  }
349 
350  /* reorder the references if necessary */
351  if (sh->rpl_modification_flag[list_idx]) {
352  for (i = 0; i < sh->nb_refs[list_idx]; i++) {
353  int idx = sh->list_entry_lx[list_idx][i];
354 
355  if (idx >= rpl_tmp.nb_refs) {
356  av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n");
357  return AVERROR_INVALIDDATA;
358  }
359 
360  rpl->list[i] = rpl_tmp.list[idx];
361  rpl->ref[i] = rpl_tmp.ref[idx];
362  rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx];
363  rpl->nb_refs++;
364  }
365  } else {
366  memcpy(rpl, &rpl_tmp, sizeof(*rpl));
367  rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]);
368  }
369 
370  // 8-9
371  if (s->ps.pps->pps_curr_pic_ref_enabled_flag &&
372  !sh->rpl_modification_flag[list_idx] &&
373  rpl_tmp.nb_refs > sh->nb_refs[L0]) {
374  rpl->list[sh->nb_refs[L0] - 1] = s->ref->poc;
375  rpl->ref[sh->nb_refs[L0] - 1] = s->ref;
376  }
377 
378  if (sh->collocated_list == list_idx &&
379  sh->collocated_ref_idx < rpl->nb_refs)
380  s->collocated_ref = rpl->ref[sh->collocated_ref_idx];
381  }
382 
383  return 0;
384 }
385 
386 static HEVCFrame *find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
387 {
388  int mask = use_msb ? ~0 : (1 << s->ps.sps->log2_max_poc_lsb) - 1;
389  int i;
390 
391  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
392  HEVCFrame *ref = &s->DPB[i];
393  if (ref->frame && ref->sequence == s->seq_decode) {
394  if ((ref->poc & mask) == poc && (use_msb || ref->poc != s->poc))
395  return ref;
396  }
397  }
398 
399  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
400  av_log(s->avctx, AV_LOG_ERROR,
401  "Could not find ref with POC %d\n", poc);
402  return NULL;
403 }
404 
405 static void mark_ref(HEVCFrame *frame, int flag)
406 {
408  frame->flags |= flag;
409 }
410 
412 {
413  HEVCFrame *frame;
414  int i, y;
415 
416  frame = alloc_frame(s);
417  if (!frame)
418  return NULL;
419 
420  if (!s->avctx->hwaccel) {
421  if (!s->ps.sps->pixel_shift) {
422  for (i = 0; frame->frame->data[i]; i++)
423  memset(frame->frame->data[i], 1 << (s->ps.sps->bit_depth - 1),
424  frame->frame->linesize[i] * AV_CEIL_RSHIFT(s->ps.sps->height, s->ps.sps->vshift[i]));
425  } else {
426  for (i = 0; frame->frame->data[i]; i++)
427  for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++) {
428  uint8_t *dst = frame->frame->data[i] + y * frame->frame->linesize[i];
429  AV_WN16(dst, 1 << (s->ps.sps->bit_depth - 1));
430  av_memcpy_backptr(dst + 2, 2, 2*(s->ps.sps->width >> s->ps.sps->hshift[i]) - 2);
431  }
432  }
433  }
434 
435  frame->poc = poc;
437  frame->flags = 0;
438 
439  if (s->threads_type == FF_THREAD_FRAME)
440  ff_progress_frame_report(&frame->tf, INT_MAX);
441 
442  return frame;
443 }
444 
445 /* add a reference with the given poc to the list and mark it as used in DPB */
447  int poc, int ref_flag, uint8_t use_msb)
448 {
449  HEVCFrame *ref = find_ref_idx(s, poc, use_msb);
450 
451  if (ref == s->ref || list->nb_refs >= HEVC_MAX_REFS)
452  return AVERROR_INVALIDDATA;
453 
454  if (!ref) {
455  ref = generate_missing_ref(s, poc);
456  if (!ref)
457  return AVERROR(ENOMEM);
458  }
459 
460  list->list[list->nb_refs] = ref->poc;
461  list->ref[list->nb_refs] = ref;
462  list->nb_refs++;
463 
464  mark_ref(ref, ref_flag);
465  return 0;
466 }
467 
469 {
470  const ShortTermRPS *short_rps = s->sh.short_term_rps;
471  const LongTermRPS *long_rps = &s->sh.long_term_rps;
472  RefPicList *rps = s->rps;
473  int i, ret = 0;
474 
475  if (!short_rps) {
476  rps[0].nb_refs = rps[1].nb_refs = 0;
477  return 0;
478  }
479 
481 
482  /* clear the reference flags on all frames except the current one */
483  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
484  HEVCFrame *frame = &s->DPB[i];
485 
486  if (frame == s->ref)
487  continue;
488 
489  mark_ref(frame, 0);
490  }
491 
492  for (i = 0; i < NB_RPS_TYPE; i++)
493  rps[i].nb_refs = 0;
494 
495  /* add the short refs */
496  for (i = 0; i < short_rps->num_delta_pocs; i++) {
497  int poc = s->poc + short_rps->delta_poc[i];
498  int list;
499 
500  if (!short_rps->used[i])
501  list = ST_FOLL;
502  else if (i < short_rps->num_negative_pics)
503  list = ST_CURR_BEF;
504  else
505  list = ST_CURR_AFT;
506 
508  if (ret < 0)
509  goto fail;
510  }
511 
512  /* add the long refs */
513  for (i = 0; i < long_rps->nb_refs; i++) {
514  int poc = long_rps->poc[i];
515  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
516 
518  if (ret < 0)
519  goto fail;
520  }
521 
522 fail:
523  /* release any frames that are now unused */
524  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
525  ff_hevc_unref_frame(&s->DPB[i], 0);
526 
527  return ret;
528 }
529 
531 {
532  int ret = 0;
533  int i;
534  const ShortTermRPS *rps = s->sh.short_term_rps;
535  const LongTermRPS *long_rps = &s->sh.long_term_rps;
536 
537  if (rps) {
538  for (i = 0; i < rps->num_negative_pics; i++)
539  ret += !!rps->used[i];
540  for (; i < rps->num_delta_pocs; i++)
541  ret += !!rps->used[i];
542  }
543 
544  if (long_rps) {
545  for (i = 0; i < long_rps->nb_refs; i++)
546  ret += !!long_rps->used[i];
547  }
548 
549  if (s->ps.pps->pps_curr_pic_ref_enabled_flag)
550  ret++;
551 
552  return ret;
553 }
ff_progress_frame_report
void ff_progress_frame_report(ProgressFrame *f, int n)
Notify later decoding threads when part of their reference frame is ready.
Definition: decode.c:1741
ShortTermRPS::used
uint8_t used[32]
Definition: hevc_ps.h:84
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:51
out
FILE * out
Definition: movenc.c:55
find_ref_idx
static HEVCFrame * find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
Definition: hevc_refs.c:386
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:188
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
ff_progress_frame_get_buffer
int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
This function sets up the ProgressFrame, i.e.
Definition: decode.c:1699
RefPicList
Definition: hevcdec.h:189
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:446
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:638
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:348
ff_hevc_clear_refs
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
Definition: hevc_refs.c:61
fail
#define fail()
Definition: checkasm.h:182
mark_ref
static void mark_ref(HEVCFrame *frame, int flag)
Definition: hevc_refs.c:405
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:175
RefPicList::nb_refs
int nb_refs
Definition: hevcdec.h:193
ShortTermRPS::num_delta_pocs
int num_delta_pocs
Definition: hevc_ps.h:79
progressframe.h
refstruct.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:352
HEVC_FRAME_FLAG_BUMPING
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:349
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:447
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:2086
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:59
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:283
ff_hevc_set_new_ref
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
Definition: hevc_refs.c:125
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ff_progress_frame_unref
void ff_progress_frame_unref(ProgressFrame *f)
Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...
Definition: decode.c:1724
decode.h
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:347
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:301
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:190
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:238
generate_missing_ref
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:411
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:2704
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:351
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:709
LongTermRPS::poc
int poc[32]
Definition: hevcdec.h:183
AV_PICTURE_STRUCTURE_TOP_FIELD
@ AV_PICTURE_STRUCTURE_TOP_FIELD
coded as top field
Definition: avcodec.h:2703
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:368
LongTermRPS::poc_msb_present
uint8_t poc_msb_present[32]
Definition: hevcdec.h:184
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:230
ff_hevc_frame_rps
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:468
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:78
LongTermRPS::used
uint8_t used[32]
Definition: hevcdec.h:185
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:384
RefPicList::isLongTerm
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:192
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
SliceHeader::collocated_ref_idx
unsigned int collocated_ref_idx
Definition: hevcdec.h:240
HEVC_FRAME_FLAG_OUTPUT
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:346
alloc_frame
static HEVCFrame * alloc_frame(HEVCContext *s)
Definition: hevc_refs.c:77
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:1013
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:119
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1594
ShortTermRPS::num_negative_pics
unsigned int num_negative_pics
Definition: hevc_ps.h:78
flag
#define flag(name)
Definition: cbs_av1.c:466
SliceHeader
Definition: hevcdec.h:200
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
HEVCFrame
Definition: hevcdec.h:354
unref_missing_refs
static void unref_missing_refs(HEVCContext *s)
Definition: hevc_refs.c:165
ff_hevc_bump_frame
void ff_hevc_bump_frame(HEVCContext *s)
Definition: hevc_refs.c:243
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:606
SliceHeader::list_entry_lx
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:224
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
hevc.h
ff_hevc_unref_frame
void ff_hevc_unref_frame(HEVCFrame *frame, int flags)
Definition: hevc_refs.c:32
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
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:530
LongTermRPS
Definition: hevcdec.h:182
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:208
ff_hevc_flush_dpb
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:70
LT_CURR
@ LT_CURR
Definition: hevcdec.h:84
NB_RPS_TYPE
@ NB_RPS_TYPE
Definition: hevcdec.h:86
HEVCContext
Definition: hevcdec.h:444
SliceHeader::rpl_modification_flag
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:226
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ShortTermRPS
Definition: hevc_ps.h:72
RefPicList::list
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:191
mem.h
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:82
LongTermRPS::nb_refs
uint8_t nb_refs
Definition: hevcdec.h:186
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
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:83
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