FFmpeg
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/mem.h"
25 #include "libavutil/stereo3d.h"
26 
27 #include "container_fifo.h"
28 #include "decode.h"
29 #include "hevc.h"
30 #include "hevcdec.h"
31 #include "progressframe.h"
32 #include "refstruct.h"
33 
35 {
36  frame->flags &= ~flags;
37  if (!frame->flags) {
39  av_frame_unref(frame->frame_grain);
40  frame->needs_fg = 0;
41 
43  ff_refstruct_unref(&frame->tab_mvf);
44 
46  frame->nb_rpl_elems = 0;
47  ff_refstruct_unref(&frame->rpl_tab);
48  frame->refPicList = NULL;
49 
50  ff_refstruct_unref(&frame->hwaccel_picture_private);
51  }
52 }
53 
54 const RefPicList *ff_hevc_get_ref_list(const HEVCFrame *ref, int x0, int y0)
55 {
56  const HEVCSPS *sps = ref->pps->sps;
57  int x_cb = x0 >> sps->log2_ctb_size;
58  int y_cb = y0 >> sps->log2_ctb_size;
59  int pic_width_cb = sps->ctb_width;
60  int ctb_addr_ts = ref->pps->ctb_addr_rs_to_ts[y_cb * pic_width_cb + x_cb];
61  return &ref->rpl_tab[ctb_addr_ts]->refPicList[0];
62 }
63 
65 {
66  int i;
67  for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++)
71 }
72 
74 {
75  for (int layer = 0; layer < FF_ARRAY_ELEMS(s->layers); layer++) {
76  HEVCLayerContext *l = &s->layers[layer];
77  for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++)
78  ff_hevc_unref_frame(&l->DPB[i], ~0);
79  }
80 }
81 
83 {
84  const HEVCVPS *vps = l->sps->vps;
85  const int view_id = vps->view_id[s->cur_layer];
86  int i, j, ret;
87  for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
88  HEVCFrame *frame = &l->DPB[i];
89  if (frame->f)
90  continue;
91 
92  ret = ff_progress_frame_alloc(s->avctx, &frame->tf);
93  if (ret < 0)
94  return NULL;
95 
96  // Add LCEVC SEI metadata here, as it's needed in get_buffer()
97  if (s->sei.common.lcevc.info) {
98  HEVCSEILCEVC *lcevc = &s->sei.common.lcevc;
100  AV_FRAME_DATA_LCEVC, &lcevc->info);
101  if (ret < 0)
102  goto fail;
103  }
104 
105  // add view ID side data if it's nontrivial
106  if (vps->nb_layers > 1 || view_id) {
107  HEVCSEITDRDI *tdrdi = &s->sei.tdrdi;
108  AVFrameSideData *sd = av_frame_side_data_new(&frame->f->side_data,
109  &frame->f->nb_side_data,
111  sizeof(int), 0);
112  if (!sd)
113  goto fail;
114  *(int*)sd->data = view_id;
115 
116  if (tdrdi->num_ref_displays) {
117  AVStereo3D *stereo_3d;
118 
119  stereo_3d = av_stereo3d_create_side_data(frame->f);
120  if (!stereo_3d)
121  goto fail;
122 
123  stereo_3d->type = AV_STEREO3D_FRAMESEQUENCE;
124  if (tdrdi->left_view_id[0] == view_id)
125  stereo_3d->view = AV_STEREO3D_VIEW_LEFT;
126  else if (tdrdi->right_view_id[0] == view_id)
127  stereo_3d->view = AV_STEREO3D_VIEW_RIGHT;
128  else
129  stereo_3d->view = AV_STEREO3D_VIEW_UNSPEC;
130  }
131  }
132 
133  ret = ff_progress_frame_get_buffer(s->avctx, &frame->tf,
135  if (ret < 0)
136  return NULL;
137 
138  frame->rpl = ff_refstruct_allocz(s->pkt.nb_nals * sizeof(*frame->rpl));
139  if (!frame->rpl)
140  goto fail;
141  frame->nb_rpl_elems = s->pkt.nb_nals;
142 
144  if (!frame->tab_mvf)
145  goto fail;
146 
148  if (!frame->rpl_tab)
149  goto fail;
150  frame->ctb_count = l->sps->ctb_width * l->sps->ctb_height;
151  for (j = 0; j < frame->ctb_count; j++)
152  frame->rpl_tab[j] = frame->rpl;
153 
154  if (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD)
156  if ((s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) ||
157  (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD))
158  frame->f->flags |= AV_FRAME_FLAG_INTERLACED;
159 
160  ret = ff_hwaccel_frame_priv_alloc(s->avctx, &frame->hwaccel_picture_private);
161  if (ret < 0)
162  goto fail;
163 
164  frame->pps = ff_refstruct_ref_c(s->pps);
165 
166  return frame;
167 fail:
169  return NULL;
170  }
171  av_log(s->avctx, AV_LOG_ERROR, "Error allocating frame, DPB full.\n");
172  return NULL;
173 }
174 
176 {
177  HEVCFrame *ref;
178  int i;
179 
180  /* check that this POC doesn't already exist */
181  for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
182  HEVCFrame *frame = &l->DPB[i];
183 
184  if (frame->f && frame->poc == poc) {
185  av_log(s->avctx, AV_LOG_ERROR, "Duplicate POC in a sequence: %d.\n",
186  poc);
187  return AVERROR_INVALIDDATA;
188  }
189  }
190 
191  ref = alloc_frame(s, l);
192  if (!ref)
193  return AVERROR(ENOMEM);
194 
195  s->cur_frame = ref;
196  l->cur_frame = ref;
197  s->collocated_ref = NULL;
198 
199  ref->base_layer_frame = (l != &s->layers[0] && s->layers[0].cur_frame) ?
200  s->layers[0].cur_frame - s->layers[0].DPB : -1;
201 
202  if (s->sh.pic_output_flag)
204  else
206 
207  ref->poc = poc;
208  ref->f->crop_left = l->sps->output_window.left_offset;
209  ref->f->crop_right = l->sps->output_window.right_offset;
210  ref->f->crop_top = l->sps->output_window.top_offset;
211  ref->f->crop_bottom = l->sps->output_window.bottom_offset;
212 
213  return 0;
214 }
215 
217 {
218  for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
219  HEVCFrame *frame = &l->DPB[i];
220  if (frame->flags & HEVC_FRAME_FLAG_UNAVAILABLE) {
222  }
223  }
224 }
225 
227  unsigned layers_active_decode, unsigned layers_active_output,
228  unsigned max_output, unsigned max_dpb, int discard)
229 {
230  while (1) {
231  int nb_dpb[HEVC_VPS_MAX_LAYERS] = { 0 };
232  int nb_output = 0;
233  int min_poc = INT_MAX;
234  int min_layer = -1;
235  int min_idx, ret = 0;
236 
237  for (int layer = 0; layer < FF_ARRAY_ELEMS(s->layers); layer++) {
238  HEVCLayerContext *l = &s->layers[layer];
239 
240  if (!(layers_active_decode & (1 << layer)))
241  continue;
242 
243  for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
244  HEVCFrame *frame = &l->DPB[i];
245  if (frame->flags & HEVC_FRAME_FLAG_OUTPUT) {
246  // nb_output counts AUs with an output-pending frame
247  // in at least one layer
248  if (!(frame->base_layer_frame >= 0 &&
249  (s->layers[0].DPB[frame->base_layer_frame].flags & HEVC_FRAME_FLAG_OUTPUT)))
250  nb_output++;
251  if (min_layer < 0 || frame->poc < min_poc) {
252  min_poc = frame->poc;
253  min_idx = i;
254  min_layer = layer;
255  }
256  }
257  nb_dpb[layer] += !!frame->flags;
258  }
259  }
260 
261  if (nb_output > max_output ||
262  (nb_output &&
263  (nb_dpb[0] > max_dpb || nb_dpb[1] > max_dpb))) {
264  HEVCFrame *frame = &s->layers[min_layer].DPB[min_idx];
265  AVFrame *f = frame->needs_fg ? frame->frame_grain : frame->f;
266  int output = !discard && (layers_active_output & (1 << min_layer));
267 
268  if (output) {
269  f->pkt_dts = s->pkt_dts;
270  ret = ff_container_fifo_write(s->output_fifo, f);
271  }
273  if (ret < 0)
274  return ret;
275 
276  av_log(s->avctx, AV_LOG_DEBUG, "%s frame with POC %d/%d.\n",
277  output ? "Output" : "Discarded", min_layer, frame->poc);
278  continue;
279  }
280  return 0;
281  }
282 }
283 
285 {
286  HEVCFrame *frame = s->cur_frame;
287  int ctb_count = frame->ctb_count;
288  int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
289  int i;
290 
291  if (s->slice_idx >= frame->nb_rpl_elems)
292  return AVERROR_INVALIDDATA;
293 
294  for (i = ctb_addr_ts; i < ctb_count; i++)
295  frame->rpl_tab[i] = frame->rpl + s->slice_idx;
296 
297  frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];
298 
299  return 0;
300 }
301 
303 {
304  SliceHeader *sh = &s->sh;
305 
306  uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;
307  uint8_t list_idx;
308  int i, j, ret;
309 
310  ret = init_slice_rpl(s);
311  if (ret < 0)
312  return ret;
313 
314  if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs +
315  s->rps[LT_CURR].nb_refs +
316  s->rps[INTER_LAYER0].nb_refs + s->rps[INTER_LAYER1].nb_refs) &&
317  !s->pps->pps_curr_pic_ref_enabled_flag) {
318  av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n");
319  return AVERROR_INVALIDDATA;
320  }
321 
322  for (list_idx = 0; list_idx < nb_list; list_idx++) {
323  RefPicList rpl_tmp = { { 0 } };
324  RefPicList *rpl = &s->cur_frame->refPicList[list_idx];
325 
326  /* The order of the elements is
327  * ST_CURR_BEF - INTER_LAYER0 - ST_CURR_AFT - LT_CURR - INTER_LAYER1 for the L0 and
328  * ST_CURR_AFT - INTER_LAYER1 - ST_CURR_BEF - LT_CURR - INTER_LAYER0 for the L1 */
329  int cand_lists[] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,
330  list_idx ? INTER_LAYER1 : INTER_LAYER0,
331  list_idx ? ST_CURR_BEF : ST_CURR_AFT,
332  LT_CURR,
333  list_idx ? INTER_LAYER0 : INTER_LAYER1
334  };
335 
336  /* concatenate the candidate lists for the current frame */
337  while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {
338  for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
339  RefPicList *rps = &s->rps[cand_lists[i]];
340  for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {
341  rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];
342  rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j];
343  // multiview inter-layer refs are treated as long-term here,
344  // cf. G.8.1.3
345  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = cand_lists[i] == LT_CURR ||
346  cand_lists[i] == INTER_LAYER0 ||
347  cand_lists[i] == INTER_LAYER1;
348  rpl_tmp.nb_refs++;
349  }
350  }
351  // Construct RefPicList0, RefPicList1 (8-8, 8-10)
352  if (s->pps->pps_curr_pic_ref_enabled_flag && rpl_tmp.nb_refs < HEVC_MAX_REFS) {
353  rpl_tmp.list[rpl_tmp.nb_refs] = s->cur_frame->poc;
354  rpl_tmp.ref[rpl_tmp.nb_refs] = s->cur_frame;
355  rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = 1;
356  rpl_tmp.nb_refs++;
357  }
358  }
359 
360  /* reorder the references if necessary */
361  if (sh->rpl_modification_flag[list_idx]) {
362  for (i = 0; i < sh->nb_refs[list_idx]; i++) {
363  int idx = sh->list_entry_lx[list_idx][i];
364 
365  if (idx >= rpl_tmp.nb_refs) {
366  av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n");
367  return AVERROR_INVALIDDATA;
368  }
369 
370  rpl->list[i] = rpl_tmp.list[idx];
371  rpl->ref[i] = rpl_tmp.ref[idx];
372  rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx];
373  rpl->nb_refs++;
374  }
375  } else {
376  memcpy(rpl, &rpl_tmp, sizeof(*rpl));
377  rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]);
378  }
379 
380  // 8-9
381  if (s->pps->pps_curr_pic_ref_enabled_flag &&
382  !sh->rpl_modification_flag[list_idx] &&
383  rpl_tmp.nb_refs > sh->nb_refs[L0]) {
384  rpl->list[sh->nb_refs[L0] - 1] = s->cur_frame->poc;
385  rpl->ref[sh->nb_refs[L0] - 1] = s->cur_frame;
386  }
387 
388  if (sh->collocated_list == list_idx &&
389  sh->collocated_ref_idx < rpl->nb_refs)
390  s->collocated_ref = rpl->ref[sh->collocated_ref_idx];
391  }
392 
393  return 0;
394 }
395 
397  int poc, uint8_t use_msb)
398 {
399  int mask = use_msb ? ~0 : (1 << l->sps->log2_max_poc_lsb) - 1;
400  int i;
401 
402  for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
403  HEVCFrame *ref = &l->DPB[i];
404  if (ref->f) {
405  if ((ref->poc & mask) == poc && (use_msb || ref->poc != s->poc))
406  return ref;
407  }
408  }
409 
410  if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
411  av_log(s->avctx, AV_LOG_ERROR,
412  "Could not find ref with POC %d\n", poc);
413  return NULL;
414 }
415 
416 static void mark_ref(HEVCFrame *frame, int flag)
417 {
419  frame->flags |= flag;
420 }
421 
423 {
424  HEVCFrame *frame;
425  int i, y;
426 
427  frame = alloc_frame(s, l);
428  if (!frame)
429  return NULL;
430 
431  if (!s->avctx->hwaccel) {
432  if (!l->sps->pixel_shift) {
433  for (i = 0; frame->f->data[i]; i++)
434  memset(frame->f->data[i], 1 << (l->sps->bit_depth - 1),
435  frame->f->linesize[i] * AV_CEIL_RSHIFT(l->sps->height, l->sps->vshift[i]));
436  } else {
437  for (i = 0; frame->f->data[i]; i++)
438  for (y = 0; y < (l->sps->height >> l->sps->vshift[i]); y++) {
439  uint8_t *dst = frame->f->data[i] + y * frame->f->linesize[i];
440  AV_WN16(dst, 1 << (l->sps->bit_depth - 1));
441  av_memcpy_backptr(dst + 2, 2, 2*(l->sps->width >> l->sps->hshift[i]) - 2);
442  }
443  }
444  }
445 
446  frame->poc = poc;
448 
449  if (s->avctx->active_thread_type == FF_THREAD_FRAME)
450  ff_progress_frame_report(&frame->tf, INT_MAX);
451 
452  return frame;
453 }
454 
455 /* add a reference with the given poc to the list and mark it as used in DPB */
457  RefPicList *list,
458  int poc, int ref_flag, uint8_t use_msb)
459 {
460  HEVCFrame *ref = find_ref_idx(s, l, poc, use_msb);
461 
462  if (ref == s->cur_frame || list->nb_refs >= HEVC_MAX_REFS)
463  return AVERROR_INVALIDDATA;
464 
465  if (!ref) {
466  ref = generate_missing_ref(s, l, poc);
467  if (!ref)
468  return AVERROR(ENOMEM);
469  }
470 
471  list->list[list->nb_refs] = ref->poc;
472  list->ref[list->nb_refs] = ref;
473  list->nb_refs++;
474 
475  mark_ref(ref, ref_flag);
476  return 0;
477 }
478 
480 {
481  const ShortTermRPS *short_rps = s->sh.short_term_rps;
482  const LongTermRPS *long_rps = &s->sh.long_term_rps;
483  RefPicList *rps = s->rps;
484  int i, ret = 0;
485 
487 
488  /* clear the reference flags on all frames except the current one */
489  for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
490  HEVCFrame *frame = &l->DPB[i];
491 
492  if (frame == s->cur_frame)
493  continue;
494 
495  mark_ref(frame, 0);
496  }
497 
498  for (i = 0; i < NB_RPS_TYPE; i++)
499  rps[i].nb_refs = 0;
500 
501  if (!short_rps)
502  goto inter_layer;
503 
504  /* add the short refs */
505  for (i = 0; i < short_rps->num_delta_pocs; i++) {
506  int poc = s->poc + short_rps->delta_poc[i];
507  int list;
508 
509  if (!(short_rps->used & (1 << i)))
510  list = ST_FOLL;
511  else if (i < short_rps->num_negative_pics)
512  list = ST_CURR_BEF;
513  else
514  list = ST_CURR_AFT;
515 
516  ret = add_candidate_ref(s, l, &rps[list], poc,
518  if (ret < 0)
519  goto fail;
520  }
521 
522  /* add the long refs */
523  for (i = 0; i < long_rps->nb_refs; i++) {
524  int poc = long_rps->poc[i];
525  int list = long_rps->used[i] ? LT_CURR : LT_FOLL;
526 
527  ret = add_candidate_ref(s, l, &rps[list], poc,
529  if (ret < 0)
530  goto fail;
531  }
532 
533 inter_layer:
534  /* add inter-layer refs */
535  if (s->sh.inter_layer_pred) {
536  HEVCLayerContext *l0 = &s->layers[0];
537 
538  av_assert0(l != l0);
539 
540  /* Given the assumption of at most two layers, refPicSet0Flag is
541  * always 1, so only RefPicSetInterLayer0 can ever contain a frame. */
542  if (l0->cur_frame) {
543  // inter-layer refs are treated as short-term here, cf. F.8.1.6
544  ret = add_candidate_ref(s, l0, &rps[INTER_LAYER0], l0->cur_frame->poc,
546  if (ret < 0)
547  goto fail;
548  }
549  }
550 
551 fail:
552  /* release any frames that are now unused */
553  for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++)
554  ff_hevc_unref_frame(&l->DPB[i], 0);
555 
556  return ret;
557 }
558 
560  unsigned layer_idx)
561 {
562  int ret = 0;
563  int i;
564  const ShortTermRPS *rps = sh->short_term_rps;
565  const LongTermRPS *long_rps = &sh->long_term_rps;
566 
567  if (rps) {
568  for (i = 0; i < rps->num_negative_pics; i++)
569  ret += !!(rps->used & (1 << i));
570  for (; i < rps->num_delta_pocs; i++)
571  ret += !!(rps->used & (1 << i));
572  }
573 
574  if (long_rps) {
575  for (i = 0; i < long_rps->nb_refs; i++)
576  ret += !!long_rps->used[i];
577  }
578 
579  if (sh->inter_layer_pred) {
580  av_assert0(pps->sps->vps->num_direct_ref_layers[layer_idx] < 2);
581  ret++;
582  }
583 
584  if (pps->pps_curr_pic_ref_enabled_flag)
585  ret++;
586 
587  return ret;
588 }
ff_progress_frame_report
void ff_progress_frame_report(ProgressFrame *f, int n)
Notify later decoding threads when part of their reference frame is ready.
Definition: decode.c:1893
ff_hevc_flush_dpb
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: refs.c:73
ff_container_fifo_write
int ff_container_fifo_write(ContainerFifo *cf, void *obj)
Write the contents of obj to the FIFO.
Definition: container_fifo.c:136
AV_STEREO3D_VIEW_LEFT
@ AV_STEREO3D_VIEW_LEFT
Frame contains only the left view.
Definition: stereo3d.h:158
LT_FOLL
@ LT_FOLL
Definition: hevcdec.h:86
AVERROR
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
HEVCWindow::bottom_offset
unsigned int bottom_offset
Definition: ps.h:95
ShortTermRPS::num_negative_pics
uint8_t num_negative_pics
Definition: ps.h:80
HEVC_VPS_MAX_LAYERS
#define HEVC_VPS_MAX_LAYERS
Definition: ps.h:35
HEVCSPS::bit_depth
int bit_depth
Definition: ps.h:262
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
HEVCSEILCEVC::info
AVBufferRef * info
Definition: h2645_sei.h:54
mask
int mask
Definition: mediacodecdec_common.c:154
container_fifo.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
ff_progress_frame_get_buffer
int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
This function sets up the ProgressFrame, i.e.
Definition: decode.c:1848
ff_hevc_frame_rps
int ff_hevc_frame_rps(HEVCContext *s, HEVCLayerContext *l)
Construct the reference picture sets for the current frame.
Definition: refs.c:479
RefPicList
Definition: hevcdec.h:192
AV_STEREO3D_VIEW_RIGHT
@ AV_STEREO3D_VIEW_RIGHT
Frame contains only the right view.
Definition: stereo3d.h:163
HEVCSEILCEVC
Definition: h2645_sei.h:53
AV_STEREO3D_VIEW_UNSPEC
@ AV_STEREO3D_VIEW_UNSPEC
Content is unspecified.
Definition: stereo3d.h:168
HEVCSPS::output_window
HEVCWindow output_window
Definition: ps.h:256
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:653
find_ref_idx
static HEVCFrame * find_ref_idx(HEVCContext *s, HEVCLayerContext *l, int poc, uint8_t use_msb)
Definition: refs.c:396
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:354
fail
#define fail()
Definition: checkasm.h:193
HEVCWindow::left_offset
unsigned int left_offset
Definition: ps.h:92
mark_ref
static void mark_ref(HEVCFrame *frame, int flag)
Definition: refs.c:416
RefPicList::nb_refs
int nb_refs
Definition: hevcdec.h:196
HEVCSPS::log2_max_poc_lsb
unsigned int log2_max_poc_lsb
Definition: ps.h:267
progressframe.h
refstruct.h
ff_frame_new_side_data_from_buf
int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:2137
AV_STEREO3D_FRAMESEQUENCE
@ AV_STEREO3D_FRAMESEQUENCE
Views are alternated temporally.
Definition: stereo3d.h:89
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
HEVCLayerContext::rpl_tab_pool
struct FFRefStructPool * rpl_tab_pool
Definition: hevcdec.h:484
unref_missing_refs
static void unref_missing_refs(HEVCLayerContext *l)
Definition: refs.c:216
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ff_refstruct_ref_c
const void * ff_refstruct_ref_c(const void *obj)
Analog of ff_refstruct_ref(), but for constant objects.
Definition: refstruct.c:149
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:447
stereo3d.h
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:2251
HEVCLayerContext::cur_frame
HEVCFrame * cur_frame
Definition: hevcdec.h:451
s
#define s(width, name)
Definition: cbs_vp9.c:198
HEVCSPS::height
int height
Definition: ps.h:348
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:431
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
ff_progress_frame_unref
void ff_progress_frame_unref(ProgressFrame *f)
Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...
Definition: decode.c:1876
decode.h
hevc.h
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:353
ff_hevc_slice_rpl
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: refs.c:302
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:193
HEVCLayerContext::tab_mvf_pool
struct FFRefStructPool * tab_mvf_pool
Definition: hevcdec.h:483
HEVCWindow::top_offset
unsigned int top_offset
Definition: ps.h:94
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:243
ShortTermRPS::num_delta_pocs
uint8_t num_delta_pocs
Definition: ps.h:81
if
if(ret)
Definition: filter_design.txt:179
AV_PICTURE_STRUCTURE_BOTTOM_FIELD
@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD
coded as bottom field
Definition: avcodec.h:2744
IS_BLA
#define IS_BLA(s)
Definition: hevcdec.h:77
NULL
#define NULL
Definition: coverity.c:32
LongTermRPS::poc
int poc[32]
Definition: hevcdec.h:186
AV_PICTURE_STRUCTURE_TOP_FIELD
@ AV_PICTURE_STRUCTURE_TOP_FIELD
coded as top field
Definition: avcodec.h:2743
generate_missing_ref
static HEVCFrame * generate_missing_ref(HEVCContext *s, HEVCLayerContext *l, int poc)
Definition: refs.c:422
L0
#define L0
Definition: hevcdec.h:58
list
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
Definition: filter_design.txt:25
LongTermRPS::poc_msb_present
uint8_t poc_msb_present[32]
Definition: hevcdec.h:187
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
INTER_LAYER0
@ INTER_LAYER0
Definition: hevcdec.h:87
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:423
SliceHeader::nb_refs
unsigned int nb_refs[2]
Definition: hevcdec.h:235
ff_hevc_set_new_ref
int ff_hevc_set_new_ref(HEVCContext *s, HEVCLayerContext *l, int poc)
Definition: refs.c:175
ShortTermRPS::used
uint32_t used
Definition: ps.h:77
ff_hevc_output_frames
int ff_hevc_output_frames(HEVCContext *s, unsigned layers_active_decode, unsigned layers_active_output, unsigned max_output, unsigned max_dpb, int discard)
Find frames in the DPB that are ready for output and either write them to the output FIFO or drop the...
Definition: refs.c:226
LongTermRPS::used
uint8_t used[32]
Definition: hevcdec.h:188
ff_hevc_unref_frame
void ff_hevc_unref_frame(HEVCFrame *frame, int flags)
Definition: refs.c:34
HEVCSEITDRDI
Definition: sei.h:82
ST_FOLL
@ ST_FOLL
Definition: hevcdec.h:84
add_candidate_ref
static int add_candidate_ref(HEVCContext *s, HEVCLayerContext *l, RefPicList *list, int poc, int ref_flag, uint8_t use_msb)
Definition: refs.c:456
f
f
Definition: af_crystalizer.c:122
HEVCSPS::vps
const HEVCVPS * vps
RefStruct reference.
Definition: ps.h:368
ff_progress_frame_alloc
int ff_progress_frame_alloc(AVCodecContext *avctx, ProgressFrame *f)
This function allocates ProgressFrame.f May be called before ff_progress_frame_get_buffer() in the ca...
Definition: decode.c:1834
hevcdec.h
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
HEVCSEITDRDI::right_view_id
uint16_t right_view_id[32]
Definition: sei.h:88
HEVCSEITDRDI::left_view_id
uint16_t left_view_id[32]
Definition: sei.h:87
AV_FRAME_DATA_LCEVC
@ AV_FRAME_DATA_LCEVC
Raw LCEVC payload data, as a uint8_t array, with NAL emulation bytes intact.
Definition: frame.h:236
ff_hevc_clear_refs
void ff_hevc_clear_refs(HEVCLayerContext *l)
Mark all frames in DPB as unused for reference.
Definition: refs.c:64
SliceHeader::collocated_ref_idx
unsigned int collocated_ref_idx
Definition: hevcdec.h:245
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
HEVC_FRAME_FLAG_OUTPUT
#define HEVC_FRAME_FLAG_OUTPUT
Definition: hevcdec.h:352
HEVC_FRAME_FLAG_UNAVAILABLE
#define HEVC_FRAME_FLAG_UNAVAILABLE
Definition: hevcdec.h:355
HEVCSPS::hshift
int hshift[3]
Definition: ps.h:360
AV_FRAME_DATA_VIEW_ID
@ AV_FRAME_DATA_VIEW_ID
This side data must be associated with a video frame.
Definition: frame.h:245
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1604
flag
#define flag(name)
Definition: cbs_av1.c:474
SliceHeader
Definition: hevcdec.h:203
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
HEVCFrame
Definition: hevcdec.h:357
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:122
init_slice_rpl
static int init_slice_rpl(HEVCContext *s)
Definition: refs.c:284
HEVCLayerContext
Definition: hevcdec.h:449
RefPicList::list
int list[HEVC_MAX_REFS]
Definition: hevcdec.h:194
HEVCSEITDRDI::num_ref_displays
uint8_t num_ref_displays
Definition: sei.h:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
HEVCSPS::width
int width
Definition: ps.h:347
SliceHeader::list_entry_lx
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:229
HEVCFrame::poc
int poc
Definition: hevcdec.h:370
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:648
SliceHeader::short_term_rps
const ShortTermRPS * short_term_rps
Definition: hevcdec.h:226
HEVCLayerContext::sps
const HEVCSPS * sps
Definition: hevcdec.h:453
ret
ret
Definition: filter_design.txt:187
ff_hevc_get_ref_list
const RefPicList * ff_hevc_get_ref_list(const HEVCFrame *ref, int x0, int y0)
Definition: refs.c:54
frame
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
Definition: filter_design.txt:264
ST_CURR_BEF
@ ST_CURR_BEF
Definition: hevcdec.h:82
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
LongTermRPS
Definition: hevcdec.h:185
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:211
LT_CURR
@ LT_CURR
Definition: hevcdec.h:85
HEVC_NAL_CRA_NUT
@ HEVC_NAL_CRA_NUT
Definition: hevc.h:50
av_frame_side_data_new
AVFrameSideData * av_frame_side_data_new(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, size_t size, unsigned int flags)
Add new side data entry to an array.
Definition: frame.c:837
NB_RPS_TYPE
@ NB_RPS_TYPE
Definition: hevcdec.h:89
HEVCContext
Definition: hevcdec.h:487
HEVCLayerContext::DPB
HEVCFrame DPB[32]
Definition: hevcdec.h:450
HEVCSPS::ctb_height
int ctb_height
Definition: ps.h:350
SliceHeader::rpl_modification_flag
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:231
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
HEVCWindow::right_offset
unsigned int right_offset
Definition: ps.h:93
alloc_frame
static HEVCFrame * alloc_frame(HEVCContext *s, HEVCLayerContext *l)
Definition: refs.c:82
ShortTermRPS
Definition: ps.h:75
SliceHeader::inter_layer_pred
uint8_t inter_layer_pred
RPS coded in the slice header itself is stored here.
Definition: hevcdec.h:220
HEVCSPS::ctb_width
int ctb_width
Definition: ps.h:349
mem.h
HEVCSPS::vshift
int vshift[3]
Definition: ps.h:361
HEVCVPS
Definition: ps.h:171
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:54
HEVCSPS
Definition: ps.h:252
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
HEVCSPS::pixel_shift
int pixel_shift
Definition: ps.h:264
HEVCPPS
Definition: ps.h:371
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:83
AVStereo3D::view
enum AVStereo3DView view
Determines which views are packed.
Definition: stereo3d.h:217
LongTermRPS::nb_refs
uint8_t nb_refs
Definition: hevcdec.h:189
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ShortTermRPS::delta_poc
int32_t delta_poc[32]
Definition: ps.h:76
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
RefPicList::isLongTerm
int isLongTerm[HEVC_MAX_REFS]
Definition: hevcdec.h:195
ff_hevc_frame_nb_refs
int ff_hevc_frame_nb_refs(const SliceHeader *sh, const HEVCPPS *pps, unsigned layer_idx)
Get the number of candidate references for the current frame.
Definition: refs.c:559
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
SliceHeader::long_term_rps
LongTermRPS long_term_rps
Definition: hevcdec.h:228
INTER_LAYER1
@ INTER_LAYER1
Definition: hevcdec.h:88
ff_refstruct_pool_get
void * ff_refstruct_pool_get(FFRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:368