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 "thread.h"
27 #include "hevc.h"
28 #include "hevcdec.h"
29 #include "threadframe.h"
30 
32 {
33  /* frame->frame can be NULL if context init failed */
34  if (!frame->frame || !frame->frame->buf[0])
35  return;
36 
37  frame->flags &= ~flags;
38  if (!frame->flags) {
39  ff_thread_release_ext_buffer(s->avctx, &frame->tf);
40  ff_thread_release_buffer(s->avctx, frame->frame_grain);
41  frame->needs_fg = 0;
42 
43  av_buffer_unref(&frame->tab_mvf_buf);
44  frame->tab_mvf = NULL;
45 
46  av_buffer_unref(&frame->rpl_buf);
47  av_buffer_unref(&frame->rpl_tab_buf);
48  frame->rpl_tab = NULL;
49  frame->refPicList = NULL;
50 
51  frame->collocated_ref = NULL;
52 
53  av_buffer_unref(&frame->hwaccel_priv_buf);
54  frame->hwaccel_picture_private = NULL;
55  }
56 }
57 
59 {
60  int x_cb = x0 >> s->ps.sps->log2_ctb_size;
61  int y_cb = y0 >> s->ps.sps->log2_ctb_size;
62  int pic_width_cb = s->ps.sps->ctb_width;
63  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[y_cb * pic_width_cb + x_cb];
64  return (RefPicList *)ref->rpl_tab[ctb_addr_ts];
65 }
66 
68 {
69  int i;
70  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
71  ff_hevc_unref_frame(s, &s->DPB[i],
74 }
75 
77 {
78  int i;
79  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
80  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
81 }
82 
84 {
85  int i, j, ret;
86  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
87  HEVCFrame *frame = &s->DPB[i];
88  if (frame->frame->buf[0])
89  continue;
90 
91  ret = ff_thread_get_ext_buffer(s->avctx, &frame->tf,
93  if (ret < 0)
94  return NULL;
95 
96  frame->rpl_buf = av_buffer_allocz(s->pkt.nb_nals * sizeof(RefPicListTab));
97  if (!frame->rpl_buf)
98  goto fail;
99 
100  frame->tab_mvf_buf = av_buffer_pool_get(s->tab_mvf_pool);
101  if (!frame->tab_mvf_buf)
102  goto fail;
103  frame->tab_mvf = (MvField *)frame->tab_mvf_buf->data;
104 
105  frame->rpl_tab_buf = av_buffer_pool_get(s->rpl_tab_pool);
106  if (!frame->rpl_tab_buf)
107  goto fail;
108  frame->rpl_tab = (RefPicListTab **)frame->rpl_tab_buf->data;
109  frame->ctb_count = s->ps.sps->ctb_width * s->ps.sps->ctb_height;
110  for (j = 0; j < frame->ctb_count; j++)
111  frame->rpl_tab[j] = (RefPicListTab *)frame->rpl_buf->data;
112 
113  frame->frame->top_field_first = s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD;
114  frame->frame->interlaced_frame = (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) || (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD);
115 
116  if (s->avctx->hwaccel) {
117  const AVHWAccel *hwaccel = s->avctx->hwaccel;
118  av_assert0(!frame->hwaccel_picture_private);
119  if (hwaccel->frame_priv_data_size) {
120  frame->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
121  if (!frame->hwaccel_priv_buf)
122  goto fail;
123  frame->hwaccel_picture_private = frame->hwaccel_priv_buf->data;
124  }
125  }
126 
127  return frame;
128 fail:
130  return NULL;
131  }
132  av_log(s->avctx, AV_LOG_ERROR, "Error allocating frame, DPB full.\n");
133  return NULL;
134 }
135 
137 {
138  HEVCFrame *ref;
139  int i;
140 
141  /* check that this POC doesn't already exist */
142  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
143  HEVCFrame *frame = &s->DPB[i];
144 
145  if (frame->frame->buf[0] && frame->sequence == s->seq_decode &&
146  frame->poc == poc) {
147  av_log(s->avctx, AV_LOG_ERROR, "Duplicate POC in a sequence: %d.\n",
148  poc);
149  return AVERROR_INVALIDDATA;
150  }
151  }
152 
153  ref = alloc_frame(s);
154  if (!ref)
155  return AVERROR(ENOMEM);
156 
157  *frame = ref->frame;
158  s->ref = ref;
159 
160  if (s->sh.pic_output_flag)
162  else
164 
165  ref->poc = poc;
166  ref->sequence = s->seq_decode;
167  ref->frame->crop_left = s->ps.sps->output_window.left_offset;
168  ref->frame->crop_right = s->ps.sps->output_window.right_offset;
169  ref->frame->crop_top = s->ps.sps->output_window.top_offset;
170  ref->frame->crop_bottom = s->ps.sps->output_window.bottom_offset;
171 
172  return 0;
173 }
174 
176 {
177  do {
178  int nb_output = 0;
179  int min_poc = INT_MAX;
180  int i, min_idx, ret;
181 
182  if (s->sh.no_output_of_prior_pics_flag == 1 && s->no_rasl_output_flag == 1) {
183  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
184  HEVCFrame *frame = &s->DPB[i];
185  if (!(frame->flags & HEVC_FRAME_FLAG_BUMPING) && frame->poc != s->poc &&
186  frame->sequence == s->seq_output) {
188  }
189  }
190  }
191 
192  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
193  HEVCFrame *frame = &s->DPB[i];
194  if ((frame->flags & HEVC_FRAME_FLAG_OUTPUT) &&
195  frame->sequence == s->seq_output) {
196  nb_output++;
197  if (frame->poc < min_poc || nb_output == 1) {
198  min_poc = frame->poc;
199  min_idx = i;
200  }
201  }
202  }
203 
204  /* wait for more frames before output */
205  if (!flush && s->seq_output == s->seq_decode && s->ps.sps &&
206  nb_output <= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].num_reorder_pics)
207  return 0;
208 
209  if (nb_output) {
210  HEVCFrame *frame = &s->DPB[min_idx];
211 
212  ret = av_frame_ref(out, frame->needs_fg ? frame->frame_grain : frame->frame);
213  if (frame->flags & HEVC_FRAME_FLAG_BUMPING)
215  else
217  if (ret < 0)
218  return ret;
219 
220  if (frame->needs_fg && (ret = av_frame_copy_props(out, frame->frame)) < 0)
221  return ret;
222 
223  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN))
225 
226  av_log(s->avctx, AV_LOG_DEBUG,
227  "Output frame with POC %d.\n", frame->poc);
228  return 1;
229  }
230 
231  if (s->seq_output != s->seq_decode)
232  s->seq_output = (s->seq_output + 1) & 0xff;
233  else
234  break;
235  } while (1);
236 
237  return 0;
238 }
239 
241 {
242  int dpb = 0;
243  int min_poc = INT_MAX;
244  int i;
245 
246  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
247  HEVCFrame *frame = &s->DPB[i];
248  if ((frame->flags) &&
249  frame->sequence == s->seq_output &&
250  frame->poc != s->poc) {
251  dpb++;
252  }
253  }
254 
255  if (s->ps.sps && dpb >= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering) {
256  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
257  HEVCFrame *frame = &s->DPB[i];
258  if ((frame->flags) &&
259  frame->sequence == s->seq_output &&
260  frame->poc != s->poc) {
261  if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) {
262  min_poc = frame->poc;
263  }
264  }
265  }
266 
267  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
268  HEVCFrame *frame = &s->DPB[i];
269  if (frame->flags & HEVC_FRAME_FLAG_OUTPUT &&
270  frame->sequence == s->seq_output &&
271  frame->poc <= min_poc) {
272  frame->flags |= HEVC_FRAME_FLAG_BUMPING;
273  }
274  }
275 
276  dpb--;
277  }
278 }
279 
281 {
282  HEVCFrame *frame = s->ref;
283  int ctb_count = frame->ctb_count;
284  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
285  int i;
286 
287  if (s->slice_idx >= frame->rpl_buf->size / sizeof(RefPicListTab))
288  return AVERROR_INVALIDDATA;
289 
290  for (i = ctb_addr_ts; i < ctb_count; i++)
291  frame->rpl_tab[i] = (RefPicListTab *)frame->rpl_buf->data + s->slice_idx;
292 
293  frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];
294 
295  return 0;
296 }
297 
299 {
300  SliceHeader *sh = &s->sh;
301 
302  uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;
303  uint8_t list_idx;
304  int i, j, ret;
305 
306  ret = init_slice_rpl(s);
307  if (ret < 0)
308  return ret;
309 
310  if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs +
311  s->rps[LT_CURR].nb_refs)) {
312  av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n");
313  return AVERROR_INVALIDDATA;
314  }
315 
316  for (list_idx = 0; list_idx < nb_list; list_idx++) {
317  RefPicList rpl_tmp = { { 0 } };
318  RefPicList *rpl = &s->ref->refPicList[list_idx];
319 
320  /* The order of the elements is
321  * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and
322  * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */
323  int cand_lists[3] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,
324  list_idx ? ST_CURR_BEF : ST_CURR_AFT,
325  LT_CURR };
326 
327  /* concatenate the candidate lists for the current frame */
328  while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {
329  for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
330  RefPicList *rps = &s->rps[cand_lists[i]];
331  for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {
332  rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];
333  rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j];
334  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2;
335  rpl_tmp.nb_refs++;
336  }
337  }
338  }
339 
340  /* reorder the references if necessary */
341  if (sh->rpl_modification_flag[list_idx]) {
342  for (i = 0; i < sh->nb_refs[list_idx]; i++) {
343  int idx = sh->list_entry_lx[list_idx][i];
344 
345  if (idx >= rpl_tmp.nb_refs) {
346  av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n");
347  return AVERROR_INVALIDDATA;
348  }
349 
350  rpl->list[i] = rpl_tmp.list[idx];
351  rpl->ref[i] = rpl_tmp.ref[idx];
352  rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx];
353  rpl->nb_refs++;
354  }
355  } else {
356  memcpy(rpl, &rpl_tmp, sizeof(*rpl));
357  rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]);
358  }
359 
360  if (sh->collocated_list == list_idx &&
361  sh->collocated_ref_idx < rpl->nb_refs)
362  s->ref->collocated_ref = rpl->ref[sh->collocated_ref_idx];
363  }
364 
365  return 0;
366 }
367 
368 static HEVCFrame *find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
369 {
370  int mask = use_msb ? ~0 : (1 << s->ps.sps->log2_max_poc_lsb) - 1;
371  int i;
372 
373  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
374  HEVCFrame *ref = &s->DPB[i];
375  if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
376  if ((ref->poc & mask) == poc)
377  return ref;
378  }
379  }
380 
381  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
382  av_log(s->avctx, AV_LOG_ERROR,
383  "Could not find ref with POC %d\n", poc);
384  return NULL;
385 }
386 
387 static void mark_ref(HEVCFrame *frame, int flag)
388 {
390  frame->flags |= flag;
391 }
392 
394 {
395  HEVCFrame *frame;
396  int i, y;
397 
398  frame = alloc_frame(s);
399  if (!frame)
400  return NULL;
401 
402  if (!s->avctx->hwaccel) {
403  if (!s->ps.sps->pixel_shift) {
404  for (i = 0; frame->frame->data[i]; i++)
405  memset(frame->frame->data[i], 1 << (s->ps.sps->bit_depth - 1),
406  frame->frame->linesize[i] * AV_CEIL_RSHIFT(s->ps.sps->height, s->ps.sps->vshift[i]));
407  } else {
408  for (i = 0; frame->frame->data[i]; i++)
409  for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++) {
410  uint8_t *dst = frame->frame->data[i] + y * frame->frame->linesize[i];
411  AV_WN16(dst, 1 << (s->ps.sps->bit_depth - 1));
412  av_memcpy_backptr(dst + 2, 2, 2*(s->ps.sps->width >> s->ps.sps->hshift[i]) - 2);
413  }
414  }
415  }
416 
417  frame->poc = poc;
418  frame->sequence = s->seq_decode;
419  frame->flags = 0;
420 
421  if (s->threads_type == FF_THREAD_FRAME)
422  ff_thread_report_progress(&frame->tf, INT_MAX, 0);
423 
424  return frame;
425 }
426 
427 /* add a reference with the given poc to the list and mark it as used in DPB */
429  int poc, int ref_flag, uint8_t use_msb)
430 {
431  HEVCFrame *ref = find_ref_idx(s, poc, use_msb);
432 
433  if (ref == s->ref || list->nb_refs >= HEVC_MAX_REFS)
434  return AVERROR_INVALIDDATA;
435 
436  if (!ref) {
437  ref = generate_missing_ref(s, poc);
438  if (!ref)
439  return AVERROR(ENOMEM);
440  }
441 
442  list->list[list->nb_refs] = ref->poc;
443  list->ref[list->nb_refs] = ref;
444  list->nb_refs++;
445 
446  mark_ref(ref, ref_flag);
447  return 0;
448 }
449 
451 {
452  const ShortTermRPS *short_rps = s->sh.short_term_rps;
453  const LongTermRPS *long_rps = &s->sh.long_term_rps;
454  RefPicList *rps = s->rps;
455  int i, ret = 0;
456 
457  if (!short_rps) {
458  rps[0].nb_refs = rps[1].nb_refs = 0;
459  return 0;
460  }
461 
462  /* clear the reference flags on all frames except the current one */
463  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
464  HEVCFrame *frame = &s->DPB[i];
465 
466  if (frame == s->ref)
467  continue;
468 
469  mark_ref(frame, 0);
470  }
471 
472  for (i = 0; i < NB_RPS_TYPE; i++)
473  rps[i].nb_refs = 0;
474 
475  /* add the short refs */
476  for (i = 0; i < short_rps->num_delta_pocs; i++) {
477  int poc = s->poc + short_rps->delta_poc[i];
478  int list;
479 
480  if (!short_rps->used[i])
481  list = ST_FOLL;
482  else if (i < short_rps->num_negative_pics)
483  list = ST_CURR_BEF;
484  else
485  list = ST_CURR_AFT;
486 
488  if (ret < 0)
489  goto fail;
490  }
491 
492  /* add the long refs */
493  for (i = 0; i < long_rps->nb_refs; i++) {
494  int poc = long_rps->poc[i];
495  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
496 
498  if (ret < 0)
499  goto fail;
500  }
501 
502 fail:
503  /* release any frames that are now unused */
504  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
505  ff_hevc_unref_frame(s, &s->DPB[i], 0);
506 
507  return ret;
508 }
509 
511 {
512  int ret = 0;
513  int i;
514  const ShortTermRPS *rps = s->sh.short_term_rps;
515  const LongTermRPS *long_rps = &s->sh.long_term_rps;
516 
517  if (rps) {
518  for (i = 0; i < rps->num_negative_pics; i++)
519  ret += !!rps->used[i];
520  for (; i < rps->num_delta_pocs; i++)
521  ret += !!rps->used[i];
522  }
523 
524  if (long_rps) {
525  for (i = 0; i < long_rps->nb_refs; i++)
526  ret += !!long_rps->used[i];
527  }
528  return ret;
529 }
ShortTermRPS::used
uint8_t used[32]
Definition: hevc_ps.h:39
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_thread_release_ext_buffer
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1141
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:368
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:325
RefPicList
Definition: hevcdec.h:236
thread.h
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:428
AVHWAccel
Definition: avcodec.h:2067
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:390
ff_hevc_clear_refs
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
Definition: hevc_refs.c:67
fail
#define fail()
Definition: checkasm.h:131
mark_ref
static void mark_ref(HEVCFrame *frame, int flag)
Definition: hevc_refs.c:387
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:240
ShortTermRPS::num_delta_pocs
int num_delta_pocs
Definition: hevc_ps.h:36
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
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:595
HEVC_FRAME_FLAG_BUMPING
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:391
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:455
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:387
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
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:367
init_slice_rpl
static int init_slice_rpl(HEVCContext *s)
Definition: hevc_refs.c:280
ff_hevc_set_new_ref
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
Definition: hevc_refs.c:136
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:389
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:298
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:237
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:285
generate_missing_ref
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:393
AV_PICTURE_STRUCTURE_BOTTOM_FIELD
@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD
Definition: avcodec.h:2785
threadframe.h
IS_BLA
#define IS_BLA(s)
Definition: hevcdec.h:76
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:606
NULL
#define NULL
Definition: coverity.c:32
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:596
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
LongTermRPS::poc
int poc[32]
Definition: hevcdec.h:230
AV_PICTURE_STRUCTURE_TOP_FIELD
@ AV_PICTURE_STRUCTURE_TOP_FIELD
Definition: avcodec.h:2784
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
LongTermRPS::poc_msb_present
uint8_t poc_msb_present[32]
Definition: hevcdec.h:231
HEVC_NAL_CRA_NUT
@ HEVC_NAL_CRA_NUT
Definition: hevc.h:50
RefPicListTab
Definition: hevcdec.h:243
SliceHeader::nb_refs
unsigned int nb_refs[2]
Definition: hevcdec.h:277
ff_hevc_frame_rps
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:450
LongTermRPS::used
uint8_t used[32]
Definition: hevcdec.h:232
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:343
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
SliceHeader::collocated_ref_idx
unsigned int collocated_ref_idx
Definition: hevcdec.h:287
HEVC_FRAME_FLAG_OUTPUT
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:388
MvField
Definition: hevcdec.h:342
ff_hevc_unref_frame
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
Definition: hevc_refs.c:31
alloc_frame
static HEVCFrame * alloc_frame(HEVCContext *s)
Definition: hevc_refs.c:83
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:784
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1474
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1074
ShortTermRPS::num_negative_pics
unsigned int num_negative_pics
Definition: hevc_ps.h:35
flag
#define flag(name)
Definition: cbs_av1.c:553
SliceHeader
Definition: hevcdec.h:247
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
HEVCFrame
Definition: hevcdec.h:393
RefPicList::list
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:238
ff_hevc_bump_frame
void ff_hevc_bump_frame(HEVCContext *s)
Definition: hevc_refs.c:240
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SliceHeader::list_entry_lx
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:271
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:1043
hevc.h
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
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:510
LongTermRPS
Definition: hevcdec.h:229
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:255
ff_hevc_flush_dpb
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:76
LT_CURR
@ LT_CURR
Definition: hevcdec.h:84
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:119
NB_RPS_TYPE
@ NB_RPS_TYPE
Definition: hevcdec.h:86
HEVCContext
Definition: hevcdec.h:467
AVHWAccel::frame_priv_data_size
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2176
SliceHeader::rpl_modification_flag
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:273
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ShortTermRPS
Definition: hevc_ps.h:34
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:82
LongTermRPS::nb_refs
uint8_t nb_refs
Definition: hevcdec.h:233
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:38
RefPicList::isLongTerm
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:239
ff_hevc_get_ref_list
RefPicList * ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *ref, int x0, int y0)
Definition: hevc_refs.c:58
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:362
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372