FFmpeg  4.4.6
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];
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);
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];
263  frame->sequence == s->seq_output &&
264  frame->poc <= min_poc) {
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 
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 }
static void flush(AVCodecContext *avctx)
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1788
#define flag(name)
Definition: cbs_av1.c:564
#define flags(name, subs,...)
Definition: cbs_av1.c:572
#define s(width, name)
Definition: cbs_vp9.c:257
#define fail()
Definition: checkasm.h:133
#define FFMIN(a, b)
Definition: common.h:105
#define NULL
Definition: coverity.c:32
static AVFrame * frame
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:514
@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD
Definition: avcodec.h:3377
@ AV_PICTURE_STRUCTURE_TOP_FIELD
Definition: avcodec.h:3376
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
AVBufferRef * av_buffer_allocz(buffer_size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:379
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
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:443
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:428
for(j=16;j >0;--j)
static HEVCFrame * alloc_frame(HEVCContext *s)
Definition: hevc_refs.c:82
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
static HEVCFrame * find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
Definition: hevc_refs.c:361
int ff_hevc_frame_nb_refs(const HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:503
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:75
RefPicList * ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *ref, int x0, int y0)
Definition: hevc_refs.c:57
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
Definition: hevc_refs.c:135
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:386
static void mark_ref(HEVCFrame *frame, int flag)
Definition: hevc_refs.c:380
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
Definition: hevc_refs.c:32
void ff_hevc_bump_frame(HEVCContext *s)
Definition: hevc_refs.c:233
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:443
static int init_slice_rpl(HEVCContext *s)
Definition: hevc_refs.c:273
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
Definition: hevc_refs.c:66
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: hevc_refs.c:291
static int add_candidate_ref(HEVCContext *s, RefPicList *list, int poc, int ref_flag, uint8_t use_msb)
Definition: hevc_refs.c:421
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:394
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:392
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:393
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:391
@ ST_CURR_AFT
Definition: hevcdec.h:85
@ NB_RPS_TYPE
Definition: hevcdec.h:89
@ LT_FOLL
Definition: hevcdec.h:88
@ ST_CURR_BEF
Definition: hevcdec.h:84
@ LT_CURR
Definition: hevcdec.h:87
@ ST_FOLL
Definition: hevcdec.h:86
#define IS_BLA(s)
Definition: hevcdec.h:79
int i
Definition: input.c:407
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
@ HEVC_NAL_CRA_NUT
Definition: hevc.h:50
@ HEVC_SLICE_B
Definition: hevc.h:96
@ HEVC_MAX_REFS
Definition: hevc.h:119
internal header for HEVC (de)muxer utilities
common internal API header
static const uint16_t mask[17]
Definition: lzw.c:38
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
#define FF_ARRAY_ELEMS(a)
int size
Size of data in bytes.
Definition: buffer.h:97
uint8_t * data
The data buffer.
Definition: buffer.h:92
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:555
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:509
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:470
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:465
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2552
uint8_t used[32]
Definition: hevcdec.h:235
uint8_t nb_refs
Definition: hevcdec.h:236
int poc[32]
Definition: hevcdec.h:233
uint8_t poc_msb_present[32]
Definition: hevcdec.h:234
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:242
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:240
int nb_refs
Definition: hevcdec.h:243
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:241
unsigned int num_negative_pics
Definition: hevc_ps.h:35
uint8_t used[32]
Definition: hevc_ps.h:39
int num_delta_pocs
Definition: hevc_ps.h:36
int32_t delta_poc[32]
Definition: hevc_ps.h:38
enum HEVCSliceType slice_type
Definition: hevcdec.h:258
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:274
unsigned int nb_refs[2]
Definition: hevcdec.h:280
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:276
unsigned int collocated_ref_idx
Definition: hevcdec.h:290
uint8_t collocated_list
Definition: hevcdec.h:288
#define av_log(a,...)
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
FILE * out
Definition: movenc.c:54