FFmpeg
h264_refs.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... reference picture handling
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * H.264 / AVC / MPEG-4 part10 reference picture handling.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27 
28 #include <inttypes.h>
29 
30 #include "libavutil/avassert.h"
31 #include "internal.h"
32 #include "avcodec.h"
33 #include "h264.h"
34 #include "h264dec.h"
35 #include "golomb.h"
36 #include "mpegutils.h"
37 
38 #include <assert.h>
39 
40 static void pic_as_field(H264Ref *pic, const int parity)
41 {
42  int i;
43  for (i = 0; i < FF_ARRAY_ELEMS(pic->data); ++i) {
45  pic->data[i] += pic->linesize[i];
46  pic->reference = parity;
47  pic->linesize[i] *= 2;
48  }
49  pic->poc = pic->parent->field_poc[parity == PICT_BOTTOM_FIELD];
50 }
51 
53 {
54  memcpy(dst->data, src->f->data, sizeof(dst->data));
55  memcpy(dst->linesize, src->f->linesize, sizeof(dst->linesize));
56  dst->reference = src->reference;
57  dst->poc = src->poc;
58  dst->pic_id = src->pic_id;
59  dst->parent = src;
60 }
61 
62 static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add)
63 {
64  int match = !!(src->reference & parity);
65 
66  if (match) {
67  ref_from_h264pic(dest, src);
68  if (parity != PICT_FRAME) {
69  pic_as_field(dest, parity);
70  dest->pic_id *= 2;
71  dest->pic_id += id_add;
72  }
73  }
74 
75  return match;
76 }
77 
78 static int build_def_list(H264Ref *def, int def_len,
79  H264Picture * const *in, int len, int is_long, int sel)
80 {
81  int i[2] = { 0 };
82  int index = 0;
83 
84  while (i[0] < len || i[1] < len) {
85  while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel)))
86  i[0]++;
87  while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3))))
88  i[1]++;
89  if (i[0] < len) {
90  av_assert0(index < def_len);
91  in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num;
92  split_field_copy(&def[index++], in[i[0]++], sel, 1);
93  }
94  if (i[1] < len) {
95  av_assert0(index < def_len);
96  in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num;
97  split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0);
98  }
99  }
100 
101  return index;
102 }
103 
104 static int add_sorted(H264Picture **sorted, H264Picture * const *src,
105  int len, int limit, int dir)
106 {
107  int i, best_poc;
108  int out_i = 0;
109 
110  for (;;) {
111  best_poc = dir ? INT_MIN : INT_MAX;
112 
113  for (i = 0; i < len; i++) {
114  const int poc = src[i]->poc;
115  if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) {
116  best_poc = poc;
117  sorted[out_i] = src[i];
118  }
119  }
120  if (best_poc == (dir ? INT_MIN : INT_MAX))
121  break;
122  limit = sorted[out_i++]->poc - dir;
123  }
124  return out_i;
125 }
126 
127 static int mismatches_ref(const H264Context *h, const H264Picture *pic)
128 {
129  const AVFrame *f = pic->f;
130  return (h->cur_pic_ptr->f->width != f->width ||
131  h->cur_pic_ptr->f->height != f->height ||
132  h->cur_pic_ptr->f->format != f->format);
133 }
134 
136 {
137  int i, len;
138  int j;
139 
140  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
141  H264Picture *sorted[32];
142  int cur_poc, list;
143  int lens[2];
144 
145  if (FIELD_PICTURE(h))
146  cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD];
147  else
148  cur_poc = h->cur_pic_ptr->poc;
149 
150  for (list = 0; list < 2; list++) {
151  len = add_sorted(sorted, h->short_ref, h->short_ref_count, cur_poc, 1 ^ list);
152  len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list);
153  av_assert0(len <= 32);
154 
156  sorted, len, 0, h->picture_structure);
157  len += build_def_list(sl->ref_list[list] + len,
158  FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
159  h->long_ref, 16, 1, h->picture_structure);
160  av_assert0(len <= 32);
161 
162  if (len < sl->ref_count[list])
163  memset(&sl->ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len));
164  lens[list] = len;
165  }
166 
167  if (lens[0] == lens[1] && lens[1] > 1) {
168  for (i = 0; i < lens[0] &&
169  sl->ref_list[0][i].parent->f->buf[0]->buffer ==
170  sl->ref_list[1][i].parent->f->buf[0]->buffer; i++);
171  if (i == lens[0]) {
172  FFSWAP(H264Ref, sl->ref_list[1][0], sl->ref_list[1][1]);
173  }
174  }
175  } else {
177  h->short_ref, h->short_ref_count, 0, h->picture_structure);
178  len += build_def_list(sl->ref_list[0] + len,
179  FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
180  h-> long_ref, 16, 1, h->picture_structure);
181  av_assert0(len <= 32);
182 
183  if (len < sl->ref_count[0])
184  memset(&sl->ref_list[0][len], 0, sizeof(H264Ref) * (sl->ref_count[0] - len));
185  }
186 #ifdef TRACE
187  for (i = 0; i < sl->ref_count[0]; i++) {
188  ff_tlog(h->avctx, "List0: %s fn:%d 0x%p\n",
189  (sl->ref_list[0][i].parent ? (sl->ref_list[0][i].parent->long_ref ? "LT" : "ST") : "??"),
190  sl->ref_list[0][i].pic_id,
191  sl->ref_list[0][i].data[0]);
192  }
193  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
194  for (i = 0; i < sl->ref_count[1]; i++) {
195  ff_tlog(h->avctx, "List1: %s fn:%d 0x%p\n",
196  (sl->ref_list[1][i].parent ? (sl->ref_list[1][i].parent->long_ref ? "LT" : "ST") : "??"),
197  sl->ref_list[1][i].pic_id,
198  sl->ref_list[1][i].data[0]);
199  }
200  }
201 #endif
202 
203  for (j = 0; j<1+(sl->slice_type_nos == AV_PICTURE_TYPE_B); j++) {
204  for (i = 0; i < sl->ref_count[j]; i++) {
205  if (sl->ref_list[j][i].parent) {
206  if (mismatches_ref(h, sl->ref_list[j][i].parent)) {
207  av_log(h->avctx, AV_LOG_ERROR, "Discarding mismatching reference\n");
208  memset(&sl->ref_list[j][i], 0, sizeof(sl->ref_list[j][i]));
209  }
210  }
211  }
212  }
213  for (i = 0; i < sl->list_count; i++)
214  h->default_ref[i] = sl->ref_list[i][0];
215 }
216 
217 /**
218  * print short term list
219  */
220 static void print_short_term(const H264Context *h)
221 {
222  uint32_t i;
223  if (h->avctx->debug & FF_DEBUG_MMCO) {
224  av_log(h->avctx, AV_LOG_DEBUG, "short term list:\n");
225  for (i = 0; i < h->short_ref_count; i++) {
226  H264Picture *pic = h->short_ref[i];
227  av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",
228  i, pic->frame_num, pic->poc, pic->f->data[0]);
229  }
230  }
231 }
232 
233 /**
234  * print long term list
235  */
236 static void print_long_term(const H264Context *h)
237 {
238  uint32_t i;
239  if (h->avctx->debug & FF_DEBUG_MMCO) {
240  av_log(h->avctx, AV_LOG_DEBUG, "long term list:\n");
241  for (i = 0; i < 16; i++) {
242  H264Picture *pic = h->long_ref[i];
243  if (pic) {
244  av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",
245  i, pic->frame_num, pic->poc, pic->f->data[0]);
246  }
247  }
248  }
249 }
250 
251 /**
252  * Extract structure information about the picture described by pic_num in
253  * the current decoding context (frame or field). Note that pic_num is
254  * picture number without wrapping (so, 0<=pic_num<max_pic_num).
255  * @param pic_num picture number for which to extract structure information
256  * @param structure one of PICT_XXX describing structure of picture
257  * with pic_num
258  * @return frame number (short term) or long term index of picture
259  * described by pic_num
260  */
261 static int pic_num_extract(const H264Context *h, int pic_num, int *structure)
262 {
263  *structure = h->picture_structure;
264  if (FIELD_PICTURE(h)) {
265  if (!(pic_num & 1))
266  /* opposite field */
267  *structure ^= PICT_FRAME;
268  pic_num >>= 1;
269  }
270 
271  return pic_num;
272 }
273 
275 {
276  int list, i, j;
277  for (list = 0; list < sl->list_count; list++) {
278  for (i = 0; i < sl->ref_count[list]; i++) {
279  H264Ref *frame = &sl->ref_list[list][i];
280  H264Ref *field = &sl->ref_list[list][16 + 2 * i];
281 
282  field[0] = *frame;
283 
284  for (j = 0; j < 3; j++)
285  field[0].linesize[j] <<= 1;
286  field[0].reference = PICT_TOP_FIELD;
287  field[0].poc = field[0].parent->field_poc[0];
288 
289  field[1] = field[0];
290 
291  for (j = 0; j < 3; j++)
292  field[1].data[j] += frame->parent->f->linesize[j];
293  field[1].reference = PICT_BOTTOM_FIELD;
294  field[1].poc = field[1].parent->field_poc[1];
295  }
296  }
297 }
298 
300 {
301  int list, index, pic_structure;
302 
305 
307 
308  for (list = 0; list < sl->list_count; list++) {
309  int pred = sl->curr_pic_num;
310 
311  for (index = 0; index < sl->nb_ref_modifications[list]; index++) {
312  unsigned int modification_of_pic_nums_idc = sl->ref_modifications[list][index].op;
313  unsigned int val = sl->ref_modifications[list][index].val;
314  unsigned int pic_id;
315  int i;
316  H264Picture *ref = NULL;
317 
318  switch (modification_of_pic_nums_idc) {
319  case 0:
320  case 1: {
321  const unsigned int abs_diff_pic_num = val + 1;
322  int frame_num;
323 
324  if (abs_diff_pic_num > sl->max_pic_num) {
325  av_log(h->avctx, AV_LOG_ERROR,
326  "abs_diff_pic_num overflow\n");
327  return AVERROR_INVALIDDATA;
328  }
329 
330  if (modification_of_pic_nums_idc == 0)
331  pred -= abs_diff_pic_num;
332  else
333  pred += abs_diff_pic_num;
334  pred &= sl->max_pic_num - 1;
335 
336  frame_num = pic_num_extract(h, pred, &pic_structure);
337 
338  for (i = h->short_ref_count - 1; i >= 0; i--) {
339  ref = h->short_ref[i];
340  assert(ref->reference);
341  assert(!ref->long_ref);
342  if (ref->frame_num == frame_num &&
343  (ref->reference & pic_structure))
344  break;
345  }
346  if (i >= 0)
347  ref->pic_id = pred;
348  break;
349  }
350  case 2: {
351  int long_idx;
352  pic_id = val; // long_term_pic_idx
353 
354  long_idx = pic_num_extract(h, pic_id, &pic_structure);
355 
356  if (long_idx > 31U) {
357  av_log(h->avctx, AV_LOG_ERROR,
358  "long_term_pic_idx overflow\n");
359  return AVERROR_INVALIDDATA;
360  }
361  ref = h->long_ref[long_idx];
362  assert(!(ref && !ref->reference));
363  if (ref && (ref->reference & pic_structure)) {
364  ref->pic_id = pic_id;
365  assert(ref->long_ref);
366  i = 0;
367  } else {
368  i = -1;
369  }
370  break;
371  }
372  default:
373  av_assert0(0);
374  }
375 
376  if (i < 0 || mismatches_ref(h, ref)) {
377  av_log(h->avctx, AV_LOG_ERROR,
378  i < 0 ? "reference picture missing during reorder\n" :
379  "mismatching reference\n"
380  );
381  memset(&sl->ref_list[list][index], 0, sizeof(sl->ref_list[0][0])); // FIXME
382  } else {
383  for (i = index; i + 1 < sl->ref_count[list]; i++) {
384  if (sl->ref_list[list][i].parent &&
385  ref->long_ref == sl->ref_list[list][i].parent->long_ref &&
386  ref->pic_id == sl->ref_list[list][i].pic_id)
387  break;
388  }
389  for (; i > index; i--) {
390  sl->ref_list[list][i] = sl->ref_list[list][i - 1];
391  }
393  if (FIELD_PICTURE(h)) {
394  pic_as_field(&sl->ref_list[list][index], pic_structure);
395  }
396  }
397  }
398  }
399  for (list = 0; list < sl->list_count; list++) {
400  for (index = 0; index < sl->ref_count[list]; index++) {
401  if ( !sl->ref_list[list][index].parent
402  || (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) {
403  int i;
404  av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref[list].poc);
405  for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
406  h->last_pocs[i] = INT_MIN;
407  if (h->default_ref[list].parent
408  && !(!FIELD_PICTURE(h) && (h->default_ref[list].reference&3) != 3))
409  sl->ref_list[list][index] = h->default_ref[list];
410  else
411  return -1;
412  }
414  }
415  }
416 
417  if (FRAME_MBAFF(h))
419 
420  return 0;
421 }
422 
424 {
425  int list, index;
426 
427  sl->nb_ref_modifications[0] = 0;
428  sl->nb_ref_modifications[1] = 0;
429 
430  for (list = 0; list < sl->list_count; list++) {
431  if (!get_bits1(&sl->gb)) // ref_pic_list_modification_flag_l[01]
432  continue;
433 
434  for (index = 0; ; index++) {
435  unsigned int op = get_ue_golomb_31(&sl->gb);
436 
437  if (op == 3)
438  break;
439 
440  if (index >= sl->ref_count[list]) {
441  av_log(logctx, AV_LOG_ERROR, "reference count overflow\n");
442  return AVERROR_INVALIDDATA;
443  } else if (op > 2) {
444  av_log(logctx, AV_LOG_ERROR,
445  "illegal modification_of_pic_nums_idc %u\n",
446  op);
447  return AVERROR_INVALIDDATA;
448  }
450  sl->ref_modifications[list][index].op = op;
451  sl->nb_ref_modifications[list]++;
452  }
453  }
454 
455  return 0;
456 }
457 
458 /**
459  * Mark a picture as no longer needed for reference. The refmask
460  * argument allows unreferencing of individual fields or the whole frame.
461  * If the picture becomes entirely unreferenced, but is being held for
462  * display purposes, it is marked as such.
463  * @param refmask mask of fields to unreference; the mask is bitwise
464  * anded with the reference marking of pic
465  * @return non-zero if pic becomes entirely unreferenced (except possibly
466  * for display purposes) zero if one of the fields remains in
467  * reference
468  */
469 static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
470 {
471  int i;
472  if (pic->reference &= refmask) {
473  return 0;
474  } else {
475  for(i = 0; h->delayed_pic[i]; i++)
476  if(pic == h->delayed_pic[i]){
477  pic->reference = DELAYED_PIC_REF;
478  break;
479  }
480  return 1;
481  }
482 }
483 
484 /**
485  * Find a H264Picture in the short term reference list by frame number.
486  * @param frame_num frame number to search for
487  * @param idx the index into h->short_ref where returned picture is found
488  * undefined if no picture found.
489  * @return pointer to the found picture, or NULL if no pic with the provided
490  * frame number is found
491  */
492 static H264Picture *find_short(H264Context *h, int frame_num, int *idx)
493 {
494  int i;
495 
496  for (i = 0; i < h->short_ref_count; i++) {
497  H264Picture *pic = h->short_ref[i];
498  if (h->avctx->debug & FF_DEBUG_MMCO)
499  av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
500  if (pic->frame_num == frame_num) {
501  *idx = i;
502  return pic;
503  }
504  }
505  return NULL;
506 }
507 
508 /**
509  * Remove a picture from the short term reference list by its index in
510  * that list. This does no checking on the provided index; it is assumed
511  * to be valid. Other list entries are shifted down.
512  * @param i index into h->short_ref of picture to remove.
513  */
515 {
516  assert(i >= 0 && i < h->short_ref_count);
517  h->short_ref[i] = NULL;
518  if (--h->short_ref_count)
519  memmove(&h->short_ref[i], &h->short_ref[i + 1],
520  (h->short_ref_count - i) * sizeof(H264Picture*));
521 }
522 
523 /**
524  * @return the removed picture or NULL if an error occurs
525  */
526 static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask)
527 {
528  H264Picture *pic;
529  int i;
530 
531  if (h->avctx->debug & FF_DEBUG_MMCO)
532  av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
533 
534  pic = find_short(h, frame_num, &i);
535  if (pic) {
536  if (unreference_pic(h, pic, ref_mask))
538  }
539 
540  return pic;
541 }
542 
543 /**
544  * Remove a picture from the long term reference list by its index in
545  * that list.
546  * @return the removed picture or NULL if an error occurs
547  */
548 static H264Picture *remove_long(H264Context *h, int i, int ref_mask)
549 {
550  H264Picture *pic;
551 
552  pic = h->long_ref[i];
553  if (pic) {
554  if (unreference_pic(h, pic, ref_mask)) {
555  assert(h->long_ref[i]->long_ref == 1);
556  h->long_ref[i]->long_ref = 0;
557  h->long_ref[i] = NULL;
558  h->long_ref_count--;
559  }
560  }
561 
562  return pic;
563 }
564 
566 {
567  int i;
568 
569  for (i = 0; i < 16; i++) {
570  remove_long(h, i, 0);
571  }
572  assert(h->long_ref_count == 0);
573 
574  if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
575  ff_h264_unref_picture(h, &h->last_pic_for_ec);
576  ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
577  }
578 
579  for (i = 0; i < h->short_ref_count; i++) {
580  unreference_pic(h, h->short_ref[i], 0);
581  h->short_ref[i] = NULL;
582  }
583  h->short_ref_count = 0;
584 
585  memset(h->default_ref, 0, sizeof(h->default_ref));
586 }
587 
589 {
590  MMCO *mmco = h->mmco;
591  int nb_mmco = 0;
592 
593  if (h->short_ref_count &&
594  h->long_ref_count + h->short_ref_count >= h->ps.sps->ref_frame_count &&
595  !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
596  mmco[0].opcode = MMCO_SHORT2UNUSED;
597  mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
598  nb_mmco = 1;
599  if (FIELD_PICTURE(h)) {
600  mmco[0].short_pic_num *= 2;
601  mmco[1].opcode = MMCO_SHORT2UNUSED;
602  mmco[1].short_pic_num = mmco[0].short_pic_num + 1;
603  nb_mmco = 2;
604  }
605  }
606 
607  h->nb_mmco = nb_mmco;
608 }
609 
611 {
612  MMCO *mmco = h->mmco;
613  int mmco_count;
614  int i, av_uninit(j);
615  int pps_ref_count[2] = {0};
616  int current_ref_assigned = 0, err = 0;
617  H264Picture *av_uninit(pic);
618 
619  if (!h->ps.sps) {
620  av_log(h->avctx, AV_LOG_ERROR, "SPS is unset\n");
621  err = AVERROR_INVALIDDATA;
622  goto out;
623  }
624 
625  if (!h->explicit_ref_marking)
627  mmco_count = h->nb_mmco;
628 
629  if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)
630  av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");
631 
632  for (i = 0; i < mmco_count; i++) {
633  int av_uninit(structure), av_uninit(frame_num);
634  if (h->avctx->debug & FF_DEBUG_MMCO)
635  av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,
636  h->mmco[i].short_pic_num, h->mmco[i].long_arg);
637 
638  if (mmco[i].opcode == MMCO_SHORT2UNUSED ||
639  mmco[i].opcode == MMCO_SHORT2LONG) {
640  frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
641  pic = find_short(h, frame_num, &j);
642  if (!pic) {
643  if (mmco[i].opcode != MMCO_SHORT2LONG ||
644  !h->long_ref[mmco[i].long_arg] ||
645  h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
646  av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n");
647  err = AVERROR_INVALIDDATA;
648  }
649  continue;
650  }
651  }
652 
653  switch (mmco[i].opcode) {
654  case MMCO_SHORT2UNUSED:
655  if (h->avctx->debug & FF_DEBUG_MMCO)
656  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",
657  h->mmco[i].short_pic_num, h->short_ref_count);
658  remove_short(h, frame_num, structure ^ PICT_FRAME);
659  break;
660  case MMCO_SHORT2LONG:
661  if (h->long_ref[mmco[i].long_arg] != pic)
662  remove_long(h, mmco[i].long_arg, 0);
663 
665  h->long_ref[ mmco[i].long_arg ] = pic;
666  if (h->long_ref[mmco[i].long_arg]) {
667  h->long_ref[mmco[i].long_arg]->long_ref = 1;
668  h->long_ref_count++;
669  }
670  break;
671  case MMCO_LONG2UNUSED:
672  j = pic_num_extract(h, mmco[i].long_arg, &structure);
673  pic = h->long_ref[j];
674  if (pic) {
675  remove_long(h, j, structure ^ PICT_FRAME);
676  } else if (h->avctx->debug & FF_DEBUG_MMCO)
677  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
678  break;
679  case MMCO_LONG:
680  // Comment below left from previous code as it is an interesting note.
681  /* First field in pair is in short term list or
682  * at a different long term index.
683  * This is not allowed; see 7.4.3.3, notes 2 and 3.
684  * Report the problem and keep the pair where it is,
685  * and mark this field valid.
686  */
687  if (h->short_ref[0] == h->cur_pic_ptr) {
688  av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n");
690  }
691 
692  /* make sure the current picture is not already assigned as a long ref */
693  if (h->cur_pic_ptr->long_ref) {
694  for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) {
695  if (h->long_ref[j] == h->cur_pic_ptr) {
696  if (j != mmco[i].long_arg)
697  av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");
698  remove_long(h, j, 0);
699  }
700  }
701  }
702 
703  if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
704  av_assert0(!h->cur_pic_ptr->long_ref);
705  remove_long(h, mmco[i].long_arg, 0);
706 
707  h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr;
708  h->long_ref[mmco[i].long_arg]->long_ref = 1;
709  h->long_ref_count++;
710  }
711 
712  h->cur_pic_ptr->reference |= h->picture_structure;
713  current_ref_assigned = 1;
714  break;
715  case MMCO_SET_MAX_LONG:
716  assert(mmco[i].long_arg <= 16);
717  // just remove the long term which index is greater than new max
718  for (j = mmco[i].long_arg; j < 16; j++) {
719  remove_long(h, j, 0);
720  }
721  break;
722  case MMCO_RESET:
723  while (h->short_ref_count) {
724  remove_short(h, h->short_ref[0]->frame_num, 0);
725  }
726  for (j = 0; j < 16; j++) {
727  remove_long(h, j, 0);
728  }
729  h->poc.frame_num = h->cur_pic_ptr->frame_num = 0;
730  h->mmco_reset = 1;
731  h->cur_pic_ptr->mmco_reset = 1;
732  for (j = 0; j < MAX_DELAYED_PIC_COUNT; j++)
733  h->last_pocs[j] = INT_MIN;
734  break;
735  default: assert(0);
736  }
737  }
738 
739  if (!current_ref_assigned) {
740  /* Second field of complementary field pair; the first field of
741  * which is already referenced. If short referenced, it
742  * should be first entry in short_ref. If not, it must exist
743  * in long_ref; trying to put it on the short list here is an
744  * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
745  */
746  if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
747  /* Just mark the second field valid */
748  h->cur_pic_ptr->reference |= h->picture_structure;
749  } else if (h->cur_pic_ptr->long_ref) {
750  av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
751  "assignment for second field "
752  "in complementary field pair "
753  "(first field is long term)\n");
754  err = AVERROR_INVALIDDATA;
755  } else {
756  pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);
757  if (pic) {
758  av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
759  err = AVERROR_INVALIDDATA;
760  }
761 
762  if (h->short_ref_count)
763  memmove(&h->short_ref[1], &h->short_ref[0],
764  h->short_ref_count * sizeof(H264Picture*));
765 
766  h->short_ref[0] = h->cur_pic_ptr;
767  h->short_ref_count++;
768  h->cur_pic_ptr->reference |= h->picture_structure;
769  }
770  }
771 
772  if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.sps->ref_frame_count, 1)) {
773 
774  /* We have too many reference frames, probably due to corrupted
775  * stream. Need to discard one frame. Prevents overrun of the
776  * short_ref and long_ref buffers.
777  */
778  av_log(h->avctx, AV_LOG_ERROR,
779  "number of reference frames (%d+%d) exceeds max (%d; probably "
780  "corrupt input), discarding one\n",
781  h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count);
782  err = AVERROR_INVALIDDATA;
783 
784  if (h->long_ref_count && !h->short_ref_count) {
785  for (i = 0; i < 16; ++i)
786  if (h->long_ref[i])
787  break;
788 
789  assert(i < 16);
790  remove_long(h, i, 0);
791  } else {
792  pic = h->short_ref[h->short_ref_count - 1];
793  remove_short(h, pic->frame_num, 0);
794  }
795  }
796 
797  for (i = 0; i<h->short_ref_count; i++) {
798  pic = h->short_ref[i];
799  if (pic->invalid_gap) {
800  int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num);
801  if (d > h->ps.sps->ref_frame_count)
802  remove_short(h, pic->frame_num, 0);
803  }
804  }
805 
808 
809  for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
810  if (h->ps.pps_list[i]) {
811  const PPS *pps = (const PPS *)h->ps.pps_list[i]->data;
812  pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]);
813  pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]);
814  }
815  }
816 
817  // Detect unmarked random access points
818  if ( err >= 0
819  && h->long_ref_count==0
820  && ( h->short_ref_count<=2
821  || pps_ref_count[0] <= 2 && pps_ref_count[1] <= 1 && h->avctx->has_b_frames
822  || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1)
823  && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point)
824  && h->cur_pic_ptr->f->pict_type == AV_PICTURE_TYPE_I){
825  h->cur_pic_ptr->recovered |= 1;
826  if(!h->avctx->has_b_frames)
827  h->frame_recovered |= FRAME_RECOVERED_SEI;
828  }
829 
830 out:
831  return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
832 }
833 
835  const H2645NAL *nal, void *logctx)
836 {
837  int i;
838  MMCO *mmco = sl->mmco;
839  int nb_mmco = 0;
840 
841  if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields
842  skip_bits1(gb); // broken_link
843  if (get_bits1(gb)) {
844  mmco[0].opcode = MMCO_LONG;
845  mmco[0].long_arg = 0;
846  nb_mmco = 1;
847  }
848  sl->explicit_ref_marking = 1;
849  } else {
851  if (sl->explicit_ref_marking) {
852  for (i = 0; i < MAX_MMCO_COUNT; i++) {
853  MMCOOpcode opcode = get_ue_golomb_31(gb);
854 
855  mmco[i].opcode = opcode;
856  if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
857  mmco[i].short_pic_num =
858  (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &
859  (sl->max_pic_num - 1);
860  }
861  if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
862  opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
863  unsigned int long_arg = get_ue_golomb_31(gb);
864  if (long_arg >= 32 ||
865  (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
866  long_arg == 16) &&
867  !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) {
868  av_log(logctx, AV_LOG_ERROR,
869  "illegal long ref in memory management control "
870  "operation %d\n", opcode);
871  return -1;
872  }
873  mmco[i].long_arg = long_arg;
874  }
875 
876  if (opcode > (unsigned) MMCO_LONG) {
877  av_log(logctx, AV_LOG_ERROR,
878  "illegal memory management control operation %d\n",
879  opcode);
880  return -1;
881  }
882  if (opcode == MMCO_END)
883  break;
884  }
885  nb_mmco = i;
886  }
887  }
888 
889  sl->nb_mmco = nb_mmco;
890 
891  return 0;
892 }
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:39
MMCO::opcode
MMCOOpcode opcode
Definition: h264dec.h:123
remove_short_at_index
static void remove_short_at_index(H264Context *h, int i)
Remove a picture from the short term reference list by its index in that list.
Definition: h264_refs.c:514
ff_h264_unref_picture
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
Definition: h264_picture.c:45
H264SliceContext::nb_ref_modifications
int nb_ref_modifications[2]
Definition: h264dec.h:276
MMCO::long_arg
int long_arg
index, pic_num, or num long refs depending on opcode
Definition: h264dec.h:125
MMCO_RESET
@ MMCO_RESET
Definition: h264dec.h:115
mismatches_ref
static int mismatches_ref(const H264Context *h, const H264Picture *pic)
Definition: h264_refs.c:127
H264SliceContext::max_pic_num
int max_pic_num
Definition: h264dec.h:331
H264SliceContext::nb_mmco
int nb_mmco
Definition: h264dec.h:323
print_long_term
static void print_long_term(const H264Context *h)
print long term list
Definition: h264_refs.c:236
H264Picture::poc
int poc
frame POC
Definition: h264dec.h:148
H264Picture::f
AVFrame * f
Definition: h264dec.h:129
out
FILE * out
Definition: movenc.c:54
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
split_field_copy
static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add)
Definition: h264_refs.c:62
H264Ref
Definition: h264dec.h:166
ref_from_h264pic
static void ref_from_h264pic(H264Ref *dst, H264Picture *src)
Definition: h264_refs.c:52
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
internal.h
H264SliceContext::mmco
MMCO mmco[MAX_MMCO_COUNT]
Definition: h264dec.h:322
H264SliceContext::val
uint32_t val
Definition: h264dec.h:274
H264Ref::pic_id
int pic_id
Definition: h264dec.h:172
data
const char data[16]
Definition: mxf.c:91
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:267
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:75
build_def_list
static int build_def_list(H264Ref *def, int def_len, H264Picture *const *in, int len, int is_long, int sel)
Definition: h264_refs.c:78
FRAME_RECOVERED_SEI
#define FRAME_RECOVERED_SEI
Sufficient number of frames have been decoded since a SEI recovery point, so all the following frames...
Definition: h264dec.h:522
ff_h264_decode_ref_pic_list_reordering
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
Definition: h264_refs.c:423
mpegutils.h
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:486
remove_long
static H264Picture * remove_long(H264Context *h, int i, int ref_mask)
Remove a picture from the long term reference list by its index in that list.
Definition: h264_refs.c:548
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
MMCO_LONG
@ MMCO_LONG
Definition: h264dec.h:116
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
H264Picture::frame_num
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:149
H264SliceContext
Definition: h264dec.h:177
golomb.h
exp golomb vlc stuff
U
#define U(x)
Definition: vp56_arith.h:37
GetBitContext
Definition: get_bits.h:61
src
#define src
Definition: vp8dsp.c:254
H264Ref::data
uint8_t * data[3]
Definition: h264dec.h:167
find_short
static H264Picture * find_short(H264Context *h, int frame_num, int *idx)
Find a H264Picture in the short term reference list by frame number.
Definition: h264_refs.c:492
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
H264SliceContext::ref_modifications
struct H264SliceContext::@90 ref_modifications[2][32]
op
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:78
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:74
ff_h264_execute_ref_pic_marking
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:610
ff_h264_decode_ref_pic_marking
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
Definition: h264_refs.c:834
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_h264_remove_all_refs
void ff_h264_remove_all_refs(H264Context *h)
Definition: h264_refs.c:565
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
H264Ref::parent
H264Picture * parent
Definition: h264dec.h:174
MMCO_SHORT2LONG
@ MMCO_SHORT2LONG
Definition: h264dec.h:113
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
FF_DEBUG_MMCO
#define FF_DEBUG_MMCO
Definition: avcodec.h:2666
pic_num_extract
static int pic_num_extract(const H264Context *h, int pic_num, int *structure)
Extract structure information about the picture described by pic_num in the current decoding context ...
Definition: h264_refs.c:261
MMCO::short_pic_num
int short_pic_num
pic_num without wrapping (pic_num & max_pic_num)
Definition: h264dec.h:124
f
#define f(width, name)
Definition: cbs_vp9.c:255
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
H264SliceContext::curr_pic_num
int curr_pic_num
Definition: h264dec.h:330
if
if(ret)
Definition: filter_design.txt:179
NULL
#define NULL
Definition: coverity.c:32
H264Ref::linesize
int linesize[3]
Definition: h264dec.h:168
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
PPS
Picture parameter set.
Definition: h264_ps.h:109
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
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2705
index
int index
Definition: gxfenc.c:89
print_short_term
static void print_short_term(const H264Context *h)
print short term list
Definition: h264_refs.c:220
DELAYED_PIC_REF
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output.
Definition: diracdec.c:67
H264Picture::reference
int reference
Definition: h264dec.h:160
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
MMCO_LONG2UNUSED
@ MMCO_LONG2UNUSED
Definition: h264dec.h:112
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
MAX_DELAYED_PIC_COUNT
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
MMCOOpcode
MMCOOpcode
Memory management control operation opcode.
Definition: h264dec.h:109
H2645NAL
Definition: h2645_parse.h:32
parity
mcdeint parity
Definition: vf_mcdeint.c:274
val
const char const char void * val
Definition: avisynth_c.h:863
H264SliceContext::explicit_ref_marking
int explicit_ref_marking
Definition: h264dec.h:324
MMCO_SET_MAX_LONG
@ MMCO_SET_MAX_LONG
Definition: h264dec.h:114
unreference_pic
static int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
Mark a picture as no longer needed for reference.
Definition: h264_refs.c:469
av_buffer_get_ref_count
int av_buffer_get_ref_count(const AVBufferRef *buf)
Definition: buffer.c:146
AVBufferRef::buffer
AVBuffer * buffer
Definition: buffer.h:82
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
H264SliceContext::slice_type_nos
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:184
FRAME_MBAFF
#define FRAME_MBAFF(h)
Definition: h264dec.h:73
h264dec.h
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
H264Context
H264Context.
Definition: h264dec.h:337
h264_initialise_ref_list
static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:135
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
len
int len
Definition: vorbis_enc_data.h:452
H264SliceContext::list_count
unsigned int list_count
Definition: h264dec.h:268
avcodec.h
av_uninit
#define av_uninit(x)
Definition: attributes.h:148
ff_h264_ref_picture
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
Definition: h264_picture.c:66
MMCO_END
@ MMCO_END
Definition: h264dec.h:110
pred
static const float pred[4]
Definition: siprdata.h:259
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
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
remove_short
static H264Picture * remove_short(H264Context *h, int frame_num, int ref_mask)
Definition: h264_refs.c:526
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
ff_h264_build_ref_list
int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:299
generate_sliding_window_mmcos
static void generate_sliding_window_mmcos(H264Context *h)
Definition: h264_refs.c:588
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:147
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
add_sorted
static int add_sorted(H264Picture **sorted, H264Picture *const *src, int len, int limit, int dir)
Definition: h264_refs.c:104
H264Picture
Definition: h264dec.h:128
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
h264_fill_mbaff_ref_list
static void h264_fill_mbaff_ref_list(H264SliceContext *sl)
Definition: h264_refs.c:274
H264SliceContext::ref_list
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:269
H264SliceContext::op
uint8_t op
Definition: h264dec.h:273
MMCO
Memory management control operation.
Definition: h264dec.h:122
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:105
MMCO_SHORT2UNUSED
@ MMCO_SHORT2UNUSED
Definition: h264dec.h:111
H264SliceContext::gb
GetBitContext gb
Definition: h264dec.h:179
pic_as_field
static void pic_as_field(H264Ref *pic, const int parity)
Definition: h264_refs.c:40
h264.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
h
h
Definition: vp9dsp_template.c:2038
MAX_MMCO_COUNT
#define MAX_MMCO_COUNT
Definition: h264dec.h:54
H264Ref::poc
int poc
Definition: h264dec.h:171
H264Picture::long_ref
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:154
H264Ref::reference
int reference
Definition: h264dec.h:170