FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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  if (frame->frame->format == AV_PIX_FMT_VIDEOTOOLBOX && frame->frame->buf[0]->size == 1)
212  return 0;
213 
214  ret = av_frame_ref(out, frame->frame);
215  if (frame->flags & HEVC_FRAME_FLAG_BUMPING)
217  else
219  if (ret < 0)
220  return ret;
221 
223  "Output frame with POC %d.\n", frame->poc);
224  return 1;
225  }
226 
227  if (s->seq_output != s->seq_decode)
228  s->seq_output = (s->seq_output + 1) & 0xff;
229  else
230  break;
231  } while (1);
232 
233  return 0;
234 }
235 
237 {
238  int dpb = 0;
239  int min_poc = INT_MAX;
240  int i;
241 
242  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
243  HEVCFrame *frame = &s->DPB[i];
244  if ((frame->flags) &&
245  frame->sequence == s->seq_output &&
246  frame->poc != s->poc) {
247  dpb++;
248  }
249  }
250 
251  if (s->ps.sps && dpb >= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering) {
252  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
253  HEVCFrame *frame = &s->DPB[i];
254  if ((frame->flags) &&
255  frame->sequence == s->seq_output &&
256  frame->poc != s->poc) {
257  if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) {
258  min_poc = frame->poc;
259  }
260  }
261  }
262 
263  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
264  HEVCFrame *frame = &s->DPB[i];
265  if (frame->flags & HEVC_FRAME_FLAG_OUTPUT &&
266  frame->sequence == s->seq_output &&
267  frame->poc <= min_poc) {
268  frame->flags |= HEVC_FRAME_FLAG_BUMPING;
269  }
270  }
271 
272  dpb--;
273  }
274 }
275 
277 {
278  HEVCFrame *frame = s->ref;
279  int ctb_count = frame->ctb_count;
280  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
281  int i;
282 
283  if (s->slice_idx >= frame->rpl_buf->size / sizeof(RefPicListTab))
284  return AVERROR_INVALIDDATA;
285 
286  for (i = ctb_addr_ts; i < ctb_count; i++)
287  frame->rpl_tab[i] = (RefPicListTab *)frame->rpl_buf->data + s->slice_idx;
288 
289  frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];
290 
291  return 0;
292 }
293 
295 {
296  SliceHeader *sh = &s->sh;
297 
298  uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;
299  uint8_t list_idx;
300  int i, j, ret;
301 
302  ret = init_slice_rpl(s);
303  if (ret < 0)
304  return ret;
305 
306  if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs +
307  s->rps[LT_CURR].nb_refs)) {
308  av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n");
309  return AVERROR_INVALIDDATA;
310  }
311 
312  for (list_idx = 0; list_idx < nb_list; list_idx++) {
313  RefPicList rpl_tmp = { { 0 } };
314  RefPicList *rpl = &s->ref->refPicList[list_idx];
315 
316  /* The order of the elements is
317  * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and
318  * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */
319  int cand_lists[3] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,
320  list_idx ? ST_CURR_BEF : ST_CURR_AFT,
321  LT_CURR };
322 
323  /* concatenate the candidate lists for the current frame */
324  while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {
325  for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
326  RefPicList *rps = &s->rps[cand_lists[i]];
327  for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {
328  rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];
329  rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j];
330  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2;
331  rpl_tmp.nb_refs++;
332  }
333  }
334  }
335 
336  /* reorder the references if necessary */
337  if (sh->rpl_modification_flag[list_idx]) {
338  for (i = 0; i < sh->nb_refs[list_idx]; i++) {
339  int idx = sh->list_entry_lx[list_idx][i];
340 
341  if (idx >= rpl_tmp.nb_refs) {
342  av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n");
343  return AVERROR_INVALIDDATA;
344  }
345 
346  rpl->list[i] = rpl_tmp.list[idx];
347  rpl->ref[i] = rpl_tmp.ref[idx];
348  rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx];
349  rpl->nb_refs++;
350  }
351  } else {
352  memcpy(rpl, &rpl_tmp, sizeof(*rpl));
353  rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]);
354  }
355 
356  if (sh->collocated_list == list_idx &&
357  sh->collocated_ref_idx < rpl->nb_refs)
358  s->ref->collocated_ref = rpl->ref[sh->collocated_ref_idx];
359  }
360 
361  return 0;
362 }
363 
365 {
366  int i;
367  int LtMask = (1 << s->ps.sps->log2_max_poc_lsb) - 1;
368 
369  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
370  HEVCFrame *ref = &s->DPB[i];
371  if (ref->frame->buf[0] && (ref->sequence == s->seq_decode)) {
372  if ((ref->poc & LtMask) == poc)
373  return ref;
374  }
375  }
376 
377  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
378  HEVCFrame *ref = &s->DPB[i];
379  if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
380  if (ref->poc == poc || (ref->poc & LtMask) == poc)
381  return ref;
382  }
383  }
384 
385  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
387  "Could not find ref with POC %d\n", poc);
388  return NULL;
389 }
390 
391 static void mark_ref(HEVCFrame *frame, int flag)
392 {
394  frame->flags |= flag;
395 }
396 
398 {
399  HEVCFrame *frame;
400  int i, x, y;
401 
402  frame = alloc_frame(s);
403  if (!frame)
404  return NULL;
405 
406  if (!s->avctx->hwaccel) {
407  if (!s->ps.sps->pixel_shift) {
408  for (i = 0; frame->frame->buf[i]; i++)
409  memset(frame->frame->buf[i]->data, 1 << (s->ps.sps->bit_depth - 1),
410  frame->frame->buf[i]->size);
411  } else {
412  for (i = 0; frame->frame->data[i]; i++)
413  for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++)
414  for (x = 0; x < (s->ps.sps->width >> s->ps.sps->hshift[i]); x++) {
415  AV_WN16(frame->frame->data[i] + y * frame->frame->linesize[i] + 2 * x,
416  1 << (s->ps.sps->bit_depth - 1));
417  }
418  }
419  }
420 
421  frame->poc = poc;
422  frame->sequence = s->seq_decode;
423  frame->flags = 0;
424 
425  if (s->threads_type == FF_THREAD_FRAME)
426  ff_thread_report_progress(&frame->tf, INT_MAX, 0);
427 
428  return frame;
429 }
430 
431 /* add a reference with the given poc to the list and mark it as used in DPB */
433  int poc, int ref_flag)
434 {
435  HEVCFrame *ref = find_ref_idx(s, poc);
436 
437  if (ref == s->ref || list->nb_refs >= HEVC_MAX_REFS)
438  return AVERROR_INVALIDDATA;
439 
440  if (!ref) {
441  ref = generate_missing_ref(s, poc);
442  if (!ref)
443  return AVERROR(ENOMEM);
444  }
445 
446  list->list[list->nb_refs] = ref->poc;
447  list->ref[list->nb_refs] = ref;
448  list->nb_refs++;
449 
450  mark_ref(ref, ref_flag);
451  return 0;
452 }
453 
455 {
456  const ShortTermRPS *short_rps = s->sh.short_term_rps;
457  const LongTermRPS *long_rps = &s->sh.long_term_rps;
458  RefPicList *rps = s->rps;
459  int i, ret = 0;
460 
461  if (!short_rps) {
462  rps[0].nb_refs = rps[1].nb_refs = 0;
463  return 0;
464  }
465 
466  /* clear the reference flags on all frames except the current one */
467  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
468  HEVCFrame *frame = &s->DPB[i];
469 
470  if (frame == s->ref)
471  continue;
472 
473  mark_ref(frame, 0);
474  }
475 
476  for (i = 0; i < NB_RPS_TYPE; i++)
477  rps[i].nb_refs = 0;
478 
479  /* add the short refs */
480  for (i = 0; i < short_rps->num_delta_pocs; i++) {
481  int poc = s->poc + short_rps->delta_poc[i];
482  int list;
483 
484  if (!short_rps->used[i])
485  list = ST_FOLL;
486  else if (i < short_rps->num_negative_pics)
487  list = ST_CURR_BEF;
488  else
489  list = ST_CURR_AFT;
490 
491  ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_SHORT_REF);
492  if (ret < 0)
493  goto fail;
494  }
495 
496  /* add the long refs */
497  for (i = 0; i < long_rps->nb_refs; i++) {
498  int poc = long_rps->poc[i];
499  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
500 
501  ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_LONG_REF);
502  if (ret < 0)
503  goto fail;
504  }
505 
506 fail:
507  /* release any frames that are now unused */
508  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
509  ff_hevc_unref_frame(s, &s->DPB[i], 0);
510 
511  return ret;
512 }
513 
515 {
516  int ret = 0;
517  int i;
518  const ShortTermRPS *rps = s->sh.short_term_rps;
519  LongTermRPS *long_rps = &s->sh.long_term_rps;
520 
521  if (rps) {
522  for (i = 0; i < rps->num_negative_pics; i++)
523  ret += !!rps->used[i];
524  for (; i < rps->num_delta_pocs; i++)
525  ret += !!rps->used[i];
526  }
527 
528  if (long_rps) {
529  for (i = 0; i < long_rps->nb_refs; i++)
530  ret += !!long_rps->used[i];
531  }
532  return ret;
533 }
const HEVCPPS * pps
Definition: hevc_ps.h:402
AVFrame * frame
Definition: hevcdec.h:312
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
#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
#define flag(name)
Definition: cbs_h2645.c:345
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
HEVCFrame * ref
Definition: hevcdec.h:423
int ctb_height
Definition: hevc_ps.h:298
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:393
hardware decoding through Videotoolbox
Definition: pixfmt.h:278
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:309
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:454
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:364
size_t crop_bottom
Definition: frame.h:560
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2658
int width
Definition: hevc_ps.h:295
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:467
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:561
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:400
AVCodecContext * avctx
Definition: hevcdec.h:385
static AVFrame * frame
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: hevc_refs.c:294
ThreadFrame tf
Definition: hevcdec.h:313
static int flags
Definition: log.c:57
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:348
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:391
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
unsigned int log2_max_poc_lsb
Definition: hevc_ps.h:239
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
#define AVERROR(e)
Definition: error.h:43
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
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:113
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:559
const HEVCSPS * sps
Definition: hevc_ps.h:401
#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:2764
#define FFMIN(a, b)
Definition: common.h:96
unsigned int top_offset
Definition: hevc_ps.h:128
int hshift[3]
Definition: hevc_ps.h:308
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
int ctb_width
Definition: hevc_ps.h:297
struct HEVCFrame * collocated_ref
Definition: hevcdec.h:319
int32_t delta_poc[32]
Definition: hevc_ps.h:38
int height
Definition: hevc_ps.h:296
uint16_t seq_output
Definition: hevcdec.h:468
static int add_candidate_ref(HEVCContext *s, RefPicList *list, int poc, int ref_flag)
Definition: hevc_refs.c:432
#define IS_BLA(s)
Definition: hevcdec.h:78
#define FF_ARRAY_ELEMS(a)
static int init_slice_rpl(HEVCContext *s)
Definition: hevc_refs.c:276
struct HEVCSPS::@83 temporal_layer[HEVC_MAX_SUB_LAYERS]
HEVCFrame DPB[32]
Definition: hevcdec.h:424
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:397
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:274
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:383
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232
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
uint8_t * data
The data buffer.
Definition: buffer.h:89
size_t crop_right
Definition: frame.h:562
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:236
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
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
HEVCSEIPictureTiming picture_timing
Definition: hevc_sei.h:111
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
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:353
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:3640
unsigned int list_entry_lx[2][32]
Definition: hevc_ps.h:72
HEVCSEI sei
Definition: hevcdec.h:409
int ff_hevc_frame_nb_refs(HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:514
H2645Packet pkt
Definition: hevcdec.h:475
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
SliceHeader sh
Definition: hevcdec.h:418
int no_rasl_output_flag
Definition: hevcdec.h:435
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1132
for(j=16;j >0;--j)
unsigned int bottom_offset
Definition: hevc_ps.h:129
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:234