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