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 i;
364 
365  if (use_msb) {
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 == poc)
370  return ref;
371  }
372  }
373  } else {
374  int LtMask = (1 << s->ps.sps->log2_max_poc_lsb) - 1;
375  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
376  HEVCFrame *ref = &s->DPB[i];
377  if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
378  if ((ref->poc & LtMask) == poc)
379  return ref;
380  }
381  }
382  }
383 
384  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
386  "Could not find ref with POC %d\n", poc);
387  return NULL;
388 }
389 
390 static void mark_ref(HEVCFrame *frame, int flag)
391 {
393  frame->flags |= flag;
394 }
395 
397 {
398  HEVCFrame *frame;
399  int i, y;
400 
401  frame = alloc_frame(s);
402  if (!frame)
403  return NULL;
404 
405  if (!s->avctx->hwaccel) {
406  if (!s->ps.sps->pixel_shift) {
407  for (i = 0; frame->frame->buf[i]; i++)
408  memset(frame->frame->buf[i]->data, 1 << (s->ps.sps->bit_depth - 1),
409  frame->frame->buf[i]->size);
410  } else {
411  for (i = 0; frame->frame->data[i]; i++)
412  for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++) {
413  uint8_t *dst = frame->frame->data[i] + y * frame->frame->linesize[i];
414  AV_WN16(dst, 1 << (s->ps.sps->bit_depth - 1));
415  av_memcpy_backptr(dst + 2, 2, 2*(s->ps.sps->width >> s->ps.sps->hshift[i]) - 2);
416  }
417  }
418  }
419 
420  frame->poc = poc;
421  frame->sequence = s->seq_decode;
422  frame->flags = 0;
423 
424  if (s->threads_type == FF_THREAD_FRAME)
425  ff_thread_report_progress(&frame->tf, INT_MAX, 0);
426 
427  return frame;
428 }
429 
430 /* add a reference with the given poc to the list and mark it as used in DPB */
432  int poc, int ref_flag, uint8_t use_msb)
433 {
434  HEVCFrame *ref = find_ref_idx(s, poc, use_msb);
435 
436  if (ref == s->ref || list->nb_refs >= HEVC_MAX_REFS)
437  return AVERROR_INVALIDDATA;
438 
439  if (!ref) {
440  ref = generate_missing_ref(s, poc);
441  if (!ref)
442  return AVERROR(ENOMEM);
443  }
444 
445  list->list[list->nb_refs] = ref->poc;
446  list->ref[list->nb_refs] = ref;
447  list->nb_refs++;
448 
449  mark_ref(ref, ref_flag);
450  return 0;
451 }
452 
454 {
455  const ShortTermRPS *short_rps = s->sh.short_term_rps;
456  const LongTermRPS *long_rps = &s->sh.long_term_rps;
457  RefPicList *rps = s->rps;
458  int i, ret = 0;
459 
460  if (!short_rps) {
461  rps[0].nb_refs = rps[1].nb_refs = 0;
462  return 0;
463  }
464 
465  /* clear the reference flags on all frames except the current one */
466  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
467  HEVCFrame *frame = &s->DPB[i];
468 
469  if (frame == s->ref)
470  continue;
471 
472  mark_ref(frame, 0);
473  }
474 
475  for (i = 0; i < NB_RPS_TYPE; i++)
476  rps[i].nb_refs = 0;
477 
478  /* add the short refs */
479  for (i = 0; i < short_rps->num_delta_pocs; i++) {
480  int poc = s->poc + short_rps->delta_poc[i];
481  int list;
482 
483  if (!short_rps->used[i])
484  list = ST_FOLL;
485  else if (i < short_rps->num_negative_pics)
486  list = ST_CURR_BEF;
487  else
488  list = ST_CURR_AFT;
489 
490  ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_SHORT_REF, 1);
491  if (ret < 0)
492  goto fail;
493  }
494 
495  /* add the long refs */
496  for (i = 0; i < long_rps->nb_refs; i++) {
497  int poc = long_rps->poc[i];
498  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
499 
500  ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_LONG_REF, long_rps->poc_msb_present[i]);
501  if (ret < 0)
502  goto fail;
503  }
504 
505 fail:
506  /* release any frames that are now unused */
507  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
508  ff_hevc_unref_frame(s, &s->DPB[i], 0);
509 
510  return ret;
511 }
512 
514 {
515  int ret = 0;
516  int i;
517  const ShortTermRPS *rps = s->sh.short_term_rps;
518  const LongTermRPS *long_rps = &s->sh.long_term_rps;
519 
520  if (rps) {
521  for (i = 0; i < rps->num_negative_pics; i++)
522  ret += !!rps->used[i];
523  for (; i < rps->num_delta_pocs; i++)
524  ret += !!rps->used[i];
525  }
526 
527  if (long_rps) {
528  for (i = 0; i < long_rps->nb_refs; i++)
529  ret += !!long_rps->used[i];
530  }
531  return ret;
532 }
const HEVCPPS * pps
Definition: hevc_ps.h:419
AVFrame * frame
Definition: hevcdec.h:312
#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:126
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
HEVCFrame * ref
Definition: hevcdec.h:423
int ctb_height
Definition: hevc_ps.h:314
static void flush(AVCodecContext *avctx)
int max_dec_pic_buffering
Definition: hevc_ps.h:256
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:491
void * hwaccel_picture_private
Definition: hevcdec.h:326
uint8_t nb_refs
Definition: hevc_ps.h:46
MvField * tab_mvf
Definition: hevcdec.h:314
int vshift[3]
Definition: hevc_ps.h:325
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:453
unsigned int left_offset
Definition: hevc_ps.h:127
HEVCParamSets ps
Definition: hevcdec.h:408
size_t crop_bottom
Definition: frame.h:661
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1690
int width
Definition: hevc_ps.h:311
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:468
uint8_t threads_type
Definition: hevcdec.h:392
int pixel_shift
Definition: hevc_ps.h:248
HEVCWindow output_window
Definition: hevc_ps.h:242
static HEVCFrame * alloc_frame(HEVCContext *s)
Definition: hevc_refs.c:82
AVBufferPool * rpl_tab_pool
candidate references for the current frame
Definition: hevcdec.h:413
int nb_refs
Definition: hevcdec.h:235
#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: hevc_ps.h:53
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
Definition: hevc_refs.c:32
enum HEVCSliceType slice_type
Definition: hevc_ps.h:57
unsigned int num_negative_pics
Definition: hevc_ps.h:35
uint8_t
enum HEVCNALUnitType nal_unit_type
Definition: hevcdec.h:421
size_t crop_left
Definition: frame.h:662
LongTermRPS long_term_rps
Definition: hevc_ps.h:72
int poc[32]
Definition: hevc_ps.h:43
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:232
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:444
AVCodecContext * avctx
Definition: hevcdec.h:385
uint8_t poc_msb_present[32]
Definition: hevc_ps.h:44
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:313
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:447
uint8_t pic_output_flag
Definition: hevc_ps.h:63
#define av_log(a,...)
uint8_t used[32]
Definition: hevc_ps.h:45
int ctb_count
Definition: hevcdec.h:317
uint8_t no_output_of_prior_pics_flag
Definition: hevc_ps.h:76
int slice_idx
number of the slice being currently decoded
Definition: hevcdec.h:427
static void mark_ref(HEVCFrame *frame, int flag)
Definition: hevc_refs.c:390
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_hevc_frame_nb_refs(const HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:513
unsigned int log2_max_poc_lsb
Definition: hevc_ps.h:251
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:308
AVBufferRef * rpl_tab_buf
Definition: hevcdec.h:322
uint8_t rpl_modification_flag[2]
Definition: hevc_ps.h:75
RefPicList * refPicList
Definition: hevcdec.h:315
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int log2_ctb_size
Definition: hevc_ps.h:293
simple assert() macros that are a bit more flexible than ISO C assert().
const ShortTermRPS * short_term_rps
Definition: hevc_ps.h:70
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:307
#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:332
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:306
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:660
const HEVCSPS * sps
Definition: hevc_ps.h:418
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:309
AVBufferRef * tab_mvf_buf
Definition: hevcdec.h:321
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
unsigned int top_offset
Definition: hevc_ps.h:129
int hshift[3]
Definition: hevc_ps.h:324
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:313
struct HEVCFrame * collocated_ref
Definition: hevcdec.h:319
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:312
uint16_t seq_output
Definition: hevcdec.h:469
#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:424
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:396
RefPicListTab ** rpl_tab
Definition: hevcdec.h:316
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:400
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
int max_sub_layers
Definition: hevc_ps.h:254
AVBufferRef * hwaccel_priv_buf
Definition: hevcdec.h:325
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:663
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:84
void ff_hevc_bump_frame(HEVCContext *s)
Definition: hevc_refs.c:233
int poc
Definition: hevcdec.h:318
uint8_t flags
A combination of HEVC_FRAME_FLAG_*.
Definition: hevcdec.h:337
int size
Size of data in bytes.
Definition: buffer.h:93
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:233
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:564
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
static int add_candidate_ref(HEVCContext *s, RefPicList *list, int poc, int ref_flag, uint8_t use_msb)
Definition: hevc_refs.c:431
HEVCSEIPictureTiming picture_timing
Definition: hevc_sei.h:117
common internal api header.
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
unsigned int nb_refs[2]
Definition: hevc_ps.h:79
#define flag(name)
Definition: cbs_av1.c:556
uint8_t collocated_list
Definition: hevc_ps.h:87
AVBufferPool * tab_mvf_pool
Definition: hevcdec.h:412
int num_delta_pocs
Definition: hevc_ps.h:36
RefPicList rps[5]
Definition: hevcdec.h:416
unsigned int collocated_ref_idx
Definition: hevc_ps.h:89
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:452
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2517
unsigned int list_entry_lx[2][32]
Definition: hevc_ps.h:73
HEVCSEI sei
Definition: hevcdec.h:409
H2645Packet pkt
Definition: hevcdec.h:476
unsigned int right_offset
Definition: hevc_ps.h:128
FILE * out
Definition: movenc.c:54
int num_reorder_pics
Definition: hevc_ps.h:257
#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:335
AVBufferRef * rpl_buf
Definition: hevcdec.h:323
int bit_depth
Definition: hevc_ps.h:246
struct HEVCSPS::@73 temporal_layer[HEVC_MAX_SUB_LAYERS]
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:418
int no_rasl_output_flag
Definition: hevcdec.h:436
#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)
unsigned int bottom_offset
Definition: hevc_ps.h:130
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:234