FFmpeg
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->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->f)
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)
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->f->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->f && 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  s->cur_frame = ref;
147  s->collocated_ref = NULL;
148 
149  if (s->sh.pic_output_flag)
151  else
153 
154  ref->poc = poc;
155  ref->sequence = s->seq_decode;
156  ref->f->crop_left = s->ps.sps->output_window.left_offset;
157  ref->f->crop_right = s->ps.sps->output_window.right_offset;
158  ref->f->crop_top = s->ps.sps->output_window.top_offset;
159  ref->f->crop_bottom = s->ps.sps->output_window.bottom_offset;
160 
161  return 0;
162 }
163 
165 {
166  for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
167  HEVCFrame *frame = &s->DPB[i];
168  if (frame->sequence == HEVC_SEQUENCE_COUNTER_INVALID) {
170  }
171  }
172 }
173 
175 {
176  if (IS_IRAP(s) && s->no_rasl_output_flag == 1) {
178  for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
179  HEVCFrame *frame = &s->DPB[i];
180  if ((frame->flags & mask) == HEVC_FRAME_FLAG_OUTPUT &&
181  frame->sequence != s->seq_decode) {
182  if (s->sh.no_output_of_prior_pics_flag == 1)
184  else
185  frame->flags |= HEVC_FRAME_FLAG_BUMPING;
186  }
187  }
188  }
189  do {
190  int nb_output = 0;
191  int min_poc = INT_MAX;
192  int i, min_idx, ret;
193 
194  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
195  HEVCFrame *frame = &s->DPB[i];
196  if ((frame->flags & HEVC_FRAME_FLAG_OUTPUT) &&
197  frame->sequence == s->seq_output) {
198  nb_output++;
199  if (frame->poc < min_poc || nb_output == 1) {
200  min_poc = frame->poc;
201  min_idx = i;
202  }
203  }
204  }
205 
206  /* wait for more frames before output */
207  if (!flush && s->seq_output == s->seq_decode && s->ps.sps &&
208  nb_output <= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].num_reorder_pics)
209  return 0;
210 
211  if (nb_output) {
212  HEVCFrame *frame = &s->DPB[min_idx];
213 
214  ret = av_frame_ref(out, frame->needs_fg ? frame->frame_grain : frame->f);
215  if (frame->flags & HEVC_FRAME_FLAG_BUMPING)
217  else
219  if (ret < 0)
220  return ret;
221 
222  if (frame->needs_fg && (ret = av_frame_copy_props(out, frame->f)) < 0)
223  return ret;
224 
225  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN))
227 
228  av_log(s->avctx, AV_LOG_DEBUG,
229  "Output frame with POC %d.\n", frame->poc);
230  return 1;
231  }
232 
233  if (s->seq_output != s->seq_decode)
234  s->seq_output = (s->seq_output + 1) & HEVC_SEQUENCE_COUNTER_MASK;
235  else
236  break;
237  } while (1);
238 
239  return 0;
240 }
241 
243 {
244  int dpb = 0;
245  int min_poc = INT_MAX;
246  int i;
247 
248  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
249  HEVCFrame *frame = &s->DPB[i];
250  if ((frame->flags) &&
251  frame->sequence == s->seq_output &&
252  frame->poc != s->poc) {
253  dpb++;
254  }
255  }
256 
257  if (s->ps.sps && dpb >= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering) {
258  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
259  HEVCFrame *frame = &s->DPB[i];
260  if ((frame->flags) &&
261  frame->sequence == s->seq_output &&
262  frame->poc != s->poc) {
263  if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) {
264  min_poc = frame->poc;
265  }
266  }
267  }
268 
269  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
270  HEVCFrame *frame = &s->DPB[i];
271  if (frame->flags & HEVC_FRAME_FLAG_OUTPUT &&
272  frame->sequence == s->seq_output &&
273  frame->poc <= min_poc) {
274  frame->flags |= HEVC_FRAME_FLAG_BUMPING;
275  }
276  }
277 
278  dpb--;
279  }
280 }
281 
283 {
284  HEVCFrame *frame = s->cur_frame;
285  int ctb_count = frame->ctb_count;
286  int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
287  int i;
288 
289  if (s->slice_idx >= frame->nb_rpl_elems)
290  return AVERROR_INVALIDDATA;
291 
292  for (i = ctb_addr_ts; i < ctb_count; i++)
293  frame->rpl_tab[i] = frame->rpl + s->slice_idx;
294 
295  frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];
296 
297  return 0;
298 }
299 
301 {
302  SliceHeader *sh = &s->sh;
303 
304  uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;
305  uint8_t list_idx;
306  int i, j, ret;
307 
308  ret = init_slice_rpl(s);
309  if (ret < 0)
310  return ret;
311 
312  if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs +
313  s->rps[LT_CURR].nb_refs) && !s->pps->pps_curr_pic_ref_enabled_flag) {
314  av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n");
315  return AVERROR_INVALIDDATA;
316  }
317 
318  for (list_idx = 0; list_idx < nb_list; list_idx++) {
319  RefPicList rpl_tmp = { { 0 } };
320  RefPicList *rpl = &s->cur_frame->refPicList[list_idx];
321 
322  /* The order of the elements is
323  * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and
324  * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */
325  int cand_lists[3] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,
326  list_idx ? ST_CURR_BEF : ST_CURR_AFT,
327  LT_CURR };
328 
329  /* concatenate the candidate lists for the current frame */
330  while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {
331  for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
332  RefPicList *rps = &s->rps[cand_lists[i]];
333  for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {
334  rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];
335  rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j];
336  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2;
337  rpl_tmp.nb_refs++;
338  }
339  }
340  // Construct RefPicList0, RefPicList1 (8-8, 8-10)
341  if (s->pps->pps_curr_pic_ref_enabled_flag && rpl_tmp.nb_refs < HEVC_MAX_REFS) {
342  rpl_tmp.list[rpl_tmp.nb_refs] = s->cur_frame->poc;
343  rpl_tmp.ref[rpl_tmp.nb_refs] = s->cur_frame;
344  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = 1;
345  rpl_tmp.nb_refs++;
346  }
347  }
348 
349  /* reorder the references if necessary */
350  if (sh->rpl_modification_flag[list_idx]) {
351  for (i = 0; i < sh->nb_refs[list_idx]; i++) {
352  int idx = sh->list_entry_lx[list_idx][i];
353 
354  if (idx >= rpl_tmp.nb_refs) {
355  av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n");
356  return AVERROR_INVALIDDATA;
357  }
358 
359  rpl->list[i] = rpl_tmp.list[idx];
360  rpl->ref[i] = rpl_tmp.ref[idx];
361  rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx];
362  rpl->nb_refs++;
363  }
364  } else {
365  memcpy(rpl, &rpl_tmp, sizeof(*rpl));
366  rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]);
367  }
368 
369  // 8-9
370  if (s->pps->pps_curr_pic_ref_enabled_flag &&
371  !sh->rpl_modification_flag[list_idx] &&
372  rpl_tmp.nb_refs > sh->nb_refs[L0]) {
373  rpl->list[sh->nb_refs[L0] - 1] = s->cur_frame->poc;
374  rpl->ref[sh->nb_refs[L0] - 1] = s->cur_frame;
375  }
376 
377  if (sh->collocated_list == list_idx &&
378  sh->collocated_ref_idx < rpl->nb_refs)
379  s->collocated_ref = rpl->ref[sh->collocated_ref_idx];
380  }
381 
382  return 0;
383 }
384 
385 static HEVCFrame *find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
386 {
387  int mask = use_msb ? ~0 : (1 << s->ps.sps->log2_max_poc_lsb) - 1;
388  int i;
389 
390  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
391  HEVCFrame *ref = &s->DPB[i];
392  if (ref->f && ref->sequence == s->seq_decode) {
393  if ((ref->poc & mask) == poc && (use_msb || ref->poc != s->poc))
394  return ref;
395  }
396  }
397 
398  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
399  av_log(s->avctx, AV_LOG_ERROR,
400  "Could not find ref with POC %d\n", poc);
401  return NULL;
402 }
403 
404 static void mark_ref(HEVCFrame *frame, int flag)
405 {
407  frame->flags |= flag;
408 }
409 
411 {
412  HEVCFrame *frame;
413  int i, y;
414 
415  frame = alloc_frame(s);
416  if (!frame)
417  return NULL;
418 
419  if (!s->avctx->hwaccel) {
420  if (!s->ps.sps->pixel_shift) {
421  for (i = 0; frame->f->data[i]; i++)
422  memset(frame->f->data[i], 1 << (s->ps.sps->bit_depth - 1),
423  frame->f->linesize[i] * AV_CEIL_RSHIFT(s->ps.sps->height, s->ps.sps->vshift[i]));
424  } else {
425  for (i = 0; frame->f->data[i]; i++)
426  for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++) {
427  uint8_t *dst = frame->f->data[i] + y * frame->f->linesize[i];
428  AV_WN16(dst, 1 << (s->ps.sps->bit_depth - 1));
429  av_memcpy_backptr(dst + 2, 2, 2*(s->ps.sps->width >> s->ps.sps->hshift[i]) - 2);
430  }
431  }
432  }
433 
434  frame->poc = poc;
436  frame->flags = 0;
437 
438  if (s->avctx->active_thread_type == FF_THREAD_FRAME)
439  ff_progress_frame_report(&frame->tf, INT_MAX);
440 
441  return frame;
442 }
443 
444 /* add a reference with the given poc to the list and mark it as used in DPB */
446  int poc, int ref_flag, uint8_t use_msb)
447 {
448  HEVCFrame *ref = find_ref_idx(s, poc, use_msb);
449 
450  if (ref == s->cur_frame || list->nb_refs >= HEVC_MAX_REFS)
451  return AVERROR_INVALIDDATA;
452 
453  if (!ref) {
454  ref = generate_missing_ref(s, poc);
455  if (!ref)
456  return AVERROR(ENOMEM);
457  }
458 
459  list->list[list->nb_refs] = ref->poc;
460  list->ref[list->nb_refs] = ref;
461  list->nb_refs++;
462 
463  mark_ref(ref, ref_flag);
464  return 0;
465 }
466 
468 {
469  const ShortTermRPS *short_rps = s->sh.short_term_rps;
470  const LongTermRPS *long_rps = &s->sh.long_term_rps;
471  RefPicList *rps = s->rps;
472  int i, ret = 0;
473 
474  if (!short_rps) {
475  rps[0].nb_refs = rps[1].nb_refs = 0;
476  return 0;
477  }
478 
480 
481  /* clear the reference flags on all frames except the current one */
482  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
483  HEVCFrame *frame = &s->DPB[i];
484 
485  if (frame == s->cur_frame)
486  continue;
487 
488  mark_ref(frame, 0);
489  }
490 
491  for (i = 0; i < NB_RPS_TYPE; i++)
492  rps[i].nb_refs = 0;
493 
494  /* add the short refs */
495  for (i = 0; i < short_rps->num_delta_pocs; i++) {
496  int poc = s->poc + short_rps->delta_poc[i];
497  int list;
498 
499  if (!(short_rps->used & (1 << i)))
500  list = ST_FOLL;
501  else if (i < short_rps->num_negative_pics)
502  list = ST_CURR_BEF;
503  else
504  list = ST_CURR_AFT;
505 
507  if (ret < 0)
508  goto fail;
509  }
510 
511  /* add the long refs */
512  for (i = 0; i < long_rps->nb_refs; i++) {
513  int poc = long_rps->poc[i];
514  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
515 
517  if (ret < 0)
518  goto fail;
519  }
520 
521 fail:
522  /* release any frames that are now unused */
523  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
524  ff_hevc_unref_frame(&s->DPB[i], 0);
525 
526  return ret;
527 }
528 
530 {
531  int ret = 0;
532  int i;
533  const ShortTermRPS *rps = sh->short_term_rps;
534  const LongTermRPS *long_rps = &sh->long_term_rps;
535 
536  if (rps) {
537  for (i = 0; i < rps->num_negative_pics; i++)
538  ret += !!(rps->used & (1 << i));
539  for (; i < rps->num_delta_pocs; i++)
540  ret += !!(rps->used & (1 << i));
541  }
542 
543  if (long_rps) {
544  for (i = 0; i < long_rps->nb_refs; i++)
545  ret += !!long_rps->used[i];
546  }
547 
548  if (pps->pps_curr_pic_ref_enabled_flag)
549  ret++;
550 
551  return ret;
552 }
ff_hevc_get_ref_list
const RefPicList * ff_hevc_get_ref_list(const HEVCContext *s, const HEVCFrame *ref, int x0, int y0)
Definition: refs.c:51
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:1759
ff_hevc_flush_dpb
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: refs.c:70
ff_hevc_frame_rps
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: refs.c:467
LT_FOLL
@ LT_FOLL
Definition: hevcdec.h:86
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
out
FILE * out
Definition: movenc.c:55
ShortTermRPS::num_negative_pics
uint8_t num_negative_pics
Definition: ps.h:78
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:1717
RefPicList
Definition: hevcdec.h:190
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:351
fail
#define fail()
Definition: checkasm.h:186
mark_ref
static void mark_ref(HEVCFrame *frame, int flag)
Definition: refs.c:404
RefPicList::nb_refs
int nb_refs
Definition: hevcdec.h:194
progressframe.h
refstruct.h
alloc_frame
static HEVCFrame * alloc_frame(HEVCContext *s)
Definition: refs.c:77
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
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:355
HEVC_FRAME_FLAG_BUMPING
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:352
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:2111
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
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
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:1742
decode.h
hevc.h
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:350
ff_hevc_slice_rpl
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: refs.c:300
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:191
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:240
ShortTermRPS::num_delta_pocs
uint8_t num_delta_pocs
Definition: ps.h:79
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:77
NULL
#define NULL
Definition: coverity.c:32
HEVC_SEQUENCE_COUNTER_MASK
#define HEVC_SEQUENCE_COUNTER_MASK
Definition: hevcdec.h:354
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:184
AV_PICTURE_STRUCTURE_TOP_FIELD
@ AV_PICTURE_STRUCTURE_TOP_FIELD
coded as top field
Definition: avcodec.h:2703
L0
#define L0
Definition: hevcdec.h:58
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:185
ff_hevc_set_new_ref
int ff_hevc_set_new_ref(HEVCContext *s, int poc)
Definition: refs.c:125
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
generate_missing_ref
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: refs.c:410
SliceHeader::nb_refs
unsigned int nb_refs[2]
Definition: hevcdec.h:232
ShortTermRPS::used
uint32_t used
Definition: ps.h:75
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:79
LongTermRPS::used
uint8_t used[32]
Definition: hevcdec.h:186
ff_hevc_unref_frame
void ff_hevc_unref_frame(HEVCFrame *frame, int flags)
Definition: refs.c:32
ST_FOLL
@ ST_FOLL
Definition: hevcdec.h:84
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
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: refs.c:174
SliceHeader::collocated_ref_idx
unsigned int collocated_ref_idx
Definition: hevcdec.h:242
ff_hevc_bump_frame
void ff_hevc_bump_frame(HEVCContext *s)
Definition: refs.c:242
HEVC_FRAME_FLAG_OUTPUT
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:349
ff_hevc_frame_nb_refs
int ff_hevc_frame_nb_refs(const SliceHeader *sh, const HEVCPPS *pps)
Get the number of candidate references for the current frame.
Definition: refs.c:529
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
find_ref_idx
static HEVCFrame * find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
Definition: refs.c:385
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1594
flag
#define flag(name)
Definition: cbs_av1.c:466
SliceHeader
Definition: hevcdec.h:201
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
HEVCFrame
Definition: hevcdec.h:357
init_slice_rpl
static int init_slice_rpl(HEVCContext *s)
Definition: refs.c:282
RefPicList::list
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:192
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
ff_hevc_clear_refs
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
Definition: refs.c:61
SliceHeader::list_entry_lx
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:226
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
SliceHeader::short_term_rps
const ShortTermRPS * short_term_rps
Definition: hevcdec.h:223
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:82
VVCContext::ps
VVCParamSets ps
Definition: dec.h:221
LongTermRPS
Definition: hevcdec.h:183
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:209
LT_CURR
@ LT_CURR
Definition: hevcdec.h:85
HEVC_NAL_CRA_NUT
@ HEVC_NAL_CRA_NUT
Definition: hevc.h:50
NB_RPS_TYPE
@ NB_RPS_TYPE
Definition: hevcdec.h:87
HEVCContext
Definition: hevcdec.h:450
SliceHeader::rpl_modification_flag
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:228
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
ShortTermRPS
Definition: ps.h:73
mem.h
add_candidate_ref
static int add_candidate_ref(HEVCContext *s, RefPicList *list, int poc, int ref_flag, uint8_t use_msb)
Definition: refs.c:445
unref_missing_refs
static void unref_missing_refs(HEVCContext *s)
Definition: refs.c:164
HEVCPPS
Definition: ps.h:309
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:83
LongTermRPS::nb_refs
uint8_t nb_refs
Definition: hevcdec.h:187
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: ps.h:74
RefPicList::isLongTerm
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:193
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
SliceHeader::long_term_rps
LongTermRPS long_term_rps
Definition: hevcdec.h:225
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:366