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 
362 {
363  int i;
364  int LtMask = (1 << s->ps.sps->log2_max_poc_lsb) - 1;
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 & LtMask) == poc)
370  return ref;
371  }
372  }
373 
374  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
375  HEVCFrame *ref = &s->DPB[i];
376  if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
377  if (ref->poc == poc || (ref->poc & LtMask) == poc)
378  return ref;
379  }
380  }
381 
382  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
384  "Could not find ref with POC %d\n", poc);
385  return NULL;
386 }
387 
388 static void mark_ref(HEVCFrame *frame, int flag)
389 {
391  frame->flags |= flag;
392 }
393 
395 {
396  HEVCFrame *frame;
397  int i, y;
398 
399  frame = alloc_frame(s);
400  if (!frame)
401  return NULL;
402 
403  if (!s->avctx->hwaccel) {
404  if (!s->ps.sps->pixel_shift) {
405  for (i = 0; frame->frame->buf[i]; i++)
406  memset(frame->frame->buf[i]->data, 1 << (s->ps.sps->bit_depth - 1),
407  frame->frame->buf[i]->size);
408  } else {
409  for (i = 0; frame->frame->data[i]; i++)
410  for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++) {
411  uint8_t *dst = frame->frame->data[i] + y * frame->frame->linesize[i];
412  AV_WN16(dst, 1 << (s->ps.sps->bit_depth - 1));
413  av_memcpy_backptr(dst + 2, 2, 2*(s->ps.sps->width >> s->ps.sps->hshift[i]) - 2);
414  }
415  }
416  }
417 
418  frame->poc = poc;
419  frame->sequence = s->seq_decode;
420  frame->flags = 0;
421 
422  if (s->threads_type == FF_THREAD_FRAME)
423  ff_thread_report_progress(&frame->tf, INT_MAX, 0);
424 
425  return frame;
426 }
427 
428 /* add a reference with the given poc to the list and mark it as used in DPB */
430  int poc, int ref_flag)
431 {
432  HEVCFrame *ref = find_ref_idx(s, poc);
433 
434  if (ref == s->ref || list->nb_refs >= HEVC_MAX_REFS)
435  return AVERROR_INVALIDDATA;
436 
437  if (!ref) {
438  ref = generate_missing_ref(s, poc);
439  if (!ref)
440  return AVERROR(ENOMEM);
441  }
442 
443  list->list[list->nb_refs] = ref->poc;
444  list->ref[list->nb_refs] = ref;
445  list->nb_refs++;
446 
447  mark_ref(ref, ref_flag);
448  return 0;
449 }
450 
452 {
453  const ShortTermRPS *short_rps = s->sh.short_term_rps;
454  const LongTermRPS *long_rps = &s->sh.long_term_rps;
455  RefPicList *rps = s->rps;
456  int i, ret = 0;
457 
458  if (!short_rps) {
459  rps[0].nb_refs = rps[1].nb_refs = 0;
460  return 0;
461  }
462 
463  /* clear the reference flags on all frames except the current one */
464  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
465  HEVCFrame *frame = &s->DPB[i];
466 
467  if (frame == s->ref)
468  continue;
469 
470  mark_ref(frame, 0);
471  }
472 
473  for (i = 0; i < NB_RPS_TYPE; i++)
474  rps[i].nb_refs = 0;
475 
476  /* add the short refs */
477  for (i = 0; i < short_rps->num_delta_pocs; i++) {
478  int poc = s->poc + short_rps->delta_poc[i];
479  int list;
480 
481  if (!short_rps->used[i])
482  list = ST_FOLL;
483  else if (i < short_rps->num_negative_pics)
484  list = ST_CURR_BEF;
485  else
486  list = ST_CURR_AFT;
487 
488  ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_SHORT_REF);
489  if (ret < 0)
490  goto fail;
491  }
492 
493  /* add the long refs */
494  for (i = 0; i < long_rps->nb_refs; i++) {
495  int poc = long_rps->poc[i];
496  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
497 
498  ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_LONG_REF);
499  if (ret < 0)
500  goto fail;
501  }
502 
503 fail:
504  /* release any frames that are now unused */
505  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
506  ff_hevc_unref_frame(s, &s->DPB[i], 0);
507 
508  return ret;
509 }
510 
512 {
513  int ret = 0;
514  int i;
515  const ShortTermRPS *rps = s->sh.short_term_rps;
516  const LongTermRPS *long_rps = &s->sh.long_term_rps;
517 
518  if (rps) {
519  for (i = 0; i < rps->num_negative_pics; i++)
520  ret += !!rps->used[i];
521  for (; i < rps->num_delta_pocs; i++)
522  ret += !!rps->used[i];
523  }
524 
525  if (long_rps) {
526  for (i = 0; i < long_rps->nb_refs; i++)
527  ret += !!long_rps->used[i];
528  }
529  return ret;
530 }
const HEVCPPS * pps
Definition: hevc_ps.h:407
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:125
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
HEVCFrame * ref
Definition: hevcdec.h:423
int ctb_height
Definition: hevc_ps.h:302
static void flush(AVCodecContext *avctx)
int max_dec_pic_buffering
Definition: hevc_ps.h:244
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:486
void * hwaccel_picture_private
Definition: hevcdec.h:326
uint8_t nb_refs
Definition: hevc_ps.h:45
MvField * tab_mvf
Definition: hevcdec.h:314
int vshift[3]
Definition: hevc_ps.h:313
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:451
unsigned int left_offset
Definition: hevc_ps.h:126
HEVCParamSets ps
Definition: hevcdec.h:408
static HEVCFrame * find_ref_idx(HEVCContext *s, int poc)
Definition: hevc_refs.c:361
size_t crop_bottom
Definition: frame.h:656
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2729
int width
Definition: hevc_ps.h:299
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:236
HEVCWindow output_window
Definition: hevc_ps.h:230
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:52
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
Definition: hevc_refs.c:32
enum HEVCSliceType slice_type
Definition: hevc_ps.h:56
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:657
LongTermRPS long_term_rps
Definition: hevc_ps.h:71
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:443
AVCodecContext * avctx
Definition: hevcdec.h:385
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:426
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
uint8_t pic_output_flag
Definition: hevc_ps.h:62
#define av_log(a,...)
uint8_t used[32]
Definition: hevc_ps.h:44
int ctb_count
Definition: hevcdec.h:317
uint8_t no_output_of_prior_pics_flag
Definition: hevc_ps.h:75
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:388
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#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:511
unsigned int log2_max_poc_lsb
Definition: hevc_ps.h:239
#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:74
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:281
struct HEVCSPS::@94 temporal_layer[HEVC_MAX_SUB_LAYERS]
simple assert() macros that are a bit more flexible than ISO C assert().
const ShortTermRPS * short_term_rps
Definition: hevc_ps.h:69
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:307
#define fail()
Definition: checkasm.h:120
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
size_t crop_top
Definition: frame.h:655
const HEVCSPS * sps
Definition: hevc_ps.h:406
#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:2835
#define FFMIN(a, b)
Definition: common.h:96
unsigned int top_offset
Definition: hevc_ps.h:128
int hshift[3]
Definition: hevc_ps.h:312
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:301
struct HEVCFrame * collocated_ref
Definition: hevcdec.h:319
int32_t delta_poc[32]
Definition: hevc_ps.h:38
int height
Definition: hevc_ps.h:300
uint16_t seq_output
Definition: hevcdec.h:469
static int add_candidate_ref(HEVCContext *s, RefPicList *list, int poc, int ref_flag)
Definition: hevc_refs.c:429
#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:394
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
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 add an so the codec calls ff_thread_report set AVCodecInternal allocate_progress The frames must then be freed with ff_thread_release_buffer().Otherwise leave it at zero and 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
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc_ps.h:388
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
int max_sub_layers
Definition: hevc_ps.h:242
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
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:658
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: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:561
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
HEVCSEIPictureTiming picture_timing
Definition: hevc_sei.h:113
common internal api header.
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
unsigned int nb_refs[2]
Definition: hevc_ps.h:78
#define flag(name)
Definition: cbs_av1.c:553
uint8_t collocated_list
Definition: hevc_ps.h:86
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:88
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:3759
unsigned int list_entry_lx[2][32]
Definition: hevc_ps.h:72
HEVCSEI sei
Definition: hevcdec.h:409
H2645Packet pkt
Definition: hevcdec.h:476
unsigned int right_offset
Definition: hevc_ps.h:127
FILE * out
Definition: movenc.c:54
int num_reorder_pics
Definition: hevc_ps.h:245
#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:334
AVBufferRef * rpl_buf
Definition: hevcdec.h:323
int bit_depth
Definition: hevc_ps.h:234
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:1176
for(j=16;j >0;--j)
unsigned int bottom_offset
Definition: hevc_ps.h:129
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:234