Libav
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #include "internal.h"
29 #include "avcodec.h"
30 #include "h264.h"
31 #include "golomb.h"
32 
33 #include <assert.h>
34 
35 #define COPY_PICTURE(dst, src) \
36 do {\
37  *(dst) = *(src);\
38  (dst)->f.extended_data = (dst)->f.data;\
39  (dst)->tf.f = &(dst)->f;\
40 } while (0)
41 
42 
43 static void pic_as_field(Picture *pic, const int parity){
44  int i;
45  for (i = 0; i < 4; ++i) {
46  if (parity == PICT_BOTTOM_FIELD)
47  pic->f.data[i] += pic->f.linesize[i];
48  pic->reference = parity;
49  pic->f.linesize[i] *= 2;
50  }
51  pic->poc= pic->field_poc[parity == PICT_BOTTOM_FIELD];
52 }
53 
54 static int split_field_copy(Picture *dest, Picture *src, int parity, int id_add)
55 {
56  int match = !!(src->reference & parity);
57 
58  if (match) {
59  COPY_PICTURE(dest, src);
60  if (parity != PICT_FRAME) {
61  pic_as_field(dest, parity);
62  dest->pic_id *= 2;
63  dest->pic_id += id_add;
64  }
65  }
66 
67  return match;
68 }
69 
70 static int build_def_list(Picture *def, int def_len,
71  Picture **in, int len, int is_long, int sel)
72 {
73  int i[2] = { 0 };
74  int index = 0;
75 
76  while ((i[0] < len || i[1] < len) && index < def_len) {
77  while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel)))
78  i[0]++;
79  while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3))))
80  i[1]++;
81  if (i[0] < len && index < def_len) {
82  in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num;
83  split_field_copy(&def[index++], in[i[0]++], sel, 1);
84  }
85  if (i[1] < len && index < def_len) {
86  in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num;
87  split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0);
88  }
89  }
90 
91  return index;
92 }
93 
94 static int add_sorted(Picture **sorted, Picture **src, int len, int limit, int dir)
95 {
96  int i, best_poc;
97  int out_i = 0;
98 
99  for (;;) {
100  best_poc = dir ? INT_MIN : INT_MAX;
101 
102  for (i = 0; i < len; i++) {
103  const int poc = src[i]->poc;
104  if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) {
105  best_poc = poc;
106  sorted[out_i] = src[i];
107  }
108  }
109  if (best_poc == (dir ? INT_MIN : INT_MAX))
110  break;
111  limit = sorted[out_i++]->poc - dir;
112  }
113  return out_i;
114 }
115 
117 {
118  int i, len;
119 
120  if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
121  Picture *sorted[32];
122  int cur_poc, list;
123  int lens[2];
124 
125  if (FIELD_PICTURE(h))
127  else
128  cur_poc = h->cur_pic_ptr->poc;
129 
130  for (list = 0; list < 2; list++) {
131  len = add_sorted(sorted, h->short_ref, h->short_ref_count, cur_poc, 1 ^ list);
132  len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list);
133  assert(len <= 32);
134 
136  sorted, len, 0, h->picture_structure);
137  len += build_def_list(h->default_ref_list[list] + len,
138  FF_ARRAY_ELEMS(h->default_ref_list[0]) - len,
139  h->long_ref, 16, 1, h->picture_structure);
140 
141  if (len < h->ref_count[list])
142  memset(&h->default_ref_list[list][len], 0, sizeof(Picture) * (h->ref_count[list] - len));
143  lens[list] = len;
144  }
145 
146  if (lens[0] == lens[1] && lens[1] > 1) {
147  for (i = 0; i < lens[0] &&
148  h->default_ref_list[0][i].f.buf[0]->buffer ==
149  h->default_ref_list[1][i].f.buf[0]->buffer; i++);
150  if (i == lens[0]) {
151  Picture tmp;
152  COPY_PICTURE(&tmp, &h->default_ref_list[1][0]);
153  COPY_PICTURE(&h->default_ref_list[1][0], &h->default_ref_list[1][1]);
154  COPY_PICTURE(&h->default_ref_list[1][1], &tmp);
155  }
156  }
157  } else {
160  len += build_def_list(h->default_ref_list[0] + len,
161  FF_ARRAY_ELEMS(h->default_ref_list[0]) - len,
162  h-> long_ref, 16, 1, h->picture_structure);
163 
164  if (len < h->ref_count[0])
165  memset(&h->default_ref_list[0][len], 0, sizeof(Picture) * (h->ref_count[0] - len));
166  }
167 #ifdef TRACE
168  for (i = 0; i < h->ref_count[0]; i++) {
169  tprintf(h->avctx, "List0: %s fn:%d 0x%p\n",
170  (h->default_ref_list[0][i].long_ref ? "LT" : "ST"),
171  h->default_ref_list[0][i].pic_id,
172  h->default_ref_list[0][i].f.data[0]);
173  }
174  if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
175  for (i = 0; i < h->ref_count[1]; i++) {
176  tprintf(h->avctx, "List1: %s fn:%d 0x%p\n",
177  (h->default_ref_list[1][i].long_ref ? "LT" : "ST"),
178  h->default_ref_list[1][i].pic_id,
179  h->default_ref_list[1][i].f.data[0]);
180  }
181  }
182 #endif
183  return 0;
184 }
185 
186 static void print_short_term(H264Context *h);
187 static void print_long_term(H264Context *h);
188 
199 static int pic_num_extract(H264Context *h, int pic_num, int *structure)
200 {
201  *structure = h->picture_structure;
202  if (FIELD_PICTURE(h)) {
203  if (!(pic_num & 1))
204  /* opposite field */
205  *structure ^= PICT_FRAME;
206  pic_num >>= 1;
207  }
208 
209  return pic_num;
210 }
211 
213 {
214  int list, index, pic_structure, i;
215 
216  print_short_term(h);
217  print_long_term(h);
218 
219  for (list = 0; list < h->list_count; list++) {
220  for (i = 0; i < h->ref_count[list]; i++)
221  COPY_PICTURE(&h->ref_list[list][i], &h->default_ref_list[list][i]);
222 
223  if (get_bits1(&h->gb)) {
224  int pred = h->curr_pic_num;
225 
226  for (index = 0; ; index++) {
227  unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(&h->gb);
228  unsigned int pic_id;
229  int i;
230  Picture *ref = NULL;
231 
232  if (reordering_of_pic_nums_idc == 3)
233  break;
234 
235  if (index >= h->ref_count[list]) {
236  av_log(h->avctx, AV_LOG_ERROR, "reference count overflow\n");
237  return -1;
238  }
239 
240  switch (reordering_of_pic_nums_idc) {
241  case 0:
242  case 1: {
243  const unsigned int abs_diff_pic_num = get_ue_golomb(&h->gb) + 1;
244  int frame_num;
245 
246  if (abs_diff_pic_num > h->max_pic_num) {
248  "abs_diff_pic_num overflow\n");
249  return AVERROR_INVALIDDATA;
250  }
251 
252  if (reordering_of_pic_nums_idc == 0)
253  pred -= abs_diff_pic_num;
254  else
255  pred += abs_diff_pic_num;
256  pred &= h->max_pic_num - 1;
257 
258  frame_num = pic_num_extract(h, pred, &pic_structure);
259 
260  for (i = h->short_ref_count - 1; i >= 0; i--) {
261  ref = h->short_ref[i];
262  assert(ref->reference);
263  assert(!ref->long_ref);
264  if (ref->frame_num == frame_num &&
265  (ref->reference & pic_structure))
266  break;
267  }
268  if (i >= 0)
269  ref->pic_id = pred;
270  break;
271  }
272  case 2: {
273  int long_idx;
274  pic_id = get_ue_golomb(&h->gb); // long_term_pic_idx
275 
276  long_idx = pic_num_extract(h, pic_id, &pic_structure);
277 
278  if (long_idx > 31) {
280  "long_term_pic_idx overflow\n");
281  return AVERROR_INVALIDDATA;
282  }
283  ref = h->long_ref[long_idx];
284  assert(!(ref && !ref->reference));
285  if (ref && (ref->reference & pic_structure)) {
286  ref->pic_id = pic_id;
287  assert(ref->long_ref);
288  i = 0;
289  } else {
290  i = -1;
291  }
292  break;
293  }
294  default:
296  "illegal reordering_of_pic_nums_idc\n");
297  return AVERROR_INVALIDDATA;
298  }
299 
300  if (i < 0) {
302  "reference picture missing during reorder\n");
303  memset(&h->ref_list[list][index], 0, sizeof(Picture)); // FIXME
304  } else {
305  for (i = index; i + 1 < h->ref_count[list]; i++) {
306  if (ref->long_ref == h->ref_list[list][i].long_ref &&
307  ref->pic_id == h->ref_list[list][i].pic_id)
308  break;
309  }
310  for (; i > index; i--) {
311  COPY_PICTURE(&h->ref_list[list][i], &h->ref_list[list][i - 1]);
312  }
313  COPY_PICTURE(&h->ref_list[list][index], ref);
314  if (FIELD_PICTURE(h)) {
315  pic_as_field(&h->ref_list[list][index], pic_structure);
316  }
317  }
318  }
319  }
320  }
321  for (list = 0; list < h->list_count; list++) {
322  for (index = 0; index < h->ref_count[list]; index++) {
323  if (!h->ref_list[list][index].f.buf[0]) {
324  av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture\n");
325  if (h->default_ref_list[list][0].f.buf[0])
326  COPY_PICTURE(&h->ref_list[list][index], &h->default_ref_list[list][0]);
327  else
328  return -1;
329  }
330  }
331  }
332 
333  return 0;
334 }
335 
337 {
338  int list, i, j;
339  for (list = 0; list < 2; list++) { //FIXME try list_count
340  for (i = 0; i < h->ref_count[list]; i++) {
341  Picture *frame = &h->ref_list[list][i];
342  Picture *field = &h->ref_list[list][16 + 2 * i];
343  COPY_PICTURE(field, frame);
344  for (j = 0; j < 3; j++)
345  field[0].f.linesize[j] <<= 1;
346  field[0].reference = PICT_TOP_FIELD;
347  field[0].poc = field[0].field_poc[0];
348  COPY_PICTURE(field + 1, field);
349  for (j = 0; j < 3; j++)
350  field[1].f.data[j] += frame->f.linesize[j];
351  field[1].reference = PICT_BOTTOM_FIELD;
352  field[1].poc = field[1].field_poc[1];
353 
354  h->luma_weight[16 + 2 * i][list][0] = h->luma_weight[16 + 2 * i + 1][list][0] = h->luma_weight[i][list][0];
355  h->luma_weight[16 + 2 * i][list][1] = h->luma_weight[16 + 2 * i + 1][list][1] = h->luma_weight[i][list][1];
356  for (j = 0; j < 2; j++) {
357  h->chroma_weight[16 + 2 * i][list][j][0] = h->chroma_weight[16 + 2 * i + 1][list][j][0] = h->chroma_weight[i][list][j][0];
358  h->chroma_weight[16 + 2 * i][list][j][1] = h->chroma_weight[16 + 2 * i + 1][list][j][1] = h->chroma_weight[i][list][j][1];
359  }
360  }
361  }
362 }
363 
375 static inline int unreference_pic(H264Context *h, Picture *pic, int refmask)
376 {
377  int i;
378  if (pic->reference &= refmask) {
379  return 0;
380  } else {
381  for(i = 0; h->delayed_pic[i]; i++)
382  if(pic == h->delayed_pic[i]){
383  pic->reference = DELAYED_PIC_REF;
384  break;
385  }
386  return 1;
387  }
388 }
389 
398 static Picture *find_short(H264Context *h, int frame_num, int *idx)
399 {
400  int i;
401 
402  for (i = 0; i < h->short_ref_count; i++) {
403  Picture *pic = h->short_ref[i];
404  if (h->avctx->debug & FF_DEBUG_MMCO)
405  av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
406  if (pic->frame_num == frame_num) {
407  *idx = i;
408  return pic;
409  }
410  }
411  return NULL;
412 }
413 
420 static void remove_short_at_index(H264Context *h, int i)
421 {
422  assert(i >= 0 && i < h->short_ref_count);
423  h->short_ref[i] = NULL;
424  if (--h->short_ref_count)
425  memmove(&h->short_ref[i], &h->short_ref[i + 1],
426  (h->short_ref_count - i) * sizeof(Picture*));
427 }
428 
433 static Picture *remove_short(H264Context *h, int frame_num, int ref_mask)
434 {
435  Picture *pic;
436  int i;
437 
438  if (h->avctx->debug & FF_DEBUG_MMCO)
439  av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
440 
441  pic = find_short(h, frame_num, &i);
442  if (pic) {
443  if (unreference_pic(h, pic, ref_mask))
444  remove_short_at_index(h, i);
445  }
446 
447  return pic;
448 }
449 
455 static Picture *remove_long(H264Context *h, int i, int ref_mask)
456 {
457  Picture *pic;
458 
459  pic = h->long_ref[i];
460  if (pic) {
461  if (unreference_pic(h, pic, ref_mask)) {
462  assert(h->long_ref[i]->long_ref == 1);
463  h->long_ref[i]->long_ref = 0;
464  h->long_ref[i] = NULL;
465  h->long_ref_count--;
466  }
467  }
468 
469  return pic;
470 }
471 
473 {
474  int i;
475 
476  for (i = 0; i < 16; i++) {
477  remove_long(h, i, 0);
478  }
479  assert(h->long_ref_count == 0);
480 
481  for (i = 0; i < h->short_ref_count; i++) {
482  unreference_pic(h, h->short_ref[i], 0);
483  h->short_ref[i] = NULL;
484  }
485  h->short_ref_count = 0;
486 }
487 
492 {
493  uint32_t i;
494  if (h->avctx->debug & FF_DEBUG_MMCO) {
495  av_log(h->avctx, AV_LOG_DEBUG, "short term list:\n");
496  for (i = 0; i < h->short_ref_count; i++) {
497  Picture *pic = h->short_ref[i];
498  av_log(h->avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n",
499  i, pic->frame_num, pic->poc, pic->f.data[0]);
500  }
501  }
502 }
503 
508 {
509  uint32_t i;
510  if (h->avctx->debug & FF_DEBUG_MMCO) {
511  av_log(h->avctx, AV_LOG_DEBUG, "long term list:\n");
512  for (i = 0; i < 16; i++) {
513  Picture *pic = h->long_ref[i];
514  if (pic) {
515  av_log(h->avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n",
516  i, pic->frame_num, pic->poc, pic->f.data[0]);
517  }
518  }
519  }
520 }
521 
522 static int check_opcodes(MMCO *mmco1, MMCO *mmco2, int n_mmcos)
523 {
524  int i;
525 
526  for (i = 0; i < n_mmcos; i++) {
527  if (mmco1[i].opcode != mmco2[i].opcode)
528  return -1;
529  }
530 
531  return 0;
532 }
533 
535 {
536  MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = first_slice ? h->mmco : mmco_temp;
537  int mmco_index = 0, i;
538 
539  assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
540 
541  if (h->short_ref_count &&
543  !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
544  mmco[0].opcode = MMCO_SHORT2UNUSED;
545  mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
546  mmco_index = 1;
547  if (FIELD_PICTURE(h)) {
548  mmco[0].short_pic_num *= 2;
549  mmco[1].opcode = MMCO_SHORT2UNUSED;
550  mmco[1].short_pic_num = mmco[0].short_pic_num + 1;
551  mmco_index = 2;
552  }
553  }
554 
555  if (first_slice) {
556  h->mmco_index = mmco_index;
557  } else if (!first_slice && mmco_index >= 0 &&
558  (mmco_index != h->mmco_index ||
559  (i = check_opcodes(h->mmco, mmco_temp, mmco_index)))) {
561  "Inconsistent MMCO state between slices [%d, %d, %d]\n",
562  mmco_index, h->mmco_index, i);
563  return AVERROR_INVALIDDATA;
564  }
565  return 0;
566 }
567 
568 int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count)
569 {
570  int i, av_uninit(j);
571  int current_ref_assigned = 0, err = 0;
572  Picture *av_uninit(pic);
573 
574  if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)
575  av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");
576 
577  for (i = 0; i < mmco_count; i++) {
578  int av_uninit(structure), av_uninit(frame_num);
579  if (h->avctx->debug & FF_DEBUG_MMCO)
580  av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,
581  h->mmco[i].short_pic_num, h->mmco[i].long_arg);
582 
583  if (mmco[i].opcode == MMCO_SHORT2UNUSED ||
584  mmco[i].opcode == MMCO_SHORT2LONG) {
585  frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
586  pic = find_short(h, frame_num, &j);
587  if (!pic) {
588  if (mmco[i].opcode != MMCO_SHORT2LONG ||
589  !h->long_ref[mmco[i].long_arg] ||
590  h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
591  av_log(h->avctx, AV_LOG_ERROR, "mmco: unref short failure\n");
592  err = AVERROR_INVALIDDATA;
593  }
594  continue;
595  }
596  }
597 
598  switch (mmco[i].opcode) {
599  case MMCO_SHORT2UNUSED:
600  if (h->avctx->debug & FF_DEBUG_MMCO)
601  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",
603  remove_short(h, frame_num, structure ^ PICT_FRAME);
604  break;
605  case MMCO_SHORT2LONG:
606  if (h->long_ref[mmco[i].long_arg] != pic)
607  remove_long(h, mmco[i].long_arg, 0);
608 
609  remove_short_at_index(h, j);
610  h->long_ref[ mmco[i].long_arg ] = pic;
611  if (h->long_ref[mmco[i].long_arg]) {
612  h->long_ref[mmco[i].long_arg]->long_ref = 1;
613  h->long_ref_count++;
614  }
615  break;
616  case MMCO_LONG2UNUSED:
617  j = pic_num_extract(h, mmco[i].long_arg, &structure);
618  pic = h->long_ref[j];
619  if (pic) {
620  remove_long(h, j, structure ^ PICT_FRAME);
621  } else if (h->avctx->debug & FF_DEBUG_MMCO)
622  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
623  break;
624  case MMCO_LONG:
625  // Comment below left from previous code as it is an interresting note.
626  /* First field in pair is in short term list or
627  * at a different long term index.
628  * This is not allowed; see 7.4.3.3, notes 2 and 3.
629  * Report the problem and keep the pair where it is,
630  * and mark this field valid.
631  */
632  if (h->short_ref[0] == h->cur_pic_ptr)
633  remove_short_at_index(h, 0);
634 
635  if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
636  remove_long(h, mmco[i].long_arg, 0);
637 
638  h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr;
639  h->long_ref[mmco[i].long_arg]->long_ref = 1;
640  h->long_ref_count++;
641  }
642 
644  current_ref_assigned = 1;
645  break;
646  case MMCO_SET_MAX_LONG:
647  assert(mmco[i].long_arg <= 16);
648  // just remove the long term which index is greater than new max
649  for (j = mmco[i].long_arg; j < 16; j++) {
650  remove_long(h, j, 0);
651  }
652  break;
653  case MMCO_RESET:
654  while (h->short_ref_count) {
655  remove_short(h, h->short_ref[0]->frame_num, 0);
656  }
657  for (j = 0; j < 16; j++) {
658  remove_long(h, j, 0);
659  }
660  h->frame_num = h->cur_pic_ptr->frame_num = 0;
661  h->mmco_reset = 1;
662  h->cur_pic_ptr->mmco_reset = 1;
663  break;
664  default: assert(0);
665  }
666  }
667 
668  if (!current_ref_assigned) {
669  /* Second field of complementary field pair; the first field of
670  * which is already referenced. If short referenced, it
671  * should be first entry in short_ref. If not, it must exist
672  * in long_ref; trying to put it on the short list here is an
673  * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
674  */
675  if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
676  /* Just mark the second field valid */
678  } else if (h->cur_pic_ptr->long_ref) {
679  av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
680  "assignment for second field "
681  "in complementary field pair "
682  "(first field is long term)\n");
683  err = AVERROR_INVALIDDATA;
684  } else {
685  pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);
686  if (pic) {
687  av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
688  err = AVERROR_INVALIDDATA;
689  }
690 
691  if (h->short_ref_count)
692  memmove(&h->short_ref[1], &h->short_ref[0],
693  h->short_ref_count * sizeof(Picture*));
694 
695  h->short_ref[0] = h->cur_pic_ptr;
696  h->short_ref_count++;
698  }
699  }
700 
701  if (h->long_ref_count + h->short_ref_count -
702  (h->short_ref[0] == h->cur_pic_ptr) > h->sps.ref_frame_count) {
703 
704  /* We have too many reference frames, probably due to corrupted
705  * stream. Need to discard one frame. Prevents overrun of the
706  * short_ref and long_ref buffers.
707  */
709  "number of reference frames (%d+%d) exceeds max (%d; probably "
710  "corrupt input), discarding one\n",
712  err = AVERROR_INVALIDDATA;
713 
714  if (h->long_ref_count && !h->short_ref_count) {
715  for (i = 0; i < 16; ++i)
716  if (h->long_ref[i])
717  break;
718 
719  assert(i < 16);
720  remove_long(h, i, 0);
721  } else {
722  pic = h->short_ref[h->short_ref_count - 1];
723  remove_short(h, pic->frame_num, 0);
724  }
725  }
726 
727  print_short_term(h);
728  print_long_term(h);
729  return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
730 }
731 
733  int first_slice)
734 {
735  int i, ret;
736  MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = first_slice ? h->mmco : mmco_temp;
737  int mmco_index = 0;
738 
739  if (h->nal_unit_type == NAL_IDR_SLICE) { // FIXME fields
740  skip_bits1(gb); // broken_link
741  if (get_bits1(gb)) {
742  mmco[0].opcode = MMCO_LONG;
743  mmco[0].long_arg = 0;
744  mmco_index = 1;
745  }
746  } else {
747  if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
748  for (i = 0; i < MAX_MMCO_COUNT; i++) {
749  MMCOOpcode opcode = get_ue_golomb_31(gb);
750 
751  mmco[i].opcode = opcode;
752  if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
753  mmco[i].short_pic_num =
754  (h->curr_pic_num - get_ue_golomb(gb) - 1) &
755  (h->max_pic_num - 1);
756 #if 0
757  if (mmco[i].short_pic_num >= h->short_ref_count ||
758  h->short_ref[ mmco[i].short_pic_num ] == NULL){
759  av_log(s->avctx, AV_LOG_ERROR,
760  "illegal short ref in memory management control "
761  "operation %d\n", mmco);
762  return -1;
763  }
764 #endif
765  }
766  if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
767  opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
768  unsigned int long_arg = get_ue_golomb_31(gb);
769  if (long_arg >= 32 ||
770  (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
771  long_arg == 16) &&
772  !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(h)))) {
774  "illegal long ref in memory management control "
775  "operation %d\n", opcode);
776  return -1;
777  }
778  mmco[i].long_arg = long_arg;
779  }
780 
781  if (opcode > (unsigned) MMCO_LONG) {
783  "illegal memory management control operation %d\n",
784  opcode);
785  return -1;
786  }
787  if (opcode == MMCO_END)
788  break;
789  }
790  mmco_index = i;
791  } else {
792  if (first_slice) {
793  ret = ff_generate_sliding_window_mmcos(h, first_slice);
794  if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
795  return ret;
796  }
797  mmco_index = -1;
798  }
799  }
800 
801  if (first_slice && mmco_index != -1) {
802  h->mmco_index = mmco_index;
803  } else if (!first_slice && mmco_index >= 0 &&
804  (mmco_index != h->mmco_index ||
805  check_opcodes(h->mmco, mmco_temp, mmco_index))) {
807  "Inconsistent MMCO state between slices [%d, %d]\n",
808  mmco_index, h->mmco_index);
809  return AVERROR_INVALIDDATA;
810  }
811 
812  return 0;
813 }