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 "avcodec.h"
32 #include "h264.h"
33 #include "h264dec.h"
34 #include "golomb.h"
35 #include "mpegutils.h"
36 
37 #include <assert.h>
38 
39 static void pic_as_field(H264Ref *pic, const int parity)
40 {
41  int i;
42  for (i = 0; i < FF_ARRAY_ELEMS(pic->data); ++i) {
44  pic->data[i] += pic->linesize[i];
45  pic->reference = parity;
46  pic->linesize[i] *= 2;
47  }
48  pic->poc = pic->parent->field_poc[parity == PICT_BOTTOM_FIELD];
49 }
50 
51 static void ref_from_h264pic(H264Ref *dst, const H264Picture *src)
52 {
53  memcpy(dst->data, src->f->data, sizeof(dst->data));
54  memcpy(dst->linesize, src->f->linesize, sizeof(dst->linesize));
55  dst->reference = src->reference;
56  dst->poc = src->poc;
57  dst->pic_id = src->pic_id;
58  dst->parent = src;
59 }
60 
61 static int split_field_copy(H264Ref *dest, const H264Picture *src,
62  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  const 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  }
413  if (h->noref_gray>0 && sl->ref_list[list][index].parent->gray && h->non_gray) {
414  for (int j=0; j<sl->list_count; j++) {
415  int list2 = (list+j)&1;
416  if (h->default_ref[list2].parent && !h->default_ref[list2].parent->gray
417  && !(!FIELD_PICTURE(h) && (h->default_ref[list2].reference&3) != 3)) {
418  sl->ref_list[list][index] = h->default_ref[list2];
419  av_log(h, AV_LOG_DEBUG, "replacement of gray gap frame\n");
420  break;
421  }
422  }
423  }
425  }
426  }
427 
428  if (FRAME_MBAFF(h))
430 
431  return 0;
432 }
433 
435 {
436  int list, index;
437 
438  sl->nb_ref_modifications[0] = 0;
439  sl->nb_ref_modifications[1] = 0;
440 
441  for (list = 0; list < sl->list_count; list++) {
442  if (!get_bits1(&sl->gb)) // ref_pic_list_modification_flag_l[01]
443  continue;
444 
445  for (index = 0; ; index++) {
446  unsigned int op = get_ue_golomb_31(&sl->gb);
447 
448  if (op == 3)
449  break;
450 
451  if (index >= sl->ref_count[list]) {
452  av_log(logctx, AV_LOG_ERROR, "reference count overflow\n");
453  return AVERROR_INVALIDDATA;
454  } else if (op > 2) {
455  av_log(logctx, AV_LOG_ERROR,
456  "illegal modification_of_pic_nums_idc %u\n",
457  op);
458  return AVERROR_INVALIDDATA;
459  }
461  sl->ref_modifications[list][index].op = op;
462  sl->nb_ref_modifications[list]++;
463  }
464  }
465 
466  return 0;
467 }
468 
469 /**
470  * Mark a picture as no longer needed for reference. The refmask
471  * argument allows unreferencing of individual fields or the whole frame.
472  * If the picture becomes entirely unreferenced, but is being held for
473  * display purposes, it is marked as such.
474  * @param refmask mask of fields to unreference; the mask is bitwise
475  * anded with the reference marking of pic
476  * @return non-zero if pic becomes entirely unreferenced (except possibly
477  * for display purposes) zero if one of the fields remains in
478  * reference
479  */
480 static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
481 {
482  int i;
483  if (pic->reference &= refmask) {
484  return 0;
485  } else {
486  for(i = 0; h->delayed_pic[i]; i++)
487  if(pic == h->delayed_pic[i]){
488  pic->reference = DELAYED_PIC_REF;
489  break;
490  }
491  return 1;
492  }
493 }
494 
495 /**
496  * Find a H264Picture in the short term reference list by frame number.
497  * @param frame_num frame number to search for
498  * @param idx the index into h->short_ref where returned picture is found
499  * undefined if no picture found.
500  * @return pointer to the found picture, or NULL if no pic with the provided
501  * frame number is found
502  */
503 static H264Picture *find_short(H264Context *h, int frame_num, int *idx)
504 {
505  int i;
506 
507  for (i = 0; i < h->short_ref_count; i++) {
508  H264Picture *pic = h->short_ref[i];
509  if (h->avctx->debug & FF_DEBUG_MMCO)
510  av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
511  if (pic->frame_num == frame_num) {
512  *idx = i;
513  return pic;
514  }
515  }
516  return NULL;
517 }
518 
519 /**
520  * Remove a picture from the short term reference list by its index in
521  * that list. This does no checking on the provided index; it is assumed
522  * to be valid. Other list entries are shifted down.
523  * @param i index into h->short_ref of picture to remove.
524  */
526 {
527  assert(i >= 0 && i < h->short_ref_count);
528  h->short_ref[i] = NULL;
529  if (--h->short_ref_count)
530  memmove(&h->short_ref[i], &h->short_ref[i + 1],
531  (h->short_ref_count - i) * sizeof(H264Picture*));
532 }
533 
534 /**
535  * @return the removed picture or NULL if an error occurs
536  */
537 static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask)
538 {
539  H264Picture *pic;
540  int i;
541 
542  if (h->avctx->debug & FF_DEBUG_MMCO)
543  av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
544 
545  pic = find_short(h, frame_num, &i);
546  if (pic) {
547  if (unreference_pic(h, pic, ref_mask))
549  }
550 
551  return pic;
552 }
553 
554 /**
555  * Remove a picture from the long term reference list by its index in
556  * that list.
557  * @return the removed picture or NULL if an error occurs
558  */
559 static H264Picture *remove_long(H264Context *h, int i, int ref_mask)
560 {
561  H264Picture *pic;
562 
563  pic = h->long_ref[i];
564  if (pic) {
565  if (unreference_pic(h, pic, ref_mask)) {
566  assert(h->long_ref[i]->long_ref == 1);
567  h->long_ref[i]->long_ref = 0;
568  h->long_ref[i] = NULL;
569  h->long_ref_count--;
570  }
571  }
572 
573  return pic;
574 }
575 
577 {
578  int i;
579 
580  for (i = 0; i < 16; i++) {
581  remove_long(h, i, 0);
582  }
583  assert(h->long_ref_count == 0);
584 
585  if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
586  ff_h264_unref_picture(&h->last_pic_for_ec);
587  ff_h264_ref_picture(&h->last_pic_for_ec, h->short_ref[0]);
588  }
589 
590  for (i = 0; i < h->short_ref_count; i++) {
591  unreference_pic(h, h->short_ref[i], 0);
592  h->short_ref[i] = NULL;
593  }
594  h->short_ref_count = 0;
595 
596  memset(h->default_ref, 0, sizeof(h->default_ref));
597 }
598 
600 {
601  MMCO *mmco = h->mmco;
602  int nb_mmco = 0;
603 
604  if (h->short_ref_count &&
605  h->long_ref_count + h->short_ref_count >= h->ps.sps->ref_frame_count &&
606  !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
607  mmco[0].opcode = MMCO_SHORT2UNUSED;
608  mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
609  nb_mmco = 1;
610  if (FIELD_PICTURE(h)) {
611  mmco[0].short_pic_num *= 2;
612  mmco[1].opcode = MMCO_SHORT2UNUSED;
613  mmco[1].short_pic_num = mmco[0].short_pic_num + 1;
614  nb_mmco = 2;
615  }
616  }
617 
618  h->nb_mmco = nb_mmco;
619 }
620 
622 {
623  MMCO *mmco = h->mmco;
624  int mmco_count;
625  int i, av_uninit(j);
626  int pps_ref_count[2] = {0};
627  int current_ref_assigned = 0, err = 0;
628  H264Picture *av_uninit(pic);
629 
630  if (!h->ps.sps) {
631  av_log(h->avctx, AV_LOG_ERROR, "SPS is unset\n");
632  err = AVERROR_INVALIDDATA;
633  goto out;
634  }
635 
636  if (!h->explicit_ref_marking)
638  mmco_count = h->nb_mmco;
639 
640  if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)
641  av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");
642 
643  for (i = 0; i < mmco_count; i++) {
644  int av_uninit(structure), av_uninit(frame_num);
645  if (h->avctx->debug & FF_DEBUG_MMCO)
646  av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,
647  h->mmco[i].short_pic_num, h->mmco[i].long_arg);
648 
649  if (mmco[i].opcode == MMCO_SHORT2UNUSED ||
650  mmco[i].opcode == MMCO_SHORT2LONG) {
651  frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
652  pic = find_short(h, frame_num, &j);
653  if (!pic) {
654  if (mmco[i].opcode != MMCO_SHORT2LONG ||
655  !h->long_ref[mmco[i].long_arg] ||
656  h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
657  av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n");
658  err = AVERROR_INVALIDDATA;
659  }
660  continue;
661  }
662  }
663 
664  switch (mmco[i].opcode) {
665  case MMCO_SHORT2UNUSED:
666  if (h->avctx->debug & FF_DEBUG_MMCO)
667  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",
668  h->mmco[i].short_pic_num, h->short_ref_count);
669  remove_short(h, frame_num, structure ^ PICT_FRAME);
670  break;
671  case MMCO_SHORT2LONG:
672  if (h->long_ref[mmco[i].long_arg] != pic)
673  remove_long(h, mmco[i].long_arg, 0);
674 
676  h->long_ref[ mmco[i].long_arg ] = pic;
677  if (h->long_ref[mmco[i].long_arg]) {
678  h->long_ref[mmco[i].long_arg]->long_ref = 1;
679  h->long_ref_count++;
680  }
681  break;
682  case MMCO_LONG2UNUSED:
683  j = pic_num_extract(h, mmco[i].long_arg, &structure);
684  pic = h->long_ref[j];
685  if (pic) {
686  remove_long(h, j, structure ^ PICT_FRAME);
687  } else if (h->avctx->debug & FF_DEBUG_MMCO)
688  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
689  break;
690  case MMCO_LONG:
691  // Comment below left from previous code as it is an interesting note.
692  /* First field in pair is in short term list or
693  * at a different long term index.
694  * This is not allowed; see 7.4.3.3, notes 2 and 3.
695  * Report the problem and keep the pair where it is,
696  * and mark this field valid.
697  */
698  if (h->short_ref[0] == h->cur_pic_ptr) {
699  av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n");
701  }
702 
703  /* make sure the current picture is not already assigned as a long ref */
704  if (h->cur_pic_ptr->long_ref) {
705  for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) {
706  if (h->long_ref[j] == h->cur_pic_ptr) {
707  if (j != mmco[i].long_arg)
708  av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");
709  remove_long(h, j, 0);
710  }
711  }
712  }
713 
714  if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
715  av_assert0(!h->cur_pic_ptr->long_ref);
716  remove_long(h, mmco[i].long_arg, 0);
717 
718  h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr;
719  h->long_ref[mmco[i].long_arg]->long_ref = 1;
720  h->long_ref_count++;
721  }
722 
723  h->cur_pic_ptr->reference |= h->picture_structure;
724  current_ref_assigned = 1;
725  break;
726  case MMCO_SET_MAX_LONG:
727  assert(mmco[i].long_arg <= 16);
728  // just remove the long term which index is greater than new max
729  for (j = mmco[i].long_arg; j < 16; j++) {
730  remove_long(h, j, 0);
731  }
732  break;
733  case MMCO_RESET:
734  while (h->short_ref_count) {
735  remove_short(h, h->short_ref[0]->frame_num, 0);
736  }
737  for (j = 0; j < 16; j++) {
738  remove_long(h, j, 0);
739  }
740  h->poc.frame_num = h->cur_pic_ptr->frame_num = 0;
741  h->mmco_reset = 1;
742  h->cur_pic_ptr->mmco_reset = 1;
743  for (j = 0; j < FF_ARRAY_ELEMS(h->last_pocs); j++)
744  h->last_pocs[j] = INT_MIN;
745  break;
746  default: av_assert0(0);
747  }
748  }
749 
750  if (!current_ref_assigned) {
751  /* Second field of complementary field pair; the first field of
752  * which is already referenced. If short referenced, it
753  * should be first entry in short_ref. If not, it must exist
754  * in long_ref; trying to put it on the short list here is an
755  * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
756  */
757  if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
758  /* Just mark the second field valid */
759  h->cur_pic_ptr->reference |= h->picture_structure;
760  } else if (h->cur_pic_ptr->long_ref) {
761  av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
762  "assignment for second field "
763  "in complementary field pair "
764  "(first field is long term)\n");
765  err = AVERROR_INVALIDDATA;
766  } else {
767  pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);
768  if (pic) {
769  av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
770  err = AVERROR_INVALIDDATA;
771  }
772 
773  if (h->short_ref_count)
774  memmove(&h->short_ref[1], &h->short_ref[0],
775  h->short_ref_count * sizeof(H264Picture*));
776 
777  h->short_ref[0] = h->cur_pic_ptr;
778  h->short_ref_count++;
779  h->cur_pic_ptr->reference |= h->picture_structure;
780  }
781  }
782 
783  if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.sps->ref_frame_count, 1)) {
784 
785  /* We have too many reference frames, probably due to corrupted
786  * stream. Need to discard one frame. Prevents overrun of the
787  * short_ref and long_ref buffers.
788  */
789  av_log(h->avctx, AV_LOG_ERROR,
790  "number of reference frames (%d+%d) exceeds max (%d; probably "
791  "corrupt input), discarding one\n",
792  h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count);
793  err = AVERROR_INVALIDDATA;
794 
795  if (h->long_ref_count && !h->short_ref_count) {
796  for (i = 0; i < 16; ++i)
797  if (h->long_ref[i])
798  break;
799 
800  assert(i < 16);
801  remove_long(h, i, 0);
802  } else {
803  pic = h->short_ref[h->short_ref_count - 1];
804  remove_short(h, pic->frame_num, 0);
805  }
806  }
807 
808  for (i = 0; i<h->short_ref_count; i++) {
809  pic = h->short_ref[i];
810  if (pic->invalid_gap) {
811  int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num);
812  if (d > h->ps.sps->ref_frame_count)
813  remove_short(h, pic->frame_num, 0);
814  }
815  }
816 
819 
820  for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
821  if (h->ps.pps_list[i]) {
822  const PPS *pps = h->ps.pps_list[i];
823  pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]);
824  pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]);
825  }
826  }
827 
828  // Detect unmarked random access points
829  if ( err >= 0
830  && h->long_ref_count==0
831  && ( h->short_ref_count<=2
832  || pps_ref_count[0] <= 2 && pps_ref_count[1] <= 1 && h->avctx->has_b_frames
833  || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1)
834  && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point)
835  && h->cur_pic_ptr->f->pict_type == AV_PICTURE_TYPE_I){
836  h->cur_pic_ptr->recovered |= FRAME_RECOVERED_HEURISTIC;
837  if(!h->avctx->has_b_frames)
838  h->frame_recovered |= FRAME_RECOVERED_HEURISTIC;
839  }
840 
841 out:
842  return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
843 }
844 
846  const H2645NAL *nal, void *logctx)
847 {
848  int i;
849  MMCO *mmco = sl->mmco;
850  int nb_mmco = 0;
851 
852  if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields
853  skip_bits1(gb); // broken_link
854  if (get_bits1(gb)) {
855  mmco[0].opcode = MMCO_LONG;
856  mmco[0].long_arg = 0;
857  nb_mmco = 1;
858  }
859  sl->explicit_ref_marking = 1;
860  } else {
862  if (sl->explicit_ref_marking) {
863  for (i = 0; i < FF_ARRAY_ELEMS(sl->mmco); i++) {
864  MMCOOpcode opcode = get_ue_golomb_31(gb);
865 
866  mmco[i].opcode = opcode;
867  if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
868  mmco[i].short_pic_num =
869  (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &
870  (sl->max_pic_num - 1);
871  }
872  if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
873  opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
874  unsigned int long_arg = get_ue_golomb_31(gb);
875  if (long_arg >= 32 ||
876  (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
877  long_arg == 16) &&
878  !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) {
879  av_log(logctx, AV_LOG_ERROR,
880  "illegal long ref in memory management control "
881  "operation %d\n", opcode);
882  sl->nb_mmco = i;
883  return -1;
884  }
885  mmco[i].long_arg = long_arg;
886  }
887 
888  if (opcode > (unsigned) MMCO_LONG) {
889  av_log(logctx, AV_LOG_ERROR,
890  "illegal memory management control operation %d\n",
891  opcode);
892  sl->nb_mmco = i;
893  return -1;
894  }
895  if (opcode == MMCO_END)
896  break;
897  }
898  nb_mmco = i;
899  }
900  }
901 
902  sl->nb_mmco = nb_mmco;
903 
904  return 0;
905 }
MMCO_LONG2UNUSED
@ MMCO_LONG2UNUSED
Definition: h264_parse.h:62
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
MMCO::opcode
MMCOOpcode opcode
Definition: h264dec.h:101
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:525
H264SliceContext::nb_ref_modifications
int nb_ref_modifications[2]
Definition: h264dec.h:271
MMCO::long_arg
int long_arg
index, pic_num, or num long refs depending on opcode
Definition: h264dec.h:103
MMCO_LONG
@ MMCO_LONG
Definition: h264_parse.h:66
mismatches_ref
static int mismatches_ref(const H264Context *h, const H264Picture *pic)
Definition: h264_refs.c:127
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
H264SliceContext::max_pic_num
int max_pic_num
Definition: h264dec.h:326
H264SliceContext::nb_mmco
int nb_mmco
Definition: h264dec.h:317
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:127
H264Picture::f
AVFrame * f
Definition: h264dec.h:107
out
FILE * out
Definition: movenc.c:54
ff_h264_ref_picture
int ff_h264_ref_picture(H264Picture *dst, const H264Picture *src)
Definition: h264_picture.c:108
H264Ref
Definition: h264dec.h:161
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:125
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
H264SliceContext::val
uint32_t val
Definition: h264dec.h:269
H264Ref::pic_id
int pic_id
Definition: h264dec.h:167
data
const char data[16]
Definition: mxf.c:148
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:262
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
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
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_h264_decode_ref_pic_list_reordering
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
Definition: h264_refs.c:434
mpegutils.h
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:553
MMCOOpcode
MMCOOpcode
Memory management control operation opcode.
Definition: h264_parse.h:59
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:559
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
MMCO_SET_MAX_LONG
@ MMCO_SET_MAX_LONG
Definition: h264_parse.h:64
H264Picture::frame_num
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:128
H264SliceContext
Definition: h264dec.h:172
golomb.h
exp golomb vlc stuff
GetBitContext
Definition: get_bits.h:108
val
static double val(void *priv, double ch)
Definition: aeval.c:78
H264Ref::data
uint8_t * data[3]
Definition: h264dec.h:162
FRAME_RECOVERED_HEURISTIC
#define FRAME_RECOVERED_HEURISTIC
Recovery point detected by heuristic.
Definition: h264dec.h:527
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:503
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:76
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:67
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:621
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:845
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ff_h264_remove_all_refs
void ff_h264_remove_all_refs(H264Context *h)
Definition: h264_refs.c:576
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:36
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:1406
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:102
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
frame
static AVFrame * frame
Definition: demux_decode.c:54
H264SliceContext::curr_pic_num
int curr_pic_num
Definition: h264dec.h:325
if
if(ret)
Definition: filter_design.txt:179
NULL
#define NULL
Definition: coverity.c:32
H264Ref::parent
const H264Picture * parent
Definition: h264dec.h:169
H264Ref::linesize
int linesize[3]
Definition: h264dec.h:163
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
PPS
Picture parameter set.
Definition: h264_ps.h:110
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
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::pic_id
int pic_id
pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num)
Definition: h264dec.h:131
MMCO_END
@ MMCO_END
Definition: h264_parse.h:60
f
f
Definition: af_crystalizer.c:121
H264Picture::reference
int reference
Definition: h264dec.h:144
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
H264Picture::gray
int gray
Definition: h264dec.h:158
MMCO_SHORT2UNUSED
@ MMCO_SHORT2UNUSED
Definition: h264_parse.h:61
H2645NAL
Definition: h2645_parse.h:34
parity
mcdeint parity
Definition: vf_mcdeint.c:281
MMCO_RESET
@ MMCO_RESET
Definition: h264_parse.h:65
H264SliceContext::explicit_ref_marking
int explicit_ref_marking
Definition: h264dec.h:318
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:480
av_buffer_get_ref_count
int av_buffer_get_ref_count(const AVBufferRef *buf)
Definition: buffer.c:160
AVBufferRef::buffer
AVBuffer * buffer
Definition: buffer.h:83
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
H264SliceContext::slice_type_nos
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:179
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
FRAME_MBAFF
#define FRAME_MBAFF(h)
Definition: h264dec.h:66
h264dec.h
H264Context
H264Context.
Definition: h264dec.h:332
h264_initialise_ref_list
static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:135
MMCO_SHORT2LONG
@ MMCO_SHORT2LONG
Definition: h264_parse.h:63
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ref_from_h264pic
static void ref_from_h264pic(H264Ref *dst, const H264Picture *src)
Definition: h264_refs.c:51
len
int len
Definition: vorbis_enc_data.h:426
H264SliceContext::list_count
unsigned int list_count
Definition: h264dec.h:263
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:142
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
pred
static const float pred[4]
Definition: siprdata.h:259
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
remove_short
static H264Picture * remove_short(H264Context *h, int frame_num, int ref_mask)
Definition: h264_refs.c:537
U
#define U(x)
Definition: vpx_arith.h:37
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:599
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:126
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
H264SliceContext::mmco
MMCO mmco[H264_MAX_MMCO_COUNT]
Definition: h264dec.h:316
add_sorted
static int add_sorted(H264Picture **sorted, H264Picture *const *src, int len, int limit, int dir)
Definition: h264_refs.c:104
split_field_copy
static int split_field_copy(H264Ref *dest, const H264Picture *src, int parity, int id_add)
Definition: h264_refs.c:61
ff_h264_unref_picture
void ff_h264_unref_picture(H264Picture *pic)
Definition: h264_picture.c:39
H264Picture
Definition: h264dec.h:106
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
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:264
H264SliceContext::op
uint8_t op
Definition: h264dec.h:268
MMCO
Memory management control operation.
Definition: h264dec.h:100
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:104
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:153
H264SliceContext::gb
GetBitContext gb
Definition: h264dec.h:174
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
pic_as_field
static void pic_as_field(H264Ref *pic, const int parity)
Definition: h264_refs.c:39
d
d
Definition: ffmpeg_filter.c:425
h264.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
H264SliceContext::ref_modifications
struct H264SliceContext::@89 ref_modifications[2][32]
h
h
Definition: vp9dsp_template.c:2038
H264Ref::poc
int poc
Definition: h264dec.h:166
H264Picture::long_ref
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:133
H264Ref::reference
int reference
Definition: h264dec.h:165