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  const HEVCFrame *ref, int x0, int y0)
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 &ref->rpl_tab[ctb_addr_ts]->refPicList[0];
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_ext_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  for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
179  HEVCFrame *frame = &s->DPB[i];
180  if (frame->sequence == HEVC_SEQUENCE_COUNTER_INVALID) {
182  }
183  }
184 }
185 
187 {
188  if (IS_IRAP(s) && s->no_rasl_output_flag == 1) {
190  for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
191  HEVCFrame *frame = &s->DPB[i];
192  if ((frame->flags & mask) == HEVC_FRAME_FLAG_OUTPUT &&
193  frame->sequence != s->seq_decode) {
194  if (s->sh.no_output_of_prior_pics_flag == 1)
196  else
197  frame->flags |= HEVC_FRAME_FLAG_BUMPING;
198  }
199  }
200  }
201  do {
202  int nb_output = 0;
203  int min_poc = INT_MAX;
204  int i, min_idx, ret;
205 
206  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
207  HEVCFrame *frame = &s->DPB[i];
208  if ((frame->flags & HEVC_FRAME_FLAG_OUTPUT) &&
209  frame->sequence == s->seq_output) {
210  nb_output++;
211  if (frame->poc < min_poc || nb_output == 1) {
212  min_poc = frame->poc;
213  min_idx = i;
214  }
215  }
216  }
217 
218  /* wait for more frames before output */
219  if (!flush && s->seq_output == s->seq_decode && s->ps.sps &&
220  nb_output <= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].num_reorder_pics)
221  return 0;
222 
223  if (nb_output) {
224  HEVCFrame *frame = &s->DPB[min_idx];
225 
226  ret = av_frame_ref(out, frame->needs_fg ? frame->frame_grain : frame->frame);
227  if (frame->flags & HEVC_FRAME_FLAG_BUMPING)
229  else
231  if (ret < 0)
232  return ret;
233 
234  if (frame->needs_fg && (ret = av_frame_copy_props(out, frame->frame)) < 0)
235  return ret;
236 
237  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN))
239 
240  av_log(s->avctx, AV_LOG_DEBUG,
241  "Output frame with POC %d.\n", frame->poc);
242  return 1;
243  }
244 
245  if (s->seq_output != s->seq_decode)
246  s->seq_output = (s->seq_output + 1) & HEVC_SEQUENCE_COUNTER_MASK;
247  else
248  break;
249  } while (1);
250 
251  return 0;
252 }
253 
255 {
256  int dpb = 0;
257  int min_poc = INT_MAX;
258  int i;
259 
260  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
261  HEVCFrame *frame = &s->DPB[i];
262  if ((frame->flags) &&
263  frame->sequence == s->seq_output &&
264  frame->poc != s->poc) {
265  dpb++;
266  }
267  }
268 
269  if (s->ps.sps && dpb >= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering) {
270  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
271  HEVCFrame *frame = &s->DPB[i];
272  if ((frame->flags) &&
273  frame->sequence == s->seq_output &&
274  frame->poc != s->poc) {
275  if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) {
276  min_poc = frame->poc;
277  }
278  }
279  }
280 
281  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
282  HEVCFrame *frame = &s->DPB[i];
283  if (frame->flags & HEVC_FRAME_FLAG_OUTPUT &&
284  frame->sequence == s->seq_output &&
285  frame->poc <= min_poc) {
286  frame->flags |= HEVC_FRAME_FLAG_BUMPING;
287  }
288  }
289 
290  dpb--;
291  }
292 }
293 
295 {
296  HEVCFrame *frame = s->ref;
297  int ctb_count = frame->ctb_count;
298  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
299  int i;
300 
301  if (s->slice_idx >= frame->rpl_buf->size / sizeof(RefPicListTab))
302  return AVERROR_INVALIDDATA;
303 
304  for (i = ctb_addr_ts; i < ctb_count; i++)
305  frame->rpl_tab[i] = (RefPicListTab *)frame->rpl_buf->data + s->slice_idx;
306 
307  frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];
308 
309  return 0;
310 }
311 
313 {
314  SliceHeader *sh = &s->sh;
315 
316  uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;
317  uint8_t list_idx;
318  int i, j, ret;
319 
320  ret = init_slice_rpl(s);
321  if (ret < 0)
322  return ret;
323 
324  if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs +
325  s->rps[LT_CURR].nb_refs) && !s->ps.pps->pps_curr_pic_ref_enabled_flag) {
326  av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n");
327  return AVERROR_INVALIDDATA;
328  }
329 
330  for (list_idx = 0; list_idx < nb_list; list_idx++) {
331  RefPicList rpl_tmp = { { 0 } };
332  RefPicList *rpl = &s->ref->refPicList[list_idx];
333 
334  /* The order of the elements is
335  * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and
336  * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */
337  int cand_lists[3] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,
338  list_idx ? ST_CURR_BEF : ST_CURR_AFT,
339  LT_CURR };
340 
341  /* concatenate the candidate lists for the current frame */
342  while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {
343  for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
344  RefPicList *rps = &s->rps[cand_lists[i]];
345  for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {
346  rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];
347  rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j];
348  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2;
349  rpl_tmp.nb_refs++;
350  }
351  }
352  // Construct RefPicList0, RefPicList1 (8-8, 8-10)
353  if (s->ps.pps->pps_curr_pic_ref_enabled_flag) {
354  rpl_tmp.list[rpl_tmp.nb_refs] = s->ref->poc;
355  rpl_tmp.ref[rpl_tmp.nb_refs] = s->ref;
356  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = 1;
357  rpl_tmp.nb_refs++;
358  }
359  }
360 
361  /* reorder the references if necessary */
362  if (sh->rpl_modification_flag[list_idx]) {
363  for (i = 0; i < sh->nb_refs[list_idx]; i++) {
364  int idx = sh->list_entry_lx[list_idx][i];
365 
366  if (idx >= rpl_tmp.nb_refs) {
367  av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n");
368  return AVERROR_INVALIDDATA;
369  }
370 
371  rpl->list[i] = rpl_tmp.list[idx];
372  rpl->ref[i] = rpl_tmp.ref[idx];
373  rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx];
374  rpl->nb_refs++;
375  }
376  } else {
377  memcpy(rpl, &rpl_tmp, sizeof(*rpl));
378  rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]);
379  }
380 
381  // 8-9
382  if (s->ps.pps->pps_curr_pic_ref_enabled_flag &&
383  !sh->rpl_modification_flag[list_idx] &&
384  rpl_tmp.nb_refs > sh->nb_refs[L0]) {
385  rpl->list[sh->nb_refs[L0] - 1] = s->ref->poc;
386  rpl->ref[sh->nb_refs[L0] - 1] = s->ref;
387  }
388 
389  if (sh->collocated_list == list_idx &&
390  sh->collocated_ref_idx < rpl->nb_refs)
391  s->ref->collocated_ref = rpl->ref[sh->collocated_ref_idx];
392  }
393 
394  return 0;
395 }
396 
397 static HEVCFrame *find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
398 {
399  int mask = use_msb ? ~0 : (1 << s->ps.sps->log2_max_poc_lsb) - 1;
400  int i;
401 
402  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
403  HEVCFrame *ref = &s->DPB[i];
404  if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
405  if ((ref->poc & mask) == poc && (use_msb || ref->poc != s->poc))
406  return ref;
407  }
408  }
409 
410  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
411  av_log(s->avctx, AV_LOG_ERROR,
412  "Could not find ref with POC %d\n", poc);
413  return NULL;
414 }
415 
416 static void mark_ref(HEVCFrame *frame, int flag)
417 {
419  frame->flags |= flag;
420 }
421 
423 {
424  HEVCFrame *frame;
425  int i, y;
426 
427  frame = alloc_frame(s);
428  if (!frame)
429  return NULL;
430 
431  if (!s->avctx->hwaccel) {
432  if (!s->ps.sps->pixel_shift) {
433  for (i = 0; frame->frame->data[i]; i++)
434  memset(frame->frame->data[i], 1 << (s->ps.sps->bit_depth - 1),
435  frame->frame->linesize[i] * AV_CEIL_RSHIFT(s->ps.sps->height, s->ps.sps->vshift[i]));
436  } else {
437  for (i = 0; frame->frame->data[i]; i++)
438  for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++) {
439  uint8_t *dst = frame->frame->data[i] + y * frame->frame->linesize[i];
440  AV_WN16(dst, 1 << (s->ps.sps->bit_depth - 1));
441  av_memcpy_backptr(dst + 2, 2, 2*(s->ps.sps->width >> s->ps.sps->hshift[i]) - 2);
442  }
443  }
444  }
445 
446  frame->poc = poc;
448  frame->flags = 0;
449 
450  if (s->threads_type == FF_THREAD_FRAME)
451  ff_thread_report_progress(&frame->tf, INT_MAX, 0);
452 
453  return frame;
454 }
455 
456 /* add a reference with the given poc to the list and mark it as used in DPB */
458  int poc, int ref_flag, uint8_t use_msb)
459 {
460  HEVCFrame *ref = find_ref_idx(s, poc, use_msb);
461 
462  if (ref == s->ref || list->nb_refs >= HEVC_MAX_REFS)
463  return AVERROR_INVALIDDATA;
464 
465  if (!ref) {
466  ref = generate_missing_ref(s, poc);
467  if (!ref)
468  return AVERROR(ENOMEM);
469  }
470 
471  list->list[list->nb_refs] = ref->poc;
472  list->ref[list->nb_refs] = ref;
473  list->nb_refs++;
474 
475  mark_ref(ref, ref_flag);
476  return 0;
477 }
478 
480 {
481  const ShortTermRPS *short_rps = s->sh.short_term_rps;
482  const LongTermRPS *long_rps = &s->sh.long_term_rps;
483  RefPicList *rps = s->rps;
484  int i, ret = 0;
485 
486  if (!short_rps) {
487  rps[0].nb_refs = rps[1].nb_refs = 0;
488  return 0;
489  }
490 
492 
493  /* clear the reference flags on all frames except the current one */
494  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
495  HEVCFrame *frame = &s->DPB[i];
496 
497  if (frame == s->ref)
498  continue;
499 
500  mark_ref(frame, 0);
501  }
502 
503  for (i = 0; i < NB_RPS_TYPE; i++)
504  rps[i].nb_refs = 0;
505 
506  /* add the short refs */
507  for (i = 0; i < short_rps->num_delta_pocs; i++) {
508  int poc = s->poc + short_rps->delta_poc[i];
509  int list;
510 
511  if (!short_rps->used[i])
512  list = ST_FOLL;
513  else if (i < short_rps->num_negative_pics)
514  list = ST_CURR_BEF;
515  else
516  list = ST_CURR_AFT;
517 
519  if (ret < 0)
520  goto fail;
521  }
522 
523  /* add the long refs */
524  for (i = 0; i < long_rps->nb_refs; i++) {
525  int poc = long_rps->poc[i];
526  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
527 
529  if (ret < 0)
530  goto fail;
531  }
532 
533 fail:
534  /* release any frames that are now unused */
535  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
536  ff_hevc_unref_frame(s, &s->DPB[i], 0);
537 
538  return ret;
539 }
540 
542 {
543  int ret = 0;
544  int i;
545  const ShortTermRPS *rps = s->sh.short_term_rps;
546  const LongTermRPS *long_rps = &s->sh.long_term_rps;
547 
548  if (rps) {
549  for (i = 0; i < rps->num_negative_pics; i++)
550  ret += !!rps->used[i];
551  for (; i < rps->num_delta_pocs; i++)
552  ret += !!rps->used[i];
553  }
554 
555  if (long_rps) {
556  for (i = 0; i < long_rps->nb_refs; i++)
557  ret += !!long_rps->used[i];
558  }
559 
560  if (s->ps.pps->pps_curr_pic_ref_enabled_flag)
561  ret++;
562 
563  return ret;
564 }
ShortTermRPS::used
uint8_t used[32]
Definition: hevc_ps.h:40
LT_FOLL
@ LT_FOLL
Definition: hevcdec.h:85
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_hevc_get_ref_list
const RefPicList * ff_hevc_get_ref_list(const HEVCContext *s, const HEVCFrame *ref, int x0, int y0)
Definition: hevc_refs.c:58
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:978
out
FILE * out
Definition: movenc.c:54
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: hevc_refs.c:397
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:330
RefPicList
Definition: hevcdec.h:241
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:457
AVHWAccel
Definition: avcodec.h:2097
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:400
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:135
mark_ref
static void mark_ref(HEVCFrame *frame, int flag)
Definition: hevc_refs.c:416
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:186
RefPicList::nb_refs
int nb_refs
Definition: hevcdec.h:245
ShortTermRPS::num_delta_pocs
int num_delta_pocs
Definition: hevc_ps.h:37
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
HEVC_SEQUENCE_COUNTER_INVALID
#define HEVC_SEQUENCE_COUNTER_INVALID
Definition: hevcdec.h:404
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:548
HEVC_FRAME_FLAG_BUMPING
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:401
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:445
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:384
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:413
init_slice_rpl
static int init_slice_rpl(HEVCContext *s)
Definition: hevc_refs.c:294
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:399
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:312
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:242
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:290
generate_missing_ref
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:422
AV_PICTURE_STRUCTURE_BOTTOM_FIELD
@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD
coded as bottom field
Definition: avcodec.h:2855
threadframe.h
IS_BLA
#define IS_BLA(s)
Definition: hevcdec.h:76
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
NULL
#define NULL
Definition: coverity.c:32
HEVC_SEQUENCE_COUNTER_MASK
#define HEVC_SEQUENCE_COUNTER_MASK
Definition: hevcdec.h:403
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:598
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:235
AV_PICTURE_STRUCTURE_TOP_FIELD
@ AV_PICTURE_STRUCTURE_TOP_FIELD
coded as top field
Definition: avcodec.h:2854
L0
#define L0
Definition: hevcdec.h:57
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
LongTermRPS::poc_msb_present
uint8_t poc_msb_present[32]
Definition: hevcdec.h:236
HEVC_NAL_CRA_NUT
@ HEVC_NAL_CRA_NUT
Definition: hevc.h:50
RefPicListTab
Definition: hevcdec.h:248
SliceHeader::nb_refs
unsigned int nb_refs[2]
Definition: hevcdec.h:282
ff_hevc_frame_rps
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:479
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:78
LongTermRPS::used
uint8_t used[32]
Definition: hevcdec.h:237
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:350
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
SliceHeader::collocated_ref_idx
unsigned int collocated_ref_idx
Definition: hevcdec.h:292
HEVC_FRAME_FLAG_OUTPUT
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:398
MvField
Definition: hevcdec.h:352
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: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:783
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1526
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:967
ShortTermRPS::num_negative_pics
unsigned int num_negative_pics
Definition: hevc_ps.h:36
flag
#define flag(name)
Definition: cbs_av1.c:553
SliceHeader
Definition: hevcdec.h:252
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
HEVCFrame
Definition: hevcdec.h:406
unref_missing_refs
static void unref_missing_refs(HEVCContext *s)
Definition: hevc_refs.c:176
RefPicList::list
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:243
ff_hevc_bump_frame
void ff_hevc_bump_frame(HEVCContext *s)
Definition: hevc_refs.c:254
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SliceHeader::list_entry_lx
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:276
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:936
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:541
LongTermRPS
Definition: hevcdec.h:234
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:260
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:84
NB_RPS_TYPE
@ NB_RPS_TYPE
Definition: hevcdec.h:86
HEVCContext
Definition: hevcdec.h:495
AVHWAccel::frame_priv_data_size
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2206
SliceHeader::rpl_modification_flag
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:278
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ShortTermRPS
Definition: hevc_ps.h:35
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:367
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:82
LongTermRPS::nb_refs
uint8_t nb_refs
Definition: hevcdec.h:238
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:39
RefPicList::isLongTerm
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:244
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:408
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372