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  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, x, 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  for (x = 0; x < (s->ps.sps->width >> s->ps.sps->hshift[i]); x++) {
412  AV_WN16(frame->frame->data[i] + y * frame->frame->linesize[i] + 2 * x,
413  1 << (s->ps.sps->bit_depth - 1));
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  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:400
AVFrame * frame
Definition: hevcdec.h:311
#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
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
HEVCFrame * ref
Definition: hevcdec.h:420
HEVCSEIPictureTiming picture_timing
Definition: hevc_sei.h:113
int ctb_height
Definition: hevc_ps.h:296
static void flush(AVCodecContext *avctx)
int max_dec_pic_buffering
Definition: hevc_ps.h:243
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
void * hwaccel_picture_private
Definition: hevcdec.h:325
uint8_t nb_refs
Definition: hevc_ps.h:45
MvField * tab_mvf
Definition: hevcdec.h:313
int vshift[3]
Definition: hevc_ps.h:307
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:75
int flag
Definition: cpu.c:34
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:407
static HEVCFrame * find_ref_idx(HEVCContext *s, int poc)
Definition: hevc_refs.c:361
size_t crop_bottom
Definition: frame.h:560
int width
Definition: hevc_ps.h:293
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:464
uint8_t threads_type
Definition: hevcdec.h:391
int pixel_shift
Definition: hevc_ps.h:235
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:410
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:3066
int nb_refs
Definition: hevcdec.h:234
#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:418
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:231
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:392
struct HEVCSPS::@69 temporal_layer[HEVC_MAX_SUB_LAYERS]
AVCodecContext * avctx
Definition: hevcdec.h:384
static AVFrame * frame
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:312
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:316
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:424
static void mark_ref(HEVCFrame *frame, int flag)
Definition: hevc_refs.c:388
#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:238
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:307
AVBufferRef * rpl_tab_buf
Definition: hevcdec.h:321
#define AVERROR(e)
Definition: error.h:43
uint8_t rpl_modification_flag[2]
Definition: hevc_ps.h:74
RefPicList * refPicList
Definition: hevcdec.h:314
#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:279
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:306
#define fail()
Definition: checkasm.h:98
uint16_t sequence
A sequence counter, so that old frames are output first after a POC reset.
Definition: hevcdec.h:331
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:305
uint8_t used[32]
Definition: hevc_ps.h:39
size_t crop_top
Definition: frame.h:559
const HEVCSPS * sps
Definition: hevc_ps.h:399
#define HEVC_FRAME_FLAG_BUMPING
Definition: hevcdec.h:308
AVBufferRef * tab_mvf_buf
Definition: hevcdec.h:320
HEVCSEIContext sei
Definition: hevcdec.h:484
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:3186
#define FFMIN(a, b)
Definition: common.h:96
unsigned int top_offset
Definition: hevc_ps.h:128
int hshift[3]
Definition: hevc_ps.h:306
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:295
struct HEVCFrame * collocated_ref
Definition: hevcdec.h:318
int32_t delta_poc[32]
Definition: hevc_ps.h:38
int height
Definition: hevc_ps.h:294
uint16_t seq_output
Definition: hevcdec.h:465
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:77
#define FF_ARRAY_ELEMS(a)
static int init_slice_rpl(HEVCContext *s)
Definition: hevc_refs.c:273
HEVCFrame DPB[32]
Definition: hevcdec.h:421
static HEVCFrame * generate_missing_ref(HEVCContext *s, int poc)
Definition: hevc_refs.c:394
RefPicListTab ** rpl_tab
Definition: hevcdec.h:315
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:381
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:241
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:324
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:233
int poc
Definition: hevcdec.h:317
uint8_t flags
A combination of HEVC_FRAME_FLAG_*.
Definition: hevcdec.h:336
int size
Size of data in bytes.
Definition: buffer.h:93
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:232
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
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:409
int num_delta_pocs
Definition: hevc_ps.h:36
RefPicList rps[5]
Definition: hevcdec.h:413
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:3947
unsigned int list_entry_lx[2][32]
Definition: hevc_ps.h:72
int ff_hevc_frame_nb_refs(HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:511
H2645Packet pkt
Definition: hevcdec.h:472
unsigned int right_offset
Definition: hevc_ps.h:127
FILE * out
Definition: movenc.c:54
int num_reorder_pics
Definition: hevc_ps.h:244
#define AV_WN16(p, v)
Definition: intreadwrite.h:377
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:322
int bit_depth
Definition: hevc_ps.h:234
#define HEVC_MAX_REFS
Definition: hevc.h:71
SliceHeader sh
Definition: hevcdec.h:415
int no_rasl_output_flag
Definition: hevcdec.h:432
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1396
for(j=16;j >0;--j)
unsigned int bottom_offset
Definition: hevc_ps.h:129
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:233