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