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 
43  frame->tab_mvf = NULL;
44 
45  av_buffer_unref(&frame->rpl_buf);
47  frame->rpl_tab = NULL;
48  frame->refPicList = NULL;
49 
50  frame->collocated_ref = NULL;
51 
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 
100  if (!frame->tab_mvf_buf)
101  goto fail;
102  frame->tab_mvf = (MvField *)frame->tab_mvf_buf->data;
103 
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 
114 
115  if (s->avctx->hwaccel) {
116  const AVHWAccel *hwaccel = s->avctx->hwaccel;
118  if (hwaccel->frame_priv_data_size) {
120  if (!frame->hwaccel_priv_buf)
121  goto fail;
123  }
124  }
125 
126  return frame;
127 fail:
128  ff_hevc_unref_frame(s, frame, ~0);
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;
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 
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))
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 
480  ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_SHORT_REF, 1);
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 
490  ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_LONG_REF, long_rps->poc_msb_present[i]);
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 }
const HEVCPPS * pps
Definition: hevc_ps.h:335
AVFrame * frame
Definition: hevcdec.h:396
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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:125
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
HEVCFrame * ref
Definition: hevcdec.h:507
int ctb_height
Definition: hevc_ps.h:230
static void flush(AVCodecContext *avctx)
int max_dec_pic_buffering
Definition: hevc_ps.h:172
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
Definition: hevc_refs.c:135
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:499
void * hwaccel_picture_private
Definition: hevcdec.h:410
uint8_t nb_refs
Definition: hevcdec.h:235
MvField * tab_mvf
Definition: hevcdec.h:398
int vshift[3]
Definition: hevc_ps.h:241
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:75
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:443
unsigned int left_offset
Definition: hevc_ps.h:43
HEVCParamSets ps
Definition: hevcdec.h:492
size_t crop_bottom
Definition: frame.h:669
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1690
int width
Definition: hevc_ps.h:227
uint16_t seq_decode
Sequence counters for decoded and output frames, so that old frames are output first after a POC rese...
Definition: hevcdec.h:552
uint8_t threads_type
Definition: hevcdec.h:476
int pixel_shift
Definition: hevc_ps.h:164
HEVCWindow output_window
Definition: hevc_ps.h:158
static HEVCFrame * alloc_frame(HEVCContext *s)
Definition: hevc_refs.c:82
AVBufferPool * rpl_tab_pool
candidate references for the current frame
Definition: hevcdec.h:497
int nb_refs
Definition: hevcdec.h:242
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
unsigned int slice_segment_addr
address (in raster order) of the first block in the current slice
Definition: hevcdec.h:253
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
Definition: hevc_refs.c:32
enum HEVCSliceType slice_type
Definition: hevcdec.h:257
unsigned int num_negative_pics
Definition: hevc_ps.h:35
uint8_t
enum HEVCNALUnitType nal_unit_type
Definition: hevcdec.h:505
size_t crop_left
Definition: frame.h:670
LongTermRPS long_term_rps
Definition: hevcdec.h:272
int poc[32]
Definition: hevcdec.h:232
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:239
Multithreading support functions.
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:456
AVCodecContext * avctx
Definition: hevcdec.h:469
uint8_t poc_msb_present[32]
Definition: hevcdec.h:233
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: hevc_refs.c:291
ThreadFrame tf
Definition: hevcdec.h:397
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:428
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:455
uint8_t pic_output_flag
Definition: hevcdec.h:263
#define av_log(a,...)
uint8_t used[32]
Definition: hevcdec.h:234
int ctb_count
Definition: hevcdec.h:401
uint8_t no_output_of_prior_pics_flag
Definition: hevcdec.h:276
int slice_idx
number of the slice being currently decoded
Definition: hevcdec.h:511
static void mark_ref(HEVCFrame *frame, int flag)
Definition: hevc_refs.c:380
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int ff_hevc_frame_nb_refs(const HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:503
unsigned int log2_max_poc_lsb
Definition: hevc_ps.h:167
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:392
static const uint16_t mask[17]
Definition: lzw.c:38
AVBufferRef * rpl_tab_buf
Definition: hevcdec.h:406
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:275
RefPicList * refPicList
Definition: hevcdec.h:399
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
unsigned int log2_ctb_size
Definition: hevc_ps.h:209
simple assert() macros that are a bit more flexible than ISO C assert().
const ShortTermRPS * short_term_rps
Definition: hevcdec.h:270
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:391
#define fail()
Definition: checkasm.h:123
uint16_t sequence
A sequence counter, so that old frames are output first after a POC reset.
Definition: hevcdec.h:416
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:390
uint8_t used[32]
Definition: hevc_ps.h:39
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
size_t crop_top
Definition: frame.h:668
const HEVCSPS * sps
Definition: hevc_ps.h:334
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:393
AVBufferRef * tab_mvf_buf
Definition: hevcdec.h:405
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
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1796
#define FFMIN(a, b)
Definition: common.h:96
struct HEVCSPS::@75 temporal_layer[HEVC_MAX_SUB_LAYERS]
unsigned int top_offset
Definition: hevc_ps.h:45
int hshift[3]
Definition: hevc_ps.h:240
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
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
#define s(width, name)
Definition: cbs_vp9.c:257
int ctb_width
Definition: hevc_ps.h:229
struct HEVCFrame * collocated_ref
Definition: hevcdec.h:403
static HEVCFrame * find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
Definition: hevc_refs.c:361
int32_t delta_poc[32]
Definition: hevc_ps.h:38
int height
Definition: hevc_ps.h:228
uint16_t seq_output
Definition: hevcdec.h:553
#define IS_BLA(s)
Definition: hevcdec.h:78
#define FF_ARRAY_ELEMS(a)
static int init_slice_rpl(HEVCContext *s)
Definition: hevc_refs.c:273
HEVCFrame DPB[32]
Definition: hevcdec.h:508
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:386
RefPicListTab ** rpl_tab
Definition: hevcdec.h:400
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
Definition: hevc_refs.c:66
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc_ps.h:316
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
int max_sub_layers
Definition: hevc_ps.h:170
AVBufferRef * hwaccel_priv_buf
Definition: hevcdec.h:409
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
uint8_t * data
The data buffer.
Definition: buffer.h:89
size_t crop_right
Definition: frame.h:671
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
void ff_hevc_bump_frame(HEVCContext *s)
Definition: hevc_refs.c:233
int poc
Definition: hevcdec.h:402
uint8_t flags
A combination of HEVC_FRAME_FLAG_*.
Definition: hevcdec.h:421
int size
Size of data in bytes.
Definition: buffer.h:93
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:240
RefPicList * ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *ref, int x0, int y0)
Definition: hevc_refs.c:57
#define flags(name, subs,...)
Definition: cbs_av1.c:560
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
static int add_candidate_ref(HEVCContext *s, RefPicList *list, int poc, int ref_flag, uint8_t use_msb)
Definition: hevc_refs.c:421
HEVCSEIPictureTiming picture_timing
Definition: hevc_sei.h:142
common internal api header.
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
unsigned int nb_refs[2]
Definition: hevcdec.h:279
#define flag(name)
Definition: cbs_av1.c:552
uint8_t collocated_list
Definition: hevcdec.h:287
AVBufferPool * tab_mvf_pool
Definition: hevcdec.h:496
int num_delta_pocs
Definition: hevc_ps.h:36
RefPicList rps[5]
Definition: hevcdec.h:500
unsigned int collocated_ref_idx
Definition: hevcdec.h:289
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:460
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2520
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:273
HEVCSEI sei
Definition: hevcdec.h:493
H2645Packet pkt
Definition: hevcdec.h:560
unsigned int right_offset
Definition: hevc_ps.h:44
FILE * out
Definition: movenc.c:54
int num_reorder_pics
Definition: hevc_ps.h:173
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:364
AVBufferRef * rpl_buf
Definition: hevcdec.h:407
int bit_depth
Definition: hevc_ps.h:162
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
SliceHeader sh
Definition: hevcdec.h:502
int no_rasl_output_flag
Definition: hevcdec.h:520
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:509
for(j=16;j >0;--j)
int i
Definition: input.c:407
unsigned int bottom_offset
Definition: hevc_ps.h:46
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:241