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 || mismatches_ref(h, ref)) {
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  }
392  ref_from_h264pic(&sl->ref_list[list][index], ref);
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  }
413  av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0);
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))
537  remove_short_at_index(h, i);
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]) {
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 &&
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",
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 
664  remove_short_at_index(h, j);
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");
689  remove_short_at_index(h, 0);
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) {
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 
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: av_assert0(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 */
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++;
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  */
779  "number of reference frames (%d+%d) exceeds max (%d; probably "
780  "corrupt input), discarding one\n",
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 
806  print_short_term(h);
807  print_long_term(h);
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)
825  h->cur_pic_ptr->recovered |= 1;
826  if(!h->avctx->has_b_frames)
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  sl->nb_mmco = i;
872  return -1;
873  }
874  mmco[i].long_arg = long_arg;
875  }
876 
877  if (opcode > (unsigned) MMCO_LONG) {
878  av_log(logctx, AV_LOG_ERROR,
879  "illegal memory management control operation %d\n",
880  opcode);
881  sl->nb_mmco = i;
882  return -1;
883  }
884  if (opcode == MMCO_END)
885  break;
886  }
887  nb_mmco = i;
888  }
889  }
890 
891  sl->nb_mmco = nb_mmco;
892 
893  return 0;
894 }
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:295
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:526
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:486
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:565
#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:423
#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:259
int width
Definition: frame.h:353
#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:1858
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
Definition: h264_refs.c:834
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:469
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:378
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2697
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:2669
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2708
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:514
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:492
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:105
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
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:120
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
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:2653
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:548
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:309
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:610
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:353
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:588
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