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) {
44  if (parity == PICT_BOTTOM_FIELD)
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))
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 
155  len = build_def_list(sl->ref_list[list], FF_ARRAY_ELEMS(sl->ref_list[0]),
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 {
176  len = build_def_list(sl->ref_list[0], FF_ARRAY_ELEMS(sl->ref_list[0]),
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 
303  print_short_term(h);
304  print_long_term(h);
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) {
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) {
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) {
378  "reference picture missing during reorder\n");
379  memset(&sl->ref_list[list][index], 0, sizeof(sl->ref_list[0][0])); // FIXME
380  } else {
381  for (i = index; i + 1 < sl->ref_count[list]; i++) {
382  if (sl->ref_list[list][i].parent &&
383  ref->long_ref == sl->ref_list[list][i].parent->long_ref &&
384  ref->pic_id == sl->ref_list[list][i].pic_id)
385  break;
386  }
387  for (; i > index; i--) {
388  sl->ref_list[list][i] = sl->ref_list[list][i - 1];
389  }
390  ref_from_h264pic(&sl->ref_list[list][index], ref);
391  if (FIELD_PICTURE(h)) {
392  pic_as_field(&sl->ref_list[list][index], pic_structure);
393  }
394  }
395  }
396  }
397  for (list = 0; list < sl->list_count; list++) {
398  for (index = 0; index < sl->ref_count[list]; index++) {
399  if ( !sl->ref_list[list][index].parent
400  || (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) {
401  int i;
402  av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref[list].poc);
403  for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
404  h->last_pocs[i] = INT_MIN;
405  if (h->default_ref[list].parent
406  && !(!FIELD_PICTURE(h) && (h->default_ref[list].reference&3) != 3))
407  sl->ref_list[list][index] = h->default_ref[list];
408  else
409  return -1;
410  }
411  av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0);
412  }
413  }
414 
415  if (FRAME_MBAFF(h))
417 
418  return 0;
419 }
420 
422 {
423  int list, index;
424 
425  sl->nb_ref_modifications[0] = 0;
426  sl->nb_ref_modifications[1] = 0;
427 
428  for (list = 0; list < sl->list_count; list++) {
429  if (!get_bits1(&sl->gb)) // ref_pic_list_modification_flag_l[01]
430  continue;
431 
432  for (index = 0; ; index++) {
433  unsigned int op = get_ue_golomb_31(&sl->gb);
434 
435  if (op == 3)
436  break;
437 
438  if (index >= sl->ref_count[list]) {
439  av_log(logctx, AV_LOG_ERROR, "reference count overflow\n");
440  return AVERROR_INVALIDDATA;
441  } else if (op > 2) {
442  av_log(logctx, AV_LOG_ERROR,
443  "illegal modification_of_pic_nums_idc %u\n",
444  op);
445  return AVERROR_INVALIDDATA;
446  }
448  sl->ref_modifications[list][index].op = op;
449  sl->nb_ref_modifications[list]++;
450  }
451  }
452 
453  return 0;
454 }
455 
456 /**
457  * Mark a picture as no longer needed for reference. The refmask
458  * argument allows unreferencing of individual fields or the whole frame.
459  * If the picture becomes entirely unreferenced, but is being held for
460  * display purposes, it is marked as such.
461  * @param refmask mask of fields to unreference; the mask is bitwise
462  * anded with the reference marking of pic
463  * @return non-zero if pic becomes entirely unreferenced (except possibly
464  * for display purposes) zero if one of the fields remains in
465  * reference
466  */
467 static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
468 {
469  int i;
470  if (pic->reference &= refmask) {
471  return 0;
472  } else {
473  for(i = 0; h->delayed_pic[i]; i++)
474  if(pic == h->delayed_pic[i]){
475  pic->reference = DELAYED_PIC_REF;
476  break;
477  }
478  return 1;
479  }
480 }
481 
482 /**
483  * Find a H264Picture in the short term reference list by frame number.
484  * @param frame_num frame number to search for
485  * @param idx the index into h->short_ref where returned picture is found
486  * undefined if no picture found.
487  * @return pointer to the found picture, or NULL if no pic with the provided
488  * frame number is found
489  */
490 static H264Picture *find_short(H264Context *h, int frame_num, int *idx)
491 {
492  int i;
493 
494  for (i = 0; i < h->short_ref_count; i++) {
495  H264Picture *pic = h->short_ref[i];
496  if (h->avctx->debug & FF_DEBUG_MMCO)
497  av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
498  if (pic->frame_num == frame_num) {
499  *idx = i;
500  return pic;
501  }
502  }
503  return NULL;
504 }
505 
506 /**
507  * Remove a picture from the short term reference list by its index in
508  * that list. This does no checking on the provided index; it is assumed
509  * to be valid. Other list entries are shifted down.
510  * @param i index into h->short_ref of picture to remove.
511  */
513 {
514  assert(i >= 0 && i < h->short_ref_count);
515  h->short_ref[i] = NULL;
516  if (--h->short_ref_count)
517  memmove(&h->short_ref[i], &h->short_ref[i + 1],
518  (h->short_ref_count - i) * sizeof(H264Picture*));
519 }
520 
521 /**
522  * @return the removed picture or NULL if an error occurs
523  */
524 static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask)
525 {
526  H264Picture *pic;
527  int i;
528 
529  if (h->avctx->debug & FF_DEBUG_MMCO)
530  av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
531 
532  pic = find_short(h, frame_num, &i);
533  if (pic) {
534  if (unreference_pic(h, pic, ref_mask))
535  remove_short_at_index(h, i);
536  }
537 
538  return pic;
539 }
540 
541 /**
542  * Remove a picture from the long term reference list by its index in
543  * that list.
544  * @return the removed picture or NULL if an error occurs
545  */
546 static H264Picture *remove_long(H264Context *h, int i, int ref_mask)
547 {
548  H264Picture *pic;
549 
550  pic = h->long_ref[i];
551  if (pic) {
552  if (unreference_pic(h, pic, ref_mask)) {
553  assert(h->long_ref[i]->long_ref == 1);
554  h->long_ref[i]->long_ref = 0;
555  h->long_ref[i] = NULL;
556  h->long_ref_count--;
557  }
558  }
559 
560  return pic;
561 }
562 
564 {
565  int i;
566 
567  for (i = 0; i < 16; i++) {
568  remove_long(h, i, 0);
569  }
570  assert(h->long_ref_count == 0);
571 
572  if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
575  }
576 
577  for (i = 0; i < h->short_ref_count; i++) {
578  unreference_pic(h, h->short_ref[i], 0);
579  h->short_ref[i] = NULL;
580  }
581  h->short_ref_count = 0;
582 
583  memset(h->default_ref, 0, sizeof(h->default_ref));
584 }
585 
587 {
588  MMCO *mmco = h->mmco;
589  int nb_mmco = 0;
590 
591  if (h->short_ref_count &&
593  !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
594  mmco[0].opcode = MMCO_SHORT2UNUSED;
595  mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
596  nb_mmco = 1;
597  if (FIELD_PICTURE(h)) {
598  mmco[0].short_pic_num *= 2;
599  mmco[1].opcode = MMCO_SHORT2UNUSED;
600  mmco[1].short_pic_num = mmco[0].short_pic_num + 1;
601  nb_mmco = 2;
602  }
603  }
604 
605  h->nb_mmco = nb_mmco;
606 }
607 
609 {
610  MMCO *mmco = h->mmco;
611  int mmco_count;
612  int i, av_uninit(j);
613  int pps_ref_count[2] = {0};
614  int current_ref_assigned = 0, err = 0;
615  H264Picture *av_uninit(pic);
616 
617  if (!h->ps.sps) {
618  av_log(h->avctx, AV_LOG_ERROR, "SPS is unset\n");
619  err = AVERROR_INVALIDDATA;
620  goto out;
621  }
622 
623  if (!h->explicit_ref_marking)
625  mmco_count = h->nb_mmco;
626 
627  if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)
628  av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");
629 
630  for (i = 0; i < mmco_count; i++) {
631  int av_uninit(structure), av_uninit(frame_num);
632  if (h->avctx->debug & FF_DEBUG_MMCO)
633  av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,
634  h->mmco[i].short_pic_num, h->mmco[i].long_arg);
635 
636  if (mmco[i].opcode == MMCO_SHORT2UNUSED ||
637  mmco[i].opcode == MMCO_SHORT2LONG) {
638  frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
639  pic = find_short(h, frame_num, &j);
640  if (!pic) {
641  if (mmco[i].opcode != MMCO_SHORT2LONG ||
642  !h->long_ref[mmco[i].long_arg] ||
643  h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
644  av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n");
645  err = AVERROR_INVALIDDATA;
646  }
647  continue;
648  }
649  }
650 
651  switch (mmco[i].opcode) {
652  case MMCO_SHORT2UNUSED:
653  if (h->avctx->debug & FF_DEBUG_MMCO)
654  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",
656  remove_short(h, frame_num, structure ^ PICT_FRAME);
657  break;
658  case MMCO_SHORT2LONG:
659  if (h->long_ref[mmco[i].long_arg] != pic)
660  remove_long(h, mmco[i].long_arg, 0);
661 
662  remove_short_at_index(h, j);
663  h->long_ref[ mmco[i].long_arg ] = pic;
664  if (h->long_ref[mmco[i].long_arg]) {
665  h->long_ref[mmco[i].long_arg]->long_ref = 1;
666  h->long_ref_count++;
667  }
668  break;
669  case MMCO_LONG2UNUSED:
670  j = pic_num_extract(h, mmco[i].long_arg, &structure);
671  pic = h->long_ref[j];
672  if (pic) {
673  remove_long(h, j, structure ^ PICT_FRAME);
674  } else if (h->avctx->debug & FF_DEBUG_MMCO)
675  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
676  break;
677  case MMCO_LONG:
678  // Comment below left from previous code as it is an interesting note.
679  /* First field in pair is in short term list or
680  * at a different long term index.
681  * This is not allowed; see 7.4.3.3, notes 2 and 3.
682  * Report the problem and keep the pair where it is,
683  * and mark this field valid.
684  */
685  if (h->short_ref[0] == h->cur_pic_ptr) {
686  av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n");
687  remove_short_at_index(h, 0);
688  }
689 
690  /* make sure the current picture is not already assigned as a long ref */
691  if (h->cur_pic_ptr->long_ref) {
692  for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) {
693  if (h->long_ref[j] == h->cur_pic_ptr) {
694  if (j != mmco[i].long_arg)
695  av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");
696  remove_long(h, j, 0);
697  }
698  }
699  }
700 
701  if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
703  remove_long(h, mmco[i].long_arg, 0);
704 
705  h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr;
706  h->long_ref[mmco[i].long_arg]->long_ref = 1;
707  h->long_ref_count++;
708  }
709 
711  current_ref_assigned = 1;
712  break;
713  case MMCO_SET_MAX_LONG:
714  assert(mmco[i].long_arg <= 16);
715  // just remove the long term which index is greater than new max
716  for (j = mmco[i].long_arg; j < 16; j++) {
717  remove_long(h, j, 0);
718  }
719  break;
720  case MMCO_RESET:
721  while (h->short_ref_count) {
722  remove_short(h, h->short_ref[0]->frame_num, 0);
723  }
724  for (j = 0; j < 16; j++) {
725  remove_long(h, j, 0);
726  }
727  h->poc.frame_num = h->cur_pic_ptr->frame_num = 0;
728  h->mmco_reset = 1;
729  h->cur_pic_ptr->mmco_reset = 1;
730  for (j = 0; j < MAX_DELAYED_PIC_COUNT; j++)
731  h->last_pocs[j] = INT_MIN;
732  break;
733  default: assert(0);
734  }
735  }
736 
737  if (!current_ref_assigned) {
738  /* Second field of complementary field pair; the first field of
739  * which is already referenced. If short referenced, it
740  * should be first entry in short_ref. If not, it must exist
741  * in long_ref; trying to put it on the short list here is an
742  * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
743  */
744  if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
745  /* Just mark the second field valid */
747  } else if (h->cur_pic_ptr->long_ref) {
748  av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
749  "assignment for second field "
750  "in complementary field pair "
751  "(first field is long term)\n");
752  err = AVERROR_INVALIDDATA;
753  } else {
754  pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);
755  if (pic) {
756  av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
757  err = AVERROR_INVALIDDATA;
758  }
759 
760  if (h->short_ref_count)
761  memmove(&h->short_ref[1], &h->short_ref[0],
762  h->short_ref_count * sizeof(H264Picture*));
763 
764  h->short_ref[0] = h->cur_pic_ptr;
765  h->short_ref_count++;
767  }
768  }
769 
770  if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.sps->ref_frame_count, 1)) {
771 
772  /* We have too many reference frames, probably due to corrupted
773  * stream. Need to discard one frame. Prevents overrun of the
774  * short_ref and long_ref buffers.
775  */
777  "number of reference frames (%d+%d) exceeds max (%d; probably "
778  "corrupt input), discarding one\n",
780  err = AVERROR_INVALIDDATA;
781 
782  if (h->long_ref_count && !h->short_ref_count) {
783  for (i = 0; i < 16; ++i)
784  if (h->long_ref[i])
785  break;
786 
787  assert(i < 16);
788  remove_long(h, i, 0);
789  } else {
790  pic = h->short_ref[h->short_ref_count - 1];
791  remove_short(h, pic->frame_num, 0);
792  }
793  }
794 
795  for (i = 0; i<h->short_ref_count; i++) {
796  pic = h->short_ref[i];
797  if (pic->invalid_gap) {
798  int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num);
799  if (d > h->ps.sps->ref_frame_count)
800  remove_short(h, pic->frame_num, 0);
801  }
802  }
803 
804  print_short_term(h);
805  print_long_term(h);
806 
807  for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
808  if (h->ps.pps_list[i]) {
809  const PPS *pps = (const PPS *)h->ps.pps_list[i]->data;
810  pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]);
811  pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]);
812  }
813  }
814 
815  // Detect unmarked random access points
816  if ( err >= 0
817  && h->long_ref_count==0
818  && ( h->short_ref_count<=2
819  || pps_ref_count[0] <= 2 && pps_ref_count[1] <= 1 && h->avctx->has_b_frames
820  || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1)
821  && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point)
823  h->cur_pic_ptr->recovered |= 1;
824  if(!h->avctx->has_b_frames)
826  }
827 
828 out:
829  return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
830 }
831 
833  const H2645NAL *nal, void *logctx)
834 {
835  int i;
836  MMCO *mmco = sl->mmco;
837  int nb_mmco = 0;
838 
839  if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields
840  skip_bits1(gb); // broken_link
841  if (get_bits1(gb)) {
842  mmco[0].opcode = MMCO_LONG;
843  mmco[0].long_arg = 0;
844  nb_mmco = 1;
845  }
846  sl->explicit_ref_marking = 1;
847  } else {
849  if (sl->explicit_ref_marking) {
850  for (i = 0; i < MAX_MMCO_COUNT; i++) {
851  MMCOOpcode opcode = get_ue_golomb_31(gb);
852 
853  mmco[i].opcode = opcode;
854  if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
855  mmco[i].short_pic_num =
856  (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &
857  (sl->max_pic_num - 1);
858  }
859  if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
860  opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
861  unsigned int long_arg = get_ue_golomb_31(gb);
862  if (long_arg >= 32 ||
863  (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
864  long_arg == 16) &&
865  !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) {
866  av_log(logctx, AV_LOG_ERROR,
867  "illegal long ref in memory management control "
868  "operation %d\n", opcode);
869  return -1;
870  }
871  mmco[i].long_arg = long_arg;
872  }
873 
874  if (opcode > (unsigned) MMCO_LONG) {
875  av_log(logctx, AV_LOG_ERROR,
876  "illegal memory management control operation %d\n",
877  opcode);
878  return -1;
879  }
880  if (opcode == MMCO_END)
881  break;
882  }
883  nb_mmco = i;
884  }
885  }
886 
887  sl->nb_mmco = nb_mmco;
888 
889  return 0;
890 }
static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add)
Definition: h264_refs.c:62
#define ff_tlog(ctx,...)
Definition: internal.h:75
#define NULL
Definition: coverity.c:32
static int add_sorted(H264Picture **sorted, H264Picture *const *src, int len, int limit, int dir)
Definition: h264_refs.c:104
Memory management control operation.
Definition: h264dec.h:122
const char const char void * val
Definition: avisynth_c.h:863
int nb_mmco
Definition: h264dec.h:474
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:154
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
H264POCContext poc
Definition: h264dec.h:460
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static H264Picture * remove_short(H264Context *h, int frame_num, int ref_mask)
Definition: h264_refs.c:524
int first_field
Definition: h264dec.h:408
int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:299
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:459
MMCO mmco[MAX_MMCO_COUNT]
memory management control operations buffer.
Definition: h264dec.h:473
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264_ps.h:115
#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
Picture parameter set.
Definition: h264_ps.h:109
H264Picture * delayed_pic[MAX_DELAYED_PIC_COUNT+2]
Definition: h264dec.h:465
H264Ref default_ref[2]
Definition: h264dec.h:462
H264Context.
Definition: h264dec.h:337
AVFrame * f
Definition: h264dec.h:129
int nb_ref_modifications[2]
Definition: h264dec.h:276
H264Picture * long_ref[32]
Definition: h264dec.h:464
#define src
Definition: vp8dsp.c:254
int picture_structure
Definition: h264dec.h:407
static int mismatches_ref(const H264Context *h, const H264Picture *pic)
Definition: h264_refs.c:127
MMCOOpcode opcode
Definition: h264dec.h:123
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:267
MMCO mmco[MAX_MMCO_COUNT]
Definition: h264dec.h:322
void ff_h264_remove_all_refs(H264Context *h)
Definition: h264_refs.c:563
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int short_pic_num
pic_num without wrapping (pic_num & max_pic_num)
Definition: h264dec.h:124
static void print_short_term(const H264Context *h)
print short term list
Definition: h264_refs.c:220
int poc
Definition: h264dec.h:171
int poc
frame POC
Definition: h264dec.h:148
#define f(width, name)
Definition: cbs_vp9.c:255
int frame_recovered
Initial frame has been completely recovered.
Definition: h264dec.h:524
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
H264Picture * parent
Definition: h264dec.h:174
#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
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:161
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
Definition: h264_refs.c:421
#define av_log(a,...)
int last_pocs[MAX_DELAYED_PIC_COUNT]
Definition: h264dec.h:466
H.264 common definitions.
#define U(x)
Definition: vp56_arith.h:37
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
int width
Definition: frame.h:326
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1855
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
Definition: h264_refs.c:832
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
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define FIELD_PICTURE(h)
Definition: h264dec.h:74
simple assert() macros that are a bit more flexible than ISO C assert().
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:149
MMCOOpcode
Memory management control operation opcode.
Definition: h264dec.h:109
#define FFMAX(a, b)
Definition: common.h:94
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:184
int pic_id
Definition: h264dec.h:172
static int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
Mark a picture as no longer needed for reference.
Definition: h264_refs.c:467
uint8_t * data[3]
Definition: h264dec.h:167
int ref_frame_count
num_ref_frames
Definition: h264_ps.h:57
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:351
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2690
int reference
Definition: h264dec.h:160
int long_ref_count
number of actual long term references
Definition: h264dec.h:478
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
mcdeint parity
Definition: vf_mcdeint.c:274
H.264 / AVC / MPEG-4 part10 codec.
int mmco_reset
Definition: h264dec.h:475
#define FF_DEBUG_MMCO
Definition: avcodec.h:2662
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2701
int reference
Definition: h264dec.h:170
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:512
static void ref_from_h264pic(H264Ref *dst, H264Picture *src)
Definition: h264_refs.c:52
int type
NAL unit type.
Definition: h2645_parse.h:52
#define FF_ARRAY_ELEMS(a)
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:490
if(ret)
static const float pred[4]
Definition: siprdata.h:259
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:103
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:341
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
AVCodecContext * avctx
Definition: h264dec.h:339
Libavcodec external API header.
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: h264_ps.h:140
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:118
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
H264Picture * short_ref[32]
Definition: h264dec.h:463
int explicit_ref_marking
Definition: h264dec.h:476
int field_poc[2]
top/bottom POC
Definition: h264dec.h:147
int debug
debug
Definition: avcodec.h:2646
int explicit_ref_marking
Definition: h264dec.h:324
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
uint8_t * data
The data buffer.
Definition: buffer.h:89
static void print_long_term(const H264Context *h)
print long term list
Definition: h264_refs.c:236
int av_buffer_get_ref_count(const AVBufferRef *buf)
Definition: buffer.c:146
AVBuffer * buffer
Definition: buffer.h:82
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
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
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
struct H264SliceContext::@90 ref_modifications[2][32]
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
int index
Definition: gxfenc.c:89
#define FRAME_MBAFF(h)
Definition: h264dec.h:73
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
Definition: h264_picture.c:66
int mmco_reset
MMCO_RESET set this 1.
Definition: h264dec.h:150
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:546
H264Picture * cur_pic_ptr
Definition: h264dec.h:346
const SPS * sps
Definition: h264_ps.h:146
int linesize[3]
Definition: h264dec.h:168
unsigned int list_count
Definition: h264dec.h:268
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
int has_recovery_point
Definition: h264dec.h:526
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
int pic_id
pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num) ...
Definition: h264dec.h:152
static void pic_as_field(H264Ref *pic, const int parity)
Definition: h264_refs.c:40
common internal api header.
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:50
H264ParamSets ps
Definition: h264dec.h:456
static void h264_fill_mbaff_ref_list(H264SliceContext *sl)
Definition: h264_refs.c:274
Bi-dir predicted.
Definition: avutil.h:276
uint8_t op
Definition: h264dec.h:273
int long_arg
index, pic_num, or num long refs depending on opcode
Definition: h264dec.h:125
#define PICT_FRAME
Definition: mpegutils.h:39
int len
static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:135
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
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:608
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:269
H264Picture last_pic_for_ec
Definition: h264dec.h:348
#define av_uninit(x)
Definition: attributes.h:148
int height
Definition: frame.h:326
FILE * out
Definition: movenc.c:54
#define FFSWAP(type, a, b)
Definition: common.h:99
exp golomb vlc stuff
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
Definition: h264_picture.c:45
static void generate_sliding_window_mmcos(H264Context *h)
Definition: h264_refs.c:586
GetBitContext gb
Definition: h264dec.h:179
uint32_t val
Definition: h264dec.h:274
#define MAX_MMCO_COUNT
Definition: h264dec.h:54
int short_ref_count
number of actual short term references
Definition: h264dec.h:479